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 0x020f 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x020f, 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 0x70a08231 0019 11 GT 001A 61 PUSH2 0x0118 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0118, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0x95d89b41 0024 11 GT 0025 61 PUSH2 0x00a0 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a0, if 0x95d89b41 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0x95d89b41 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xb88d4fde 002F 11 GT 0030 61 PUSH2 0x006f 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xb88d4fde > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xb88d4fde > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xb88d4fde 003A 14 EQ 003B 61 PUSH2 0x05d5 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d5, if 0xb88d4fde == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xb88d4fde == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xc87b56dd 0045 14 EQ 0046 61 PUSH2 0x05f5 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f5, if 0xc87b56dd == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xc87b56dd == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xd431b1ac 0050 14 EQ 0051 61 PUSH2 0x0615 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0615, if 0xd431b1ac == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xd431b1ac == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xe985e9c5 005B 14 EQ 005C 61 PUSH2 0x062a 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x062a, 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 0x0673 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0673, 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 0xb88d4fde > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0x95d89b41 0076 14 EQ 0077 61 PUSH2 0x0560 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0560, if 0x95d89b41 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0x95d89b41 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0x9fce84ca 0081 14 EQ 0082 61 PUSH2 0x0575 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0575, if 0x9fce84ca == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0x9fce84ca == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xa0712d68 008C 14 EQ 008D 61 PUSH2 0x05a2 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a2, if 0xa0712d68 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xa0712d68 == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xa22cb465 0097 14 EQ 0098 61 PUSH2 0x05b5 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b5, if 0xa22cb465 == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xa22cb465 == stack[-1] // Inputs[1] { @009F memory[0x00:0x00] } 009C 60 PUSH1 0x00 009E 80 DUP1 009F FD *REVERT // Stack delta = +0 // Outputs[1] { @009F revert(memory[0x00:0x00]); } // Block terminates label_00A0: // Incoming jump from 0x0028, if 0x95d89b41 > stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A0 5B JUMPDEST 00A1 80 DUP1 00A2 63 PUSH4 0x7ff9b596 00A7 11 GT 00A8 61 PUSH2 0x00e7 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00e7, if 0x7ff9b596 > stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x7ff9b596 > stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x7ff9b596 00B2 14 EQ 00B3 61 PUSH2 0x04d2 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d2, if 0x7ff9b596 == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x7ff9b596 == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x82651bd0 00BD 14 EQ 00BE 61 PUSH2 0x04e8 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e8, if 0x82651bd0 == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x82651bd0 == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x86758912 00C8 14 EQ 00C9 61 PUSH2 0x0502 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0502, if 0x86758912 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x86758912 == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0x8da5cb5b 00D3 14 EQ 00D4 61 PUSH2 0x0522 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0522, if 0x8da5cb5b == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0x91b7f5ed 00DE 14 EQ 00DF 61 PUSH2 0x0540 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0540, if 0x91b7f5ed == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0x91b7f5ed == stack[-1] // Inputs[1] { @00E6 memory[0x00:0x00] } 00E3 60 PUSH1 0x00 00E5 80 DUP1 00E6 FD *REVERT // Stack delta = +0 // Outputs[1] { @00E6 revert(memory[0x00:0x00]); } // Block terminates label_00E7: // Incoming jump from 0x00AB, if 0x7ff9b596 > stack[-1] // Inputs[1] { @00E8 stack[-1] } 00E7 5B JUMPDEST 00E8 80 DUP1 00E9 63 PUSH4 0x70a08231 00EE 14 EQ 00EF 61 PUSH2 0x0468 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0468, if 0x70a08231 == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x70a08231 == stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F3 80 DUP1 00F4 63 PUSH4 0x715018a6 00F9 14 EQ 00FA 61 PUSH2 0x0488 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0488, 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 0x760a8c2a 0104 14 EQ 0105 61 PUSH2 0x049d 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x049d, if 0x760a8c2a == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x760a8c2a == stack[-1] // Inputs[1] { @0109 stack[-1] } 0109 80 DUP1 010A 63 PUSH4 0x76dcb19d 010F 14 EQ 0110 61 PUSH2 0x04b2 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b2, if 0x76dcb19d == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x76dcb19d == stack[-1] // Inputs[1] { @0117 memory[0x00:0x00] } 0114 60 PUSH1 0x00 0116 80 DUP1 0117 FD *REVERT // Stack delta = +0 // Outputs[1] { @0117 revert(memory[0x00:0x00]); } // Block terminates label_0118: // Incoming jump from 0x001D, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0119 stack[-1] } 0118 5B JUMPDEST 0119 80 DUP1 011A 63 PUSH4 0x2eb4a7ab 011F 11 GT 0120 61 PUSH2 0x019b 0123 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x019b, if 0x2eb4a7ab > stack[-1] label_0124: // Incoming jump from 0x0123, if not 0x2eb4a7ab > stack[-1] // Inputs[1] { @0124 stack[-1] } 0124 80 DUP1 0125 63 PUSH4 0x5c975abb 012A 11 GT 012B 61 PUSH2 0x016a 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x016a, if 0x5c975abb > stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x5c975abb > stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x5c975abb 0135 14 EQ 0136 61 PUSH2 0x03e5 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e5, if 0x5c975abb == stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x5c975abb == stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x5d8c2efd 0140 14 EQ 0141 61 PUSH2 0x03ff 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ff, if 0x5d8c2efd == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x5d8c2efd == stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x6352211e 014B 14 EQ 014C 61 PUSH2 0x041f 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x041f, if 0x6352211e == stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x6352211e == stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x65456827 0156 14 EQ 0157 61 PUSH2 0x043f 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x043f, if 0x65456827 == stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x65456827 == stack[-1] // Inputs[1] { @015B stack[-1] } 015B 80 DUP1 015C 63 PUSH4 0x6cfc5a99 0161 14 EQ 0162 61 PUSH2 0x0455 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0455, if 0x6cfc5a99 == stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x6cfc5a99 == stack[-1] // Inputs[1] { @0169 memory[0x00:0x00] } 0166 60 PUSH1 0x00 0168 80 DUP1 0169 FD *REVERT // Stack delta = +0 // Outputs[1] { @0169 revert(memory[0x00:0x00]); } // Block terminates label_016A: // Incoming jump from 0x012E, if 0x5c975abb > stack[-1] // Inputs[1] { @016B stack[-1] } 016A 5B JUMPDEST 016B 80 DUP1 016C 63 PUSH4 0x2eb4a7ab 0171 14 EQ 0172 61 PUSH2 0x037a 0175 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037a, if 0x2eb4a7ab == stack[-1] label_0176: // Incoming jump from 0x0175, if not 0x2eb4a7ab == stack[-1] // Inputs[1] { @0176 stack[-1] } 0176 80 DUP1 0177 63 PUSH4 0x3ccfd60b 017C 14 EQ 017D 61 PUSH2 0x0390 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0390, if 0x3ccfd60b == stack[-1] label_0181: // Incoming jump from 0x0180, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @0181 stack[-1] } 0181 80 DUP1 0182 63 PUSH4 0x42842e0e 0187 14 EQ 0188 61 PUSH2 0x03a5 018B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a5, if 0x42842e0e == stack[-1] label_018C: // Incoming jump from 0x018B, if not 0x42842e0e == stack[-1] // Inputs[1] { @018C stack[-1] } 018C 80 DUP1 018D 63 PUSH4 0x55f804b3 0192 14 EQ 0193 61 PUSH2 0x03c5 0196 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c5, if 0x55f804b3 == stack[-1] label_0197: // Incoming jump from 0x0196, if not 0x55f804b3 == stack[-1] // Inputs[1] { @019A memory[0x00:0x00] } 0197 60 PUSH1 0x00 0199 80 DUP1 019A FD *REVERT // Stack delta = +0 // Outputs[1] { @019A revert(memory[0x00:0x00]); } // Block terminates label_019B: // Incoming jump from 0x0123, if 0x2eb4a7ab > stack[-1] // Inputs[1] { @019C stack[-1] } 019B 5B JUMPDEST 019C 80 DUP1 019D 63 PUSH4 0x0a398b88 01A2 11 GT 01A3 61 PUSH2 0x01e2 01A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e2, if 0x0a398b88 > stack[-1] label_01A7: // Incoming jump from 0x01A6, if not 0x0a398b88 > stack[-1] // Inputs[1] { @01A7 stack[-1] } 01A7 80 DUP1 01A8 63 PUSH4 0x0a398b88 01AD 14 EQ 01AE 61 PUSH2 0x02c5 01B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c5, if 0x0a398b88 == stack[-1] label_01B2: // Incoming jump from 0x01B1, if not 0x0a398b88 == stack[-1] // Inputs[1] { @01B2 stack[-1] } 01B2 80 DUP1 01B3 63 PUSH4 0x1141d7de 01B8 14 EQ 01B9 61 PUSH2 0x0309 01BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0309, if 0x1141d7de == stack[-1] label_01BD: // Incoming jump from 0x01BC, if not 0x1141d7de == stack[-1] // Inputs[1] { @01BD stack[-1] } 01BD 80 DUP1 01BE 63 PUSH4 0x18160ddd 01C3 14 EQ 01C4 61 PUSH2 0x031e 01C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x031e, if 0x18160ddd == stack[-1] label_01C8: // Incoming jump from 0x01C7, if not 0x18160ddd == stack[-1] // Inputs[1] { @01C8 stack[-1] } 01C8 80 DUP1 01C9 63 PUSH4 0x22f3e2d4 01CE 14 EQ 01CF 61 PUSH2 0x033b 01D2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033b, if 0x22f3e2d4 == stack[-1] label_01D3: // Incoming jump from 0x01D2, if not 0x22f3e2d4 == stack[-1] // Inputs[1] { @01D3 stack[-1] } 01D3 80 DUP1 01D4 63 PUSH4 0x23b872dd 01D9 14 EQ 01DA 61 PUSH2 0x035a 01DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x035a, if 0x23b872dd == stack[-1] label_01DE: // Incoming jump from 0x01DD, if not 0x23b872dd == stack[-1] // Inputs[1] { @01E1 memory[0x00:0x00] } 01DE 60 PUSH1 0x00 01E0 80 DUP1 01E1 FD *REVERT // Stack delta = +0 // Outputs[1] { @01E1 revert(memory[0x00:0x00]); } // Block terminates label_01E2: // Incoming jump from 0x01A6, if 0x0a398b88 > stack[-1] // Inputs[1] { @01E3 stack[-1] } 01E2 5B JUMPDEST 01E3 80 DUP1 01E4 63 PUSH4 0x01ffc9a7 01E9 14 EQ 01EA 61 PUSH2 0x0214 01ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0214, if 0x01ffc9a7 == stack[-1] label_01EE: // Incoming jump from 0x01ED, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01EE stack[-1] } 01EE 80 DUP1 01EF 63 PUSH4 0x06fdde03 01F4 14 EQ 01F5 61 PUSH2 0x0249 01F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0249, if 0x06fdde03 == stack[-1] label_01F9: // Incoming jump from 0x01F8, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01F9 stack[-1] } 01F9 80 DUP1 01FA 63 PUSH4 0x081812fc 01FF 14 EQ 0200 61 PUSH2 0x026b 0203 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026b, if 0x081812fc == stack[-1] label_0204: // Incoming jump from 0x0203, if not 0x081812fc == stack[-1] // Inputs[1] { @0204 stack[-1] } 0204 80 DUP1 0205 63 PUSH4 0x095ea7b3 020A 14 EQ 020B 61 PUSH2 0x02a3 020E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a3, if 0x095ea7b3 == stack[-1] label_020F: // Incoming jump from 0x020E, if not 0x095ea7b3 == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @0213 memory[0x00:0x00] } 020F 5B JUMPDEST 0210 60 PUSH1 0x00 0212 80 DUP1 0213 FD *REVERT // Stack delta = +0 // Outputs[1] { @0213 revert(memory[0x00:0x00]); } // Block terminates label_0214: // Incoming jump from 0x01ED, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0215 msg.value } 0214 5B JUMPDEST 0215 34 CALLVALUE 0216 80 DUP1 0217 15 ISZERO 0218 61 PUSH2 0x0220 021B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0215 stack[0] = msg.value } // Block ends with conditional jump to 0x0220, if !msg.value label_021C: // Incoming jump from 0x021B, if not !msg.value // Inputs[1] { @021F memory[0x00:0x00] } 021C 60 PUSH1 0x00 021E 80 DUP1 021F FD *REVERT // Stack delta = +0 // Outputs[1] { @021F revert(memory[0x00:0x00]); } // Block terminates label_0220: // Incoming jump from 0x021B, if !msg.value // Inputs[1] { @0228 msg.data.length } 0220 5B JUMPDEST 0221 50 POP 0222 61 PUSH2 0x0234 0225 61 PUSH2 0x022f 0228 36 CALLDATASIZE 0229 60 PUSH1 0x04 022B 61 PUSH2 0x1c54 022E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0222 stack[-1] = 0x0234 // @0225 stack[0] = 0x022f // @0228 stack[1] = msg.data.length // @0229 stack[2] = 0x04 // } // Block ends with call to 0x1c54, returns to 0x022F label_022F: // Incoming return from call to 0x1C54 at 0x022E 022F 5B JUMPDEST 0230 61 PUSH2 0x0693 0233 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0693 label_0234: // Incoming return from call to 0x0645 at 0x0644 // Incoming jump from 0x0359 // Incoming return from call to 0x022F at 0x022E // Incoming jump from 0x0501 // Incoming jump from 0x03FE // Inputs[4] // { // @0237 memory[0x40:0x60] // @0238 stack[-1] // @0243 memory[0x40:0x60] // @0248 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0234 5B JUMPDEST 0235 60 PUSH1 0x40 0237 51 MLOAD 0238 90 SWAP1 0239 15 ISZERO 023A 15 ISZERO 023B 81 DUP2 023C 52 MSTORE 023D 60 PUSH1 0x20 023F 01 ADD 0240 5B JUMPDEST 0241 60 PUSH1 0x40 0243 51 MLOAD 0244 80 DUP1 0245 91 SWAP2 0246 03 SUB 0247 90 SWAP1 0248 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @023C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0248 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0249: // Incoming jump from 0x01F8, if 0x06fdde03 == stack[-1] // Inputs[1] { @024A msg.value } 0249 5B JUMPDEST 024A 34 CALLVALUE 024B 80 DUP1 024C 15 ISZERO 024D 61 PUSH2 0x0255 0250 57 *JUMPI // Stack delta = +1 // Outputs[1] { @024A stack[0] = msg.value } // Block ends with conditional jump to 0x0255, if !msg.value label_0251: // Incoming jump from 0x0250, if not !msg.value // Inputs[1] { @0254 memory[0x00:0x00] } 0251 60 PUSH1 0x00 0253 80 DUP1 0254 FD *REVERT // Stack delta = +0 // Outputs[1] { @0254 revert(memory[0x00:0x00]); } // Block terminates label_0255: // Incoming jump from 0x0250, if !msg.value 0255 5B JUMPDEST 0256 50 POP 0257 61 PUSH2 0x025e 025A 61 PUSH2 0x06e5 025D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0257 stack[-1] = 0x025e } // Block ends with call to 0x06e5, returns to 0x025E label_025E: // Incoming return from call to 0x0DAA at 0x0574 // Incoming return from call to 0x0849 at 0x031D // Incoming return from call to 0x0610 at 0x060F // Incoming return from call to 0x0610 at 0x060F // Incoming return from call to 0x06E5 at 0x025D // Inputs[2] // { // @0261 memory[0x40:0x60] // @0265 stack[-1] // } 025E 5B JUMPDEST 025F 60 PUSH1 0x40 0261 51 MLOAD 0262 61 PUSH2 0x0240 0265 91 SWAP2 0266 90 SWAP1 0267 61 PUSH2 0x1cd0 026A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0265 stack[-1] = 0x0240 // @0266 stack[1] = memory[0x40:0x60] // @0266 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1cd0 label_026B: // Incoming jump from 0x0203, if 0x081812fc == stack[-1] // Inputs[1] { @026C msg.value } 026B 5B JUMPDEST 026C 34 CALLVALUE 026D 80 DUP1 026E 15 ISZERO 026F 61 PUSH2 0x0277 0272 57 *JUMPI // Stack delta = +1 // Outputs[1] { @026C stack[0] = msg.value } // Block ends with conditional jump to 0x0277, if !msg.value label_0273: // Incoming jump from 0x0272, if not !msg.value // Inputs[1] { @0276 memory[0x00:0x00] } 0273 60 PUSH1 0x00 0275 80 DUP1 0276 FD *REVERT // Stack delta = +0 // Outputs[1] { @0276 revert(memory[0x00:0x00]); } // Block terminates label_0277: // Incoming jump from 0x0272, if !msg.value // Inputs[1] { @027F msg.data.length } 0277 5B JUMPDEST 0278 50 POP 0279 61 PUSH2 0x028b 027C 61 PUSH2 0x0286 027F 36 CALLDATASIZE 0280 60 PUSH1 0x04 0282 61 PUSH2 0x1ce3 0285 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0279 stack[-1] = 0x028b // @027C stack[0] = 0x0286 // @027F stack[1] = msg.data.length // @0280 stack[2] = 0x04 // } // Block ends with call to 0x1ce3, returns to 0x0286 label_0286: // Incoming return from call to 0x1CE3 at 0x0285 0286 5B JUMPDEST 0287 61 PUSH2 0x0777 028A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0777 label_028B: // Incoming jump from 0x053F // Incoming return from call to 0x0286 at 0x0285 // Incoming return from call to 0x043A at 0x0439 // Inputs[2] // { // @028E memory[0x40:0x60] // @0298 stack[-1] // } 028B 5B JUMPDEST 028C 60 PUSH1 0x40 028E 51 MLOAD 028F 60 PUSH1 0x01 0291 60 PUSH1 0x01 0293 60 PUSH1 0xa0 0295 1B SHL 0296 03 SUB 0297 90 SWAP1 0298 91 SWAP2 0299 16 AND 029A 81 DUP2 029B 52 MSTORE 029C 60 PUSH1 0x20 029E 01 ADD 029F 61 PUSH2 0x0240 02A2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @029B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @029E stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0240 label_02A3: // Incoming jump from 0x020E, if 0x095ea7b3 == 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 0x1d18 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 0x1d18, returns to 0x02BE label_02BE: // Incoming return from call to 0x1D18 at 0x02BD 02BE 5B JUMPDEST 02BF 61 PUSH2 0x07bb 02C2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07bb label_02C3: // Incoming return from call to 0x11D1 at 0x0629 // Incoming return from call to 0x0CD1 at 0x04B1 // Incoming return from call to 0x05D0 at 0x05CF // Incoming return from call to 0x0C9B at 0x049C // Incoming return from call to 0x08E2 at 0x03A4 // Incoming return from call to 0x051D at 0x051C // Incoming return from call to 0x055B at 0x055A 02C3 5B JUMPDEST 02C4 00 *STOP // Stack delta = +0 // Outputs[1] { @02C4 stop(); } // Block terminates label_02C5: // Incoming jump from 0x01B1, if 0x0a398b88 == stack[-1] // Inputs[1] { @02C6 msg.value } 02C5 5B JUMPDEST 02C6 34 CALLVALUE 02C7 80 DUP1 02C8 15 ISZERO 02C9 61 PUSH2 0x02d1 02CC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C6 stack[0] = msg.value } // Block ends with conditional jump to 0x02d1, if !msg.value label_02CD: // Incoming jump from 0x02CC, if not !msg.value // Inputs[1] { @02D0 memory[0x00:0x00] } 02CD 60 PUSH1 0x00 02CF 80 DUP1 02D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D0 revert(memory[0x00:0x00]); } // Block terminates label_02D1: // Incoming jump from 0x02CC, if !msg.value // Inputs[1] { @02D9 msg.data.length } 02D1 5B JUMPDEST 02D2 50 POP 02D3 61 PUSH2 0x02fb 02D6 61 PUSH2 0x02e0 02D9 36 CALLDATASIZE 02DA 60 PUSH1 0x04 02DC 61 PUSH2 0x1d42 02DF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02D3 stack[-1] = 0x02fb // @02D6 stack[0] = 0x02e0 // @02D9 stack[1] = msg.data.length // @02DA stack[2] = 0x04 // } // Block ends with call to 0x1d42, returns to 0x02E0 label_02E0: // Incoming return from call to 0x1D42 at 0x02DF // Inputs[4] // { // @02E9 stack[-1] // @02F7 memory[0x00:0x40] // @02F8 storage[keccak256(memory[0x00:0x40])] // @02F9 stack[-2] // } 02E0 5B JUMPDEST 02E1 60 PUSH1 0x01 02E3 60 PUSH1 0x01 02E5 60 PUSH1 0xa0 02E7 1B SHL 02E8 03 SUB 02E9 16 AND 02EA 60 PUSH1 0x00 02EC 90 SWAP1 02ED 81 DUP2 02EE 52 MSTORE 02EF 60 PUSH1 0x14 02F1 60 PUSH1 0x20 02F3 52 MSTORE 02F4 60 PUSH1 0x40 02F6 90 SWAP1 02F7 20 SHA3 02F8 54 SLOAD 02F9 90 SWAP1 02FA 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @02EE memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @02F3 memory[0x20:0x40] = 0x14 // @02F9 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_02FB: // Incoming jump from 0x038F // Incoming return from call to 0x02E0 at 0x02DF // Incoming return from call to 0x0483 at 0x0482 // Incoming return from call to 0x0590 at 0x058F // Incoming jump from 0x0454 // Incoming jump from 0x04E7 // Incoming jump from 0x033A // Inputs[2] // { // @02FE memory[0x40:0x60] // @02FF stack[-1] // } 02FB 5B JUMPDEST 02FC 60 PUSH1 0x40 02FE 51 MLOAD 02FF 90 SWAP1 0300 81 DUP2 0301 52 MSTORE 0302 60 PUSH1 0x20 0304 01 ADD 0305 61 PUSH2 0x0240 0308 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0301 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0304 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0240 label_0309: // Incoming jump from 0x01BC, if 0x1141d7de == stack[-1] // Inputs[1] { @030A msg.value } 0309 5B JUMPDEST 030A 34 CALLVALUE 030B 80 DUP1 030C 15 ISZERO 030D 61 PUSH2 0x0315 0310 57 *JUMPI // Stack delta = +1 // Outputs[1] { @030A stack[0] = msg.value } // Block ends with conditional jump to 0x0315, if !msg.value label_0311: // Incoming jump from 0x0310, if not !msg.value // Inputs[1] { @0314 memory[0x00:0x00] } 0311 60 PUSH1 0x00 0313 80 DUP1 0314 FD *REVERT // Stack delta = +0 // Outputs[1] { @0314 revert(memory[0x00:0x00]); } // Block terminates label_0315: // Incoming jump from 0x0310, if !msg.value 0315 5B JUMPDEST 0316 50 POP 0317 61 PUSH2 0x025e 031A 61 PUSH2 0x0849 031D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0317 stack[-1] = 0x025e } // Block ends with call to 0x0849, returns to 0x025E label_031E: // Incoming jump from 0x01C7, if 0x18160ddd == stack[-1] // Inputs[1] { @031F msg.value } 031E 5B JUMPDEST 031F 34 CALLVALUE 0320 80 DUP1 0321 15 ISZERO 0322 61 PUSH2 0x032a 0325 57 *JUMPI // Stack delta = +1 // Outputs[1] { @031F stack[0] = msg.value } // Block ends with conditional jump to 0x032a, if !msg.value label_0326: // Incoming jump from 0x0325, if not !msg.value // Inputs[1] { @0329 memory[0x00:0x00] } 0326 60 PUSH1 0x00 0328 80 DUP1 0329 FD *REVERT // Stack delta = +0 // Outputs[1] { @0329 revert(memory[0x00:0x00]); } // Block terminates label_032A: // Incoming jump from 0x0325, if !msg.value // Inputs[2] // { // @032E storage[0x01] // @0331 storage[0x00] // } 032A 5B JUMPDEST 032B 50 POP 032C 60 PUSH1 0x01 032E 54 SLOAD 032F 60 PUSH1 0x00 0331 54 SLOAD 0332 03 SUB 0333 60 PUSH1 0x00 0335 19 NOT 0336 01 ADD 0337 61 PUSH2 0x02fb 033A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0336 stack[-1] = ~0x00 + (storage[0x00] - storage[0x01]) } // Block ends with unconditional jump to 0x02fb label_033B: // Incoming jump from 0x01D2, if 0x22f3e2d4 == stack[-1] // Inputs[1] { @033C msg.value } 033B 5B JUMPDEST 033C 34 CALLVALUE 033D 80 DUP1 033E 15 ISZERO 033F 61 PUSH2 0x0347 0342 57 *JUMPI // Stack delta = +1 // Outputs[1] { @033C stack[0] = msg.value } // Block ends with conditional jump to 0x0347, if !msg.value label_0343: // Incoming jump from 0x0342, if not !msg.value // Inputs[1] { @0346 memory[0x00:0x00] } 0343 60 PUSH1 0x00 0345 80 DUP1 0346 FD *REVERT // Stack delta = +0 // Outputs[1] { @0346 revert(memory[0x00:0x00]); } // Block terminates label_0347: // Incoming jump from 0x0342, if !msg.value // Inputs[1] { @034B storage[0x0d] } 0347 5B JUMPDEST 0348 50 POP 0349 60 PUSH1 0x0d 034B 54 SLOAD 034C 61 PUSH2 0x0234 034F 90 SWAP1 0350 61 PUSH2 0x0100 0353 90 SWAP1 0354 04 DIV 0355 60 PUSH1 0xff 0357 16 AND 0358 81 DUP2 0359 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @034F stack[-1] = 0x0234 // @0357 stack[0] = 0xff & storage[0x0d] / 0x0100 // } // Block ends with unconditional jump to 0x0234 label_035A: // Incoming jump from 0x01DD, if 0x23b872dd == stack[-1] // Inputs[1] { @035B msg.value } 035A 5B JUMPDEST 035B 34 CALLVALUE 035C 80 DUP1 035D 15 ISZERO 035E 61 PUSH2 0x0366 0361 57 *JUMPI // Stack delta = +1 // Outputs[1] { @035B stack[0] = msg.value } // Block ends with conditional jump to 0x0366, if !msg.value label_0362: // Incoming jump from 0x0361, if not !msg.value // Inputs[1] { @0365 memory[0x00:0x00] } 0362 60 PUSH1 0x00 0364 80 DUP1 0365 FD *REVERT // Stack delta = +0 // Outputs[1] { @0365 revert(memory[0x00:0x00]); } // Block terminates label_0366: // Incoming jump from 0x0361, if !msg.value // Inputs[1] { @036E msg.data.length } 0366 5B JUMPDEST 0367 50 POP 0368 61 PUSH2 0x02c3 036B 61 PUSH2 0x0375 036E 36 CALLDATASIZE 036F 60 PUSH1 0x04 0371 61 PUSH2 0x1d5d 0374 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0368 stack[-1] = 0x02c3 // @036B stack[0] = 0x0375 // @036E stack[1] = msg.data.length // @036F stack[2] = 0x04 // } // Block ends with call to 0x1d5d, returns to 0x0375 label_0375: // Incoming return from call to 0x1D5D at 0x0374 0375 5B JUMPDEST 0376 61 PUSH2 0x08d7 0379 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08d7 label_037A: // Incoming jump from 0x0175, if 0x2eb4a7ab == stack[-1] // Inputs[1] { @037B msg.value } 037A 5B JUMPDEST 037B 34 CALLVALUE 037C 80 DUP1 037D 15 ISZERO 037E 61 PUSH2 0x0386 0381 57 *JUMPI // Stack delta = +1 // Outputs[1] { @037B stack[0] = msg.value } // Block ends with conditional jump to 0x0386, if !msg.value label_0382: // Incoming jump from 0x0381, if not !msg.value // Inputs[1] { @0385 memory[0x00:0x00] } 0382 60 PUSH1 0x00 0384 80 DUP1 0385 FD *REVERT // Stack delta = +0 // Outputs[1] { @0385 revert(memory[0x00:0x00]); } // Block terminates label_0386: // Incoming jump from 0x0381, if !msg.value // Inputs[1] { @038D storage[0x09] } 0386 5B JUMPDEST 0387 50 POP 0388 61 PUSH2 0x02fb 038B 60 PUSH1 0x09 038D 54 SLOAD 038E 81 DUP2 038F 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0388 stack[-1] = 0x02fb // @038D stack[0] = storage[0x09] // } // Block ends with unconditional jump to 0x02fb label_0390: // Incoming jump from 0x0180, if 0x3ccfd60b == stack[-1] // Inputs[1] { @0391 msg.value } 0390 5B JUMPDEST 0391 34 CALLVALUE 0392 80 DUP1 0393 15 ISZERO 0394 61 PUSH2 0x039c 0397 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0391 stack[0] = msg.value } // Block ends with conditional jump to 0x039c, if !msg.value label_0398: // Incoming jump from 0x0397, if not !msg.value // Inputs[1] { @039B memory[0x00:0x00] } 0398 60 PUSH1 0x00 039A 80 DUP1 039B FD *REVERT // Stack delta = +0 // Outputs[1] { @039B revert(memory[0x00:0x00]); } // Block terminates label_039C: // Incoming jump from 0x0397, if !msg.value 039C 5B JUMPDEST 039D 50 POP 039E 61 PUSH2 0x02c3 03A1 61 PUSH2 0x08e2 03A4 56 *JUMP // Stack delta = +0 // Outputs[1] { @039E stack[-1] = 0x02c3 } // Block ends with call to 0x08e2, returns to 0x02C3 label_03A5: // Incoming jump from 0x018B, if 0x42842e0e == stack[-1] // Inputs[1] { @03A6 msg.value } 03A5 5B JUMPDEST 03A6 34 CALLVALUE 03A7 80 DUP1 03A8 15 ISZERO 03A9 61 PUSH2 0x03b1 03AC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03A6 stack[0] = msg.value } // Block ends with conditional jump to 0x03b1, if !msg.value label_03AD: // Incoming jump from 0x03AC, if not !msg.value // Inputs[1] { @03B0 memory[0x00:0x00] } 03AD 60 PUSH1 0x00 03AF 80 DUP1 03B0 FD *REVERT // Stack delta = +0 // Outputs[1] { @03B0 revert(memory[0x00:0x00]); } // Block terminates label_03B1: // Incoming jump from 0x03AC, if !msg.value // Inputs[1] { @03B9 msg.data.length } 03B1 5B JUMPDEST 03B2 50 POP 03B3 61 PUSH2 0x02c3 03B6 61 PUSH2 0x03c0 03B9 36 CALLDATASIZE 03BA 60 PUSH1 0x04 03BC 61 PUSH2 0x1d5d 03BF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03B3 stack[-1] = 0x02c3 // @03B6 stack[0] = 0x03c0 // @03B9 stack[1] = msg.data.length // @03BA stack[2] = 0x04 // } // Block ends with call to 0x1d5d, returns to 0x03C0 label_03C0: // Incoming return from call to 0x1D5D at 0x03BF 03C0 5B JUMPDEST 03C1 61 PUSH2 0x0944 03C4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0944 label_03C5: // Incoming jump from 0x0196, if 0x55f804b3 == stack[-1] // Inputs[1] { @03C6 msg.value } 03C5 5B JUMPDEST 03C6 34 CALLVALUE 03C7 80 DUP1 03C8 15 ISZERO 03C9 61 PUSH2 0x03d1 03CC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C6 stack[0] = msg.value } // Block ends with conditional jump to 0x03d1, if !msg.value label_03CD: // Incoming jump from 0x03CC, if not !msg.value // Inputs[1] { @03D0 memory[0x00:0x00] } 03CD 60 PUSH1 0x00 03CF 80 DUP1 03D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D0 revert(memory[0x00:0x00]); } // Block terminates label_03D1: // Incoming jump from 0x03CC, if !msg.value // Inputs[1] { @03D9 msg.data.length } 03D1 5B JUMPDEST 03D2 50 POP 03D3 61 PUSH2 0x02c3 03D6 61 PUSH2 0x03e0 03D9 36 CALLDATASIZE 03DA 60 PUSH1 0x04 03DC 61 PUSH2 0x1e25 03DF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03D3 stack[-1] = 0x02c3 // @03D6 stack[0] = 0x03e0 // @03D9 stack[1] = msg.data.length // @03DA stack[2] = 0x04 // } // Block ends with call to 0x1e25, returns to 0x03E0 label_03E0: // Incoming return from call to 0x1E25 at 0x03DF 03E0 5B JUMPDEST 03E1 61 PUSH2 0x095f 03E4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x095f label_03E5: // Incoming jump from 0x0139, if 0x5c975abb == stack[-1] // Inputs[1] { @03E6 msg.value } 03E5 5B JUMPDEST 03E6 34 CALLVALUE 03E7 80 DUP1 03E8 15 ISZERO 03E9 61 PUSH2 0x03f1 03EC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E6 stack[0] = msg.value } // Block ends with conditional jump to 0x03f1, if !msg.value label_03ED: // Incoming jump from 0x03EC, if not !msg.value // Inputs[1] { @03F0 memory[0x00:0x00] } 03ED 60 PUSH1 0x00 03EF 80 DUP1 03F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F0 revert(memory[0x00:0x00]); } // Block terminates label_03F1: // Incoming jump from 0x03EC, if !msg.value // Inputs[1] { @03F5 storage[0x0d] } 03F1 5B JUMPDEST 03F2 50 POP 03F3 60 PUSH1 0x0d 03F5 54 SLOAD 03F6 61 PUSH2 0x0234 03F9 90 SWAP1 03FA 60 PUSH1 0xff 03FC 16 AND 03FD 81 DUP2 03FE 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03F9 stack[-1] = 0x0234 // @03FC stack[0] = 0xff & storage[0x0d] // } // Block ends with unconditional jump to 0x0234 label_03FF: // Incoming jump from 0x0144, if 0x5d8c2efd == stack[-1] // Inputs[1] { @0400 msg.value } 03FF 5B JUMPDEST 0400 34 CALLVALUE 0401 80 DUP1 0402 15 ISZERO 0403 61 PUSH2 0x040b 0406 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0400 stack[0] = msg.value } // Block ends with conditional jump to 0x040b, if !msg.value label_0407: // Incoming jump from 0x0406, if not !msg.value // Inputs[1] { @040A memory[0x00:0x00] } 0407 60 PUSH1 0x00 0409 80 DUP1 040A FD *REVERT // Stack delta = +0 // Outputs[1] { @040A revert(memory[0x00:0x00]); } // Block terminates label_040B: // Incoming jump from 0x0406, if !msg.value // Inputs[1] { @0413 msg.data.length } 040B 5B JUMPDEST 040C 50 POP 040D 61 PUSH2 0x02c3 0410 61 PUSH2 0x041a 0413 36 CALLDATASIZE 0414 60 PUSH1 0x04 0416 61 PUSH2 0x1e25 0419 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @040D stack[-1] = 0x02c3 // @0410 stack[0] = 0x041a // @0413 stack[1] = msg.data.length // @0414 stack[2] = 0x04 // } // Block ends with call to 0x1e25, returns to 0x041A label_041A: // Incoming return from call to 0x1E25 at 0x0419 041A 5B JUMPDEST 041B 61 PUSH2 0x09a0 041E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09a0 label_041F: // Incoming jump from 0x014F, if 0x6352211e == stack[-1] // Inputs[1] { @0420 msg.value } 041F 5B JUMPDEST 0420 34 CALLVALUE 0421 80 DUP1 0422 15 ISZERO 0423 61 PUSH2 0x042b 0426 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0420 stack[0] = msg.value } // Block ends with conditional jump to 0x042b, if !msg.value label_0427: // Incoming jump from 0x0426, if not !msg.value // Inputs[1] { @042A memory[0x00:0x00] } 0427 60 PUSH1 0x00 0429 80 DUP1 042A FD *REVERT // Stack delta = +0 // Outputs[1] { @042A revert(memory[0x00:0x00]); } // Block terminates label_042B: // Incoming jump from 0x0426, if !msg.value // Inputs[1] { @0433 msg.data.length } 042B 5B JUMPDEST 042C 50 POP 042D 61 PUSH2 0x028b 0430 61 PUSH2 0x043a 0433 36 CALLDATASIZE 0434 60 PUSH1 0x04 0436 61 PUSH2 0x1ce3 0439 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @042D stack[-1] = 0x028b // @0430 stack[0] = 0x043a // @0433 stack[1] = msg.data.length // @0434 stack[2] = 0x04 // } // Block ends with call to 0x1ce3, returns to 0x043A label_043A: // Incoming return from call to 0x1CE3 at 0x0439 043A 5B JUMPDEST 043B 61 PUSH2 0x09ef 043E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09ef label_043F: // Incoming jump from 0x015A, if 0x65456827 == stack[-1] // Inputs[1] { @0440 msg.value } 043F 5B JUMPDEST 0440 34 CALLVALUE 0441 80 DUP1 0442 15 ISZERO 0443 61 PUSH2 0x044b 0446 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0440 stack[0] = msg.value } // Block ends with conditional jump to 0x044b, if !msg.value label_0447: // Incoming jump from 0x0446, if not !msg.value // Inputs[1] { @044A memory[0x00:0x00] } 0447 60 PUSH1 0x00 0449 80 DUP1 044A FD *REVERT // Stack delta = +0 // Outputs[1] { @044A revert(memory[0x00:0x00]); } // Block terminates label_044B: // Incoming jump from 0x0446, if !msg.value // Inputs[1] { @0452 storage[0x12] } 044B 5B JUMPDEST 044C 50 POP 044D 61 PUSH2 0x02fb 0450 60 PUSH1 0x12 0452 54 SLOAD 0453 81 DUP2 0454 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @044D stack[-1] = 0x02fb // @0452 stack[0] = storage[0x12] // } // Block ends with unconditional jump to 0x02fb label_0455: // Incoming jump from 0x0165, if 0x6cfc5a99 == stack[-1] // Inputs[1] { @045C msg.data.length } 0455 5B JUMPDEST 0456 61 PUSH2 0x02c3 0459 61 PUSH2 0x0463 045C 36 CALLDATASIZE 045D 60 PUSH1 0x04 045F 61 PUSH2 0x1e6e 0462 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0456 stack[0] = 0x02c3 // @0459 stack[1] = 0x0463 // @045C stack[2] = msg.data.length // @045D stack[3] = 0x04 // } // Block ends with call to 0x1e6e, returns to 0x0463 label_0463: // Incoming return from call to 0x1E6E at 0x0462 0463 5B JUMPDEST 0464 61 PUSH2 0x0a01 0467 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a01 label_0468: // Incoming jump from 0x00F2, if 0x70a08231 == stack[-1] // Inputs[1] { @0469 msg.value } 0468 5B JUMPDEST 0469 34 CALLVALUE 046A 80 DUP1 046B 15 ISZERO 046C 61 PUSH2 0x0474 046F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0469 stack[0] = msg.value } // Block ends with conditional jump to 0x0474, if !msg.value label_0470: // Incoming jump from 0x046F, if not !msg.value // Inputs[1] { @0473 memory[0x00:0x00] } 0470 60 PUSH1 0x00 0472 80 DUP1 0473 FD *REVERT // Stack delta = +0 // Outputs[1] { @0473 revert(memory[0x00:0x00]); } // Block terminates label_0474: // Incoming jump from 0x046F, if !msg.value // Inputs[1] { @047C msg.data.length } 0474 5B JUMPDEST 0475 50 POP 0476 61 PUSH2 0x02fb 0479 61 PUSH2 0x0483 047C 36 CALLDATASIZE 047D 60 PUSH1 0x04 047F 61 PUSH2 0x1d42 0482 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0476 stack[-1] = 0x02fb // @0479 stack[0] = 0x0483 // @047C stack[1] = msg.data.length // @047D stack[2] = 0x04 // } // Block ends with call to 0x1d42, returns to 0x0483 label_0483: // Incoming return from call to 0x1D42 at 0x0482 0483 5B JUMPDEST 0484 61 PUSH2 0x0c4c 0487 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c4c label_0488: // Incoming jump from 0x00FD, if 0x715018a6 == stack[-1] // Inputs[1] { @0489 msg.value } 0488 5B JUMPDEST 0489 34 CALLVALUE 048A 80 DUP1 048B 15 ISZERO 048C 61 PUSH2 0x0494 048F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0489 stack[0] = msg.value } // Block ends with conditional jump to 0x0494, if !msg.value label_0490: // Incoming jump from 0x048F, if not !msg.value // Inputs[1] { @0493 memory[0x00:0x00] } 0490 60 PUSH1 0x00 0492 80 DUP1 0493 FD *REVERT // Stack delta = +0 // Outputs[1] { @0493 revert(memory[0x00:0x00]); } // Block terminates label_0494: // Incoming jump from 0x048F, if !msg.value 0494 5B JUMPDEST 0495 50 POP 0496 61 PUSH2 0x02c3 0499 61 PUSH2 0x0c9b 049C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0496 stack[-1] = 0x02c3 } // Block ends with call to 0x0c9b, returns to 0x02C3 label_049D: // Incoming jump from 0x0108, if 0x760a8c2a == stack[-1] // Inputs[1] { @049E msg.value } 049D 5B JUMPDEST 049E 34 CALLVALUE 049F 80 DUP1 04A0 15 ISZERO 04A1 61 PUSH2 0x04a9 04A4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @049E stack[0] = msg.value } // Block ends with conditional jump to 0x04a9, if !msg.value label_04A5: // Incoming jump from 0x04A4, if not !msg.value // Inputs[1] { @04A8 memory[0x00:0x00] } 04A5 60 PUSH1 0x00 04A7 80 DUP1 04A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A8 revert(memory[0x00:0x00]); } // Block terminates label_04A9: // Incoming jump from 0x04A4, if !msg.value 04A9 5B JUMPDEST 04AA 50 POP 04AB 61 PUSH2 0x02c3 04AE 61 PUSH2 0x0cd1 04B1 56 *JUMP // Stack delta = +0 // Outputs[1] { @04AB stack[-1] = 0x02c3 } // Block ends with call to 0x0cd1, returns to 0x02C3 label_04B2: // Incoming jump from 0x0113, if 0x76dcb19d == stack[-1] // Inputs[1] { @04B3 msg.value } 04B2 5B JUMPDEST 04B3 34 CALLVALUE 04B4 80 DUP1 04B5 15 ISZERO 04B6 61 PUSH2 0x04be 04B9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04B3 stack[0] = msg.value } // Block ends with conditional jump to 0x04be, if !msg.value label_04BA: // Incoming jump from 0x04B9, if not !msg.value // Inputs[1] { @04BD memory[0x00:0x00] } 04BA 60 PUSH1 0x00 04BC 80 DUP1 04BD FD *REVERT // Stack delta = +0 // Outputs[1] { @04BD revert(memory[0x00:0x00]); } // Block terminates label_04BE: // Incoming jump from 0x04B9, if !msg.value // Inputs[1] { @04C6 msg.data.length } 04BE 5B JUMPDEST 04BF 50 POP 04C0 61 PUSH2 0x02c3 04C3 61 PUSH2 0x04cd 04C6 36 CALLDATASIZE 04C7 60 PUSH1 0x04 04C9 61 PUSH2 0x1d18 04CC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04C0 stack[-1] = 0x02c3 // @04C3 stack[0] = 0x04cd // @04C6 stack[1] = msg.data.length // @04C7 stack[2] = 0x04 // } // Block ends with call to 0x1d18, returns to 0x04CD label_04CD: // Incoming return from call to 0x1D18 at 0x04CC 04CD 5B JUMPDEST 04CE 61 PUSH2 0x0d18 04D1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d18 label_04D2: // Incoming jump from 0x00B6, if 0x7ff9b596 == stack[-1] // Inputs[1] { @04D3 msg.value } 04D2 5B JUMPDEST 04D3 34 CALLVALUE 04D4 80 DUP1 04D5 15 ISZERO 04D6 61 PUSH2 0x04de 04D9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D3 stack[0] = msg.value } // Block ends with conditional jump to 0x04de, if !msg.value label_04DA: // Incoming jump from 0x04D9, if not !msg.value // Inputs[1] { @04DD memory[0x00:0x00] } 04DA 60 PUSH1 0x00 04DC 80 DUP1 04DD FD *REVERT // Stack delta = +0 // Outputs[1] { @04DD revert(memory[0x00:0x00]); } // Block terminates label_04DE: // Incoming jump from 0x04D9, if !msg.value // Inputs[1] { @04E5 storage[0x11] } 04DE 5B JUMPDEST 04DF 50 POP 04E0 61 PUSH2 0x02fb 04E3 60 PUSH1 0x11 04E5 54 SLOAD 04E6 81 DUP2 04E7 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04E0 stack[-1] = 0x02fb // @04E5 stack[0] = storage[0x11] // } // Block ends with unconditional jump to 0x02fb label_04E8: // Incoming jump from 0x00C1, if 0x82651bd0 == stack[-1] // Inputs[1] { @04E9 msg.value } 04E8 5B JUMPDEST 04E9 34 CALLVALUE 04EA 80 DUP1 04EB 15 ISZERO 04EC 61 PUSH2 0x04f4 04EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04E9 stack[0] = msg.value } // Block ends with conditional jump to 0x04f4, if !msg.value label_04F0: // Incoming jump from 0x04EF, if not !msg.value // Inputs[1] { @04F3 memory[0x00:0x00] } 04F0 60 PUSH1 0x00 04F2 80 DUP1 04F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F3 revert(memory[0x00:0x00]); } // Block terminates label_04F4: // Incoming jump from 0x04EF, if !msg.value // Inputs[1] { @04F8 storage[0x10] } 04F4 5B JUMPDEST 04F5 50 POP 04F6 60 PUSH1 0x10 04F8 54 SLOAD 04F9 61 PUSH2 0x0234 04FC 90 SWAP1 04FD 60 PUSH1 0xff 04FF 16 AND 0500 81 DUP2 0501 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04FC stack[-1] = 0x0234 // @04FF stack[0] = 0xff & storage[0x10] // } // Block ends with unconditional jump to 0x0234 label_0502: // Incoming jump from 0x00CC, if 0x86758912 == stack[-1] // Inputs[1] { @0503 msg.value } 0502 5B JUMPDEST 0503 34 CALLVALUE 0504 80 DUP1 0505 15 ISZERO 0506 61 PUSH2 0x050e 0509 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0503 stack[0] = msg.value } // Block ends with conditional jump to 0x050e, if !msg.value label_050A: // Incoming jump from 0x0509, if not !msg.value // Inputs[1] { @050D memory[0x00:0x00] } 050A 60 PUSH1 0x00 050C 80 DUP1 050D FD *REVERT // Stack delta = +0 // Outputs[1] { @050D revert(memory[0x00:0x00]); } // Block terminates label_050E: // Incoming jump from 0x0509, if !msg.value // Inputs[1] { @0516 msg.data.length } 050E 5B JUMPDEST 050F 50 POP 0510 61 PUSH2 0x02c3 0513 61 PUSH2 0x051d 0516 36 CALLDATASIZE 0517 60 PUSH1 0x04 0519 61 PUSH2 0x1ce3 051C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0510 stack[-1] = 0x02c3 // @0513 stack[0] = 0x051d // @0516 stack[1] = msg.data.length // @0517 stack[2] = 0x04 // } // Block ends with call to 0x1ce3, returns to 0x051D label_051D: // Incoming return from call to 0x1CE3 at 0x051C 051D 5B JUMPDEST 051E 61 PUSH2 0x0d4c 0521 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d4c label_0522: // Incoming jump from 0x00D7, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0523 msg.value } 0522 5B JUMPDEST 0523 34 CALLVALUE 0524 80 DUP1 0525 15 ISZERO 0526 61 PUSH2 0x052e 0529 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0523 stack[0] = msg.value } // Block ends with conditional jump to 0x052e, if !msg.value label_052A: // Incoming jump from 0x0529, if not !msg.value // Inputs[1] { @052D memory[0x00:0x00] } 052A 60 PUSH1 0x00 052C 80 DUP1 052D FD *REVERT // Stack delta = +0 // Outputs[1] { @052D revert(memory[0x00:0x00]); } // Block terminates label_052E: // Incoming jump from 0x0529, if !msg.value // Inputs[1] { @0532 storage[0x08] } 052E 5B JUMPDEST 052F 50 POP 0530 60 PUSH1 0x08 0532 54 SLOAD 0533 60 PUSH1 0x01 0535 60 PUSH1 0x01 0537 60 PUSH1 0xa0 0539 1B SHL 053A 03 SUB 053B 16 AND 053C 61 PUSH2 0x028b 053F 56 *JUMP // Stack delta = +0 // Outputs[1] { @053B stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x08] } // Block ends with unconditional jump to 0x028b label_0540: // Incoming jump from 0x00E2, if 0x91b7f5ed == stack[-1] // Inputs[1] { @0541 msg.value } 0540 5B JUMPDEST 0541 34 CALLVALUE 0542 80 DUP1 0543 15 ISZERO 0544 61 PUSH2 0x054c 0547 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0541 stack[0] = msg.value } // Block ends with conditional jump to 0x054c, if !msg.value label_0548: // Incoming jump from 0x0547, if not !msg.value // Inputs[1] { @054B memory[0x00:0x00] } 0548 60 PUSH1 0x00 054A 80 DUP1 054B FD *REVERT // Stack delta = +0 // Outputs[1] { @054B revert(memory[0x00:0x00]); } // Block terminates label_054C: // Incoming jump from 0x0547, if !msg.value // Inputs[1] { @0554 msg.data.length } 054C 5B JUMPDEST 054D 50 POP 054E 61 PUSH2 0x02c3 0551 61 PUSH2 0x055b 0554 36 CALLDATASIZE 0555 60 PUSH1 0x04 0557 61 PUSH2 0x1ce3 055A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @054E stack[-1] = 0x02c3 // @0551 stack[0] = 0x055b // @0554 stack[1] = msg.data.length // @0555 stack[2] = 0x04 // } // Block ends with call to 0x1ce3, returns to 0x055B label_055B: // Incoming return from call to 0x1CE3 at 0x055A 055B 5B JUMPDEST 055C 61 PUSH2 0x0d7b 055F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d7b label_0560: // Incoming jump from 0x007A, if 0x95d89b41 == stack[-1] // Inputs[1] { @0561 msg.value } 0560 5B JUMPDEST 0561 34 CALLVALUE 0562 80 DUP1 0563 15 ISZERO 0564 61 PUSH2 0x056c 0567 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0561 stack[0] = msg.value } // Block ends with conditional jump to 0x056c, if !msg.value label_0568: // Incoming jump from 0x0567, if not !msg.value // Inputs[1] { @056B memory[0x00:0x00] } 0568 60 PUSH1 0x00 056A 80 DUP1 056B FD *REVERT // Stack delta = +0 // Outputs[1] { @056B revert(memory[0x00:0x00]); } // Block terminates label_056C: // Incoming jump from 0x0567, if !msg.value 056C 5B JUMPDEST 056D 50 POP 056E 61 PUSH2 0x025e 0571 61 PUSH2 0x0daa 0574 56 *JUMP // Stack delta = +0 // Outputs[1] { @056E stack[-1] = 0x025e } // Block ends with call to 0x0daa, returns to 0x025E label_0575: // Incoming jump from 0x0085, if 0x9fce84ca == stack[-1] // Inputs[1] { @0576 msg.value } 0575 5B JUMPDEST 0576 34 CALLVALUE 0577 80 DUP1 0578 15 ISZERO 0579 61 PUSH2 0x0581 057C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0576 stack[0] = msg.value } // Block ends with conditional jump to 0x0581, if !msg.value label_057D: // Incoming jump from 0x057C, if not !msg.value // Inputs[1] { @0580 memory[0x00:0x00] } 057D 60 PUSH1 0x00 057F 80 DUP1 0580 FD *REVERT // Stack delta = +0 // Outputs[1] { @0580 revert(memory[0x00:0x00]); } // Block terminates label_0581: // Incoming jump from 0x057C, if !msg.value // Inputs[1] { @0589 msg.data.length } 0581 5B JUMPDEST 0582 50 POP 0583 61 PUSH2 0x02fb 0586 61 PUSH2 0x0590 0589 36 CALLDATASIZE 058A 60 PUSH1 0x04 058C 61 PUSH2 0x1d42 058F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0583 stack[-1] = 0x02fb // @0586 stack[0] = 0x0590 // @0589 stack[1] = msg.data.length // @058A stack[2] = 0x04 // } // Block ends with call to 0x1d42, returns to 0x0590 label_0590: // Incoming return from call to 0x1D42 at 0x058F // Inputs[4] // { // @0598 stack[-1] // @059E memory[0x00:0x40] // @059F storage[keccak256(memory[0x00:0x40])] // @05A0 stack[-2] // } 0590 5B JUMPDEST 0591 60 PUSH1 0x13 0593 60 PUSH1 0x20 0595 52 MSTORE 0596 60 PUSH1 0x00 0598 90 SWAP1 0599 81 DUP2 059A 52 MSTORE 059B 60 PUSH1 0x40 059D 90 SWAP1 059E 20 SHA3 059F 54 SLOAD 05A0 81 DUP2 05A1 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0595 memory[0x20:0x40] = 0x13 // @059A memory[0x00:0x20] = stack[-1] // @059F stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_05A2: // Incoming jump from 0x0090, if 0xa0712d68 == stack[-1] // Inputs[1] { @05A9 msg.data.length } 05A2 5B JUMPDEST 05A3 61 PUSH2 0x02c3 05A6 61 PUSH2 0x05b0 05A9 36 CALLDATASIZE 05AA 60 PUSH1 0x04 05AC 61 PUSH2 0x1ce3 05AF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05A3 stack[0] = 0x02c3 // @05A6 stack[1] = 0x05b0 // @05A9 stack[2] = msg.data.length // @05AA stack[3] = 0x04 // } // Block ends with call to 0x1ce3, returns to 0x05B0 label_05B0: // Incoming return from call to 0x1CE3 at 0x05AF 05B0 5B JUMPDEST 05B1 61 PUSH2 0x0db9 05B4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0db9 label_05B5: // Incoming jump from 0x009B, if 0xa22cb465 == stack[-1] // Inputs[1] { @05B6 msg.value } 05B5 5B JUMPDEST 05B6 34 CALLVALUE 05B7 80 DUP1 05B8 15 ISZERO 05B9 61 PUSH2 0x05c1 05BC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05B6 stack[0] = msg.value } // Block ends with conditional jump to 0x05c1, if !msg.value label_05BD: // Incoming jump from 0x05BC, if not !msg.value // Inputs[1] { @05C0 memory[0x00:0x00] } 05BD 60 PUSH1 0x00 05BF 80 DUP1 05C0 FD *REVERT // Stack delta = +0 // Outputs[1] { @05C0 revert(memory[0x00:0x00]); } // Block terminates label_05C1: // Incoming jump from 0x05BC, if !msg.value // Inputs[1] { @05C9 msg.data.length } 05C1 5B JUMPDEST 05C2 50 POP 05C3 61 PUSH2 0x02c3 05C6 61 PUSH2 0x05d0 05C9 36 CALLDATASIZE 05CA 60 PUSH1 0x04 05CC 61 PUSH2 0x1eed 05CF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05C3 stack[-1] = 0x02c3 // @05C6 stack[0] = 0x05d0 // @05C9 stack[1] = msg.data.length // @05CA stack[2] = 0x04 // } // Block ends with call to 0x1eed, returns to 0x05D0 label_05D0: // Incoming return from call to 0x1EED at 0x05CF 05D0 5B JUMPDEST 05D1 61 PUSH2 0x0faf 05D4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0faf label_05D5: // Incoming jump from 0x003E, if 0xb88d4fde == stack[-1] // Inputs[1] { @05D6 msg.value } 05D5 5B JUMPDEST 05D6 34 CALLVALUE 05D7 80 DUP1 05D8 15 ISZERO 05D9 61 PUSH2 0x05e1 05DC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05D6 stack[0] = msg.value } // Block ends with conditional jump to 0x05e1, if !msg.value label_05DD: // Incoming jump from 0x05DC, if not !msg.value // Inputs[1] { @05E0 memory[0x00:0x00] } 05DD 60 PUSH1 0x00 05DF 80 DUP1 05E0 FD *REVERT // Stack delta = +0 // Outputs[1] { @05E0 revert(memory[0x00:0x00]); } // Block terminates label_05E1: // Incoming jump from 0x05DC, if !msg.value // Inputs[1] { @05E9 msg.data.length } 05E1 5B JUMPDEST 05E2 50 POP 05E3 61 PUSH2 0x02c3 05E6 61 PUSH2 0x05f0 05E9 36 CALLDATASIZE 05EA 60 PUSH1 0x04 05EC 61 PUSH2 0x1f29 05EF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05E3 stack[-1] = 0x02c3 // @05E6 stack[0] = 0x05f0 // @05E9 stack[1] = msg.data.length // @05EA stack[2] = 0x04 // } // Block ends with call to 0x1f29, returns to 0x05F0 label_05F0: // Incoming return from call to 0x1F29 at 0x05EF 05F0 5B JUMPDEST 05F1 61 PUSH2 0x1045 05F4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1045 label_05F5: // Incoming jump from 0x0049, if 0xc87b56dd == stack[-1] // Inputs[1] { @05F6 msg.value } 05F5 5B JUMPDEST 05F6 34 CALLVALUE 05F7 80 DUP1 05F8 15 ISZERO 05F9 61 PUSH2 0x0601 05FC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05F6 stack[0] = msg.value } // Block ends with conditional jump to 0x0601, if !msg.value label_05FD: // Incoming jump from 0x05FC, if not !msg.value // Inputs[1] { @0600 memory[0x00:0x00] } 05FD 60 PUSH1 0x00 05FF 80 DUP1 0600 FD *REVERT // Stack delta = +0 // Outputs[1] { @0600 revert(memory[0x00:0x00]); } // Block terminates label_0601: // Incoming jump from 0x05FC, if !msg.value // Inputs[1] { @0609 msg.data.length } 0601 5B JUMPDEST 0602 50 POP 0603 61 PUSH2 0x025e 0606 61 PUSH2 0x0610 0609 36 CALLDATASIZE 060A 60 PUSH1 0x04 060C 61 PUSH2 0x1ce3 060F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0603 stack[-1] = 0x025e // @0606 stack[0] = 0x0610 // @0609 stack[1] = msg.data.length // @060A stack[2] = 0x04 // } // Block ends with call to 0x1ce3, returns to 0x0610 label_0610: // Incoming return from call to 0x1CE3 at 0x060F 0610 5B JUMPDEST 0611 61 PUSH2 0x1090 0614 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1090 label_0615: // Incoming jump from 0x0054, if 0xd431b1ac == stack[-1] // Inputs[1] { @0616 msg.value } 0615 5B JUMPDEST 0616 34 CALLVALUE 0617 80 DUP1 0618 15 ISZERO 0619 61 PUSH2 0x0621 061C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0616 stack[0] = msg.value } // Block ends with conditional jump to 0x0621, if !msg.value label_061D: // Incoming jump from 0x061C, if not !msg.value // Inputs[1] { @0620 memory[0x00:0x00] } 061D 60 PUSH1 0x00 061F 80 DUP1 0620 FD *REVERT // Stack delta = +0 // Outputs[1] { @0620 revert(memory[0x00:0x00]); } // Block terminates label_0621: // Incoming jump from 0x061C, if !msg.value 0621 5B JUMPDEST 0622 50 POP 0623 61 PUSH2 0x02c3 0626 61 PUSH2 0x11d1 0629 56 *JUMP // Stack delta = +0 // Outputs[1] { @0623 stack[-1] = 0x02c3 } // Block ends with call to 0x11d1, returns to 0x02C3 label_062A: // Incoming jump from 0x005F, if 0xe985e9c5 == stack[-1] // Inputs[1] { @062B msg.value } 062A 5B JUMPDEST 062B 34 CALLVALUE 062C 80 DUP1 062D 15 ISZERO 062E 61 PUSH2 0x0636 0631 57 *JUMPI // Stack delta = +1 // Outputs[1] { @062B stack[0] = msg.value } // Block ends with conditional jump to 0x0636, if !msg.value label_0632: // Incoming jump from 0x0631, if not !msg.value // Inputs[1] { @0635 memory[0x00:0x00] } 0632 60 PUSH1 0x00 0634 80 DUP1 0635 FD *REVERT // Stack delta = +0 // Outputs[1] { @0635 revert(memory[0x00:0x00]); } // Block terminates label_0636: // Incoming jump from 0x0631, if !msg.value // Inputs[1] { @063E msg.data.length } 0636 5B JUMPDEST 0637 50 POP 0638 61 PUSH2 0x0234 063B 61 PUSH2 0x0645 063E 36 CALLDATASIZE 063F 60 PUSH1 0x04 0641 61 PUSH2 0x1fa5 0644 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0638 stack[-1] = 0x0234 // @063B stack[0] = 0x0645 // @063E stack[1] = msg.data.length // @063F stack[2] = 0x04 // } // Block ends with call to 0x1fa5, returns to 0x0645 label_0645: // Incoming call from 0x0818, returns to 0x0819 // Incoming return from call to 0x1FA5 at 0x0644 // Incoming call from 0x139B, returns to 0x139C // Inputs[6] // { // @064E stack[-2] // @0661 memory[0x00:0x40] // @0662 stack[-1] // @066C memory[0x00:0x40] // @066D storage[keccak256(memory[0x00:0x40])] // @0671 stack[-3] // } 0645 5B JUMPDEST 0646 60 PUSH1 0x01 0648 60 PUSH1 0x01 064A 60 PUSH1 0xa0 064C 1B SHL 064D 03 SUB 064E 91 SWAP2 064F 82 DUP3 0650 16 AND 0651 60 PUSH1 0x00 0653 90 SWAP1 0654 81 DUP2 0655 52 MSTORE 0656 60 PUSH1 0x07 0658 60 PUSH1 0x20 065A 90 SWAP1 065B 81 DUP2 065C 52 MSTORE 065D 60 PUSH1 0x40 065F 80 DUP1 0660 83 DUP4 0661 20 SHA3 0662 93 SWAP4 0663 90 SWAP1 0664 94 SWAP5 0665 16 AND 0666 82 DUP3 0667 52 MSTORE 0668 91 SWAP2 0669 90 SWAP1 066A 91 SWAP2 066B 52 MSTORE 066C 20 SHA3 066D 54 SLOAD 066E 60 PUSH1 0xff 0670 16 AND 0671 90 SWAP1 0672 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0655 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @065C memory[0x20:0x40] = 0x07 // @0667 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @066B memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0671 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0673: // Incoming jump from 0x006A, if 0xf2fde38b == stack[-1] // Inputs[1] { @0674 msg.value } 0673 5B JUMPDEST 0674 34 CALLVALUE 0675 80 DUP1 0676 15 ISZERO 0677 61 PUSH2 0x067f 067A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0674 stack[0] = msg.value } // Block ends with conditional jump to 0x067f, if !msg.value label_067B: // Incoming jump from 0x067A, if not !msg.value // Inputs[1] { @067E memory[0x00:0x00] } 067B 60 PUSH1 0x00 067D 80 DUP1 067E FD *REVERT // Stack delta = +0 // Outputs[1] { @067E revert(memory[0x00:0x00]); } // Block terminates label_067F: // Incoming jump from 0x067A, if !msg.value // Inputs[1] { @0687 msg.data.length } 067F 5B JUMPDEST 0680 50 POP 0681 61 PUSH2 0x02c3 0684 61 PUSH2 0x068e 0687 36 CALLDATASIZE 0688 60 PUSH1 0x04 068A 61 PUSH2 0x1d42 068D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0681 stack[-1] = 0x02c3 // @0684 stack[0] = 0x068e // @0687 stack[1] = msg.data.length // @0688 stack[2] = 0x04 // } // Block ends with call to 0x1d42, returns to 0x068E label_068E: // Incoming return from call to 0x1D42 at 0x068D 068E 5B JUMPDEST 068F 61 PUSH2 0x120f 0692 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x120f label_0693: // Incoming jump from 0x0233 // Inputs[1] { @069F stack[-1] } 0693 5B JUMPDEST 0694 60 PUSH1 0x00 0696 60 PUSH1 0x01 0698 60 PUSH1 0x01 069A 60 PUSH1 0xe0 069C 1B SHL 069D 03 SUB 069E 19 NOT 069F 82 DUP3 06A0 16 AND 06A1 63 PUSH4 0x80ac58cd 06A6 60 PUSH1 0xe0 06A8 1B SHL 06A9 14 EQ 06AA 80 DUP1 06AB 61 PUSH2 0x06c4 06AE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0694 stack[0] = 0x00 // @06A9 stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x06c4, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_06AF: // Incoming jump from 0x06AE, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @06B9 stack[-3] } 06AF 50 POP 06B0 60 PUSH1 0x01 06B2 60 PUSH1 0x01 06B4 60 PUSH1 0xe0 06B6 1B SHL 06B7 03 SUB 06B8 19 NOT 06B9 82 DUP3 06BA 16 AND 06BB 63 PUSH4 0x5b5e139f 06C0 60 PUSH1 0xe0 06C2 1B SHL 06C3 14 EQ 06C4 5B JUMPDEST 06C5 80 DUP1 06C6 61 PUSH2 0x06df 06C9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @06C3 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x06df, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_06CA: // Incoming jump from 0x06C9, if not stack[-1] // Incoming jump from 0x06C9, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @06DC stack[-3] } 06CA 50 POP 06CB 63 PUSH4 0x01ffc9a7 06D0 60 PUSH1 0xe0 06D2 1B SHL 06D3 60 PUSH1 0x01 06D5 60 PUSH1 0x01 06D7 60 PUSH1 0xe0 06D9 1B SHL 06DA 03 SUB 06DB 19 NOT 06DC 83 DUP4 06DD 16 AND 06DE 14 EQ // Stack delta = +0 // Outputs[1] { @06DE stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block continues label_06DF: // Incoming jump from 0x12C1, if !(stack[-3] < storage[0x00]) // Incoming jump from 0x06DE // Incoming jump from 0x06C9, if stack[-1] // Incoming jump from 0x12C1, if !stack[-1] // Incoming jump from 0x06C9, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[3] // { // @06E0 stack[-1] // @06E0 stack[-4] // @06E1 stack[-3] // } 06DF 5B JUMPDEST 06E0 92 SWAP3 06E1 91 SWAP2 06E2 50 POP 06E3 50 POP 06E4 56 *JUMP // Stack delta = -3 // Outputs[1] { @06E0 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_06E5: // Incoming call from 0x025D, returns to 0x025E // Inputs[1] { @06EB storage[0x02] } 06E5 5B JUMPDEST 06E6 60 PUSH1 0x60 06E8 60 PUSH1 0x02 06EA 80 DUP1 06EB 54 SLOAD 06EC 61 PUSH2 0x06f4 06EF 90 SWAP1 06F0 61 PUSH2 0x1fd8 06F3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06E6 stack[0] = 0x60 // @06E8 stack[1] = 0x02 // @06EF stack[2] = 0x06f4 // @06EF stack[3] = storage[0x02] // } // Block ends with call to 0x1fd8, returns to 0x06F4 label_06F4: // Incoming return from call to 0x1FD8 at 0x06F3 // Incoming return from call to 0x1FD8 at 0x0DB8 // Inputs[4] // { // @06F5 stack[-1] // @0704 memory[0x40:0x60] // @070C stack[-2] // @0717 storage[stack[-2]] // } 06F4 5B JUMPDEST 06F5 80 DUP1 06F6 60 PUSH1 0x1f 06F8 01 ADD 06F9 60 PUSH1 0x20 06FB 80 DUP1 06FC 91 SWAP2 06FD 04 DIV 06FE 02 MUL 06FF 60 PUSH1 0x20 0701 01 ADD 0702 60 PUSH1 0x40 0704 51 MLOAD 0705 90 SWAP1 0706 81 DUP2 0707 01 ADD 0708 60 PUSH1 0x40 070A 52 MSTORE 070B 80 DUP1 070C 92 SWAP3 070D 91 SWAP2 070E 90 SWAP1 070F 81 DUP2 0710 81 DUP2 0711 52 MSTORE 0712 60 PUSH1 0x20 0714 01 ADD 0715 82 DUP3 0716 80 DUP1 0717 54 SLOAD 0718 61 PUSH2 0x0720 071B 90 SWAP1 071C 61 PUSH2 0x1fd8 071F 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @070A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @070C stack[-2] = memory[0x40:0x60] // @070D stack[-1] = stack[-2] // @070E stack[0] = stack[-1] // @0711 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0714 stack[1] = 0x20 + memory[0x40:0x60] // @0715 stack[2] = stack[-2] // @071B stack[4] = storage[stack[-2]] // @071B stack[3] = 0x0720 // } // Block ends with call to 0x1fd8, returns to 0x0720 label_0720: // Incoming return from call to 0x1FD8 at 0x071F // Inputs[1] { @0721 stack[-1] } 0720 5B JUMPDEST 0721 80 DUP1 0722 15 ISZERO 0723 61 PUSH2 0x076d 0726 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x076d, if !stack[-1] label_0727: // Incoming jump from 0x0726, if not !stack[-1] // Inputs[1] { @0727 stack[-1] } 0727 80 DUP1 0728 60 PUSH1 0x1f 072A 10 LT 072B 61 PUSH2 0x0742 072E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0742, if 0x1f < stack[-1] label_072F: // Incoming jump from 0x072E, if not 0x1f < stack[-1] // Inputs[4] // { // @0733 stack[-2] // @0734 storage[stack[-2]] // @0737 stack[-3] // @0739 stack[-1] // } 072F 61 PUSH2 0x0100 0732 80 DUP1 0733 83 DUP4 0734 54 SLOAD 0735 04 DIV 0736 02 MUL 0737 83 DUP4 0738 52 MSTORE 0739 91 SWAP2 073A 60 PUSH1 0x20 073C 01 ADD 073D 91 SWAP2 073E 61 PUSH2 0x076d 0741 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0738 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @073D stack[-1] = stack[-1] // @073D stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x076d label_0742: // Incoming jump from 0x072E, if 0x1f < stack[-1] // Inputs[5] // { // @0743 stack[-3] // @0744 stack[-1] // @0746 stack[-2] // @074E memory[0x00:0x20] // @0752 storage[keccak256(memory[0x00:0x20])] // } 0742 5B JUMPDEST 0743 82 DUP3 0744 01 ADD 0745 91 SWAP2 0746 90 SWAP1 0747 60 PUSH1 0x00 0749 52 MSTORE 074A 60 PUSH1 0x20 074C 60 PUSH1 0x00 074E 20 SHA3 074F 90 SWAP1 0750 5B JUMPDEST 0751 81 DUP2 0752 54 SLOAD 0753 81 DUP2 0754 52 MSTORE 0755 90 SWAP1 0756 60 PUSH1 0x01 0758 01 ADD 0759 90 SWAP1 075A 60 PUSH1 0x20 075C 01 ADD 075D 80 DUP1 075E 83 DUP4 075F 11 GT 0760 61 PUSH2 0x0750 0763 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0745 stack[-3] = stack[-3] + stack[-1] // @0749 memory[0x00:0x20] = stack[-2] // @0754 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0759 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @075C stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0750, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0764: // Incoming jump from 0x0763, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0763, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0764 stack[-3] // @0765 stack[-1] // } 0764 82 DUP3 0765 90 SWAP1 0766 03 SUB 0767 60 PUSH1 0x1f 0769 16 AND 076A 82 DUP3 076B 01 ADD 076C 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @076C stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @076C stack[-1] = stack[-3] // } // Block continues label_076D: // Incoming jump from 0x0726, if !stack[-1] // Incoming jump from 0x076C // Incoming jump from 0x0741 // Inputs[3] // { // @0773 stack[-7] // @0773 stack[-6] // @0775 stack[-8] // } 076D 5B JUMPDEST 076E 50 POP 076F 50 POP 0770 50 POP 0771 50 POP 0772 50 POP 0773 90 SWAP1 0774 50 POP 0775 90 SWAP1 0776 56 *JUMP // Stack delta = -7 // Outputs[1] { @0775 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0777: // Incoming jump from 0x028A // Incoming call from 0x13AB, returns to 0x13AC // Inputs[1] { @077D stack[-1] } 0777 5B JUMPDEST 0778 60 PUSH1 0x00 077A 61 PUSH2 0x0782 077D 82 DUP3 077E 61 PUSH2 0x12a7 0781 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0778 stack[0] = 0x00 // @077A stack[1] = 0x0782 // @077D stack[2] = stack[-1] // } // Block ends with call to 0x12a7, returns to 0x0782 label_0782: // Incoming return from call to 0x12A7 at 0x0781 // Inputs[1] { @0786 stack[-1] } 0782 5B JUMPDEST 0783 61 PUSH2 0x079f 0786 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x079f, if stack[-1] label_0787: // Incoming jump from 0x0786, if not stack[-1] // Inputs[3] // { // @0789 memory[0x40:0x60] // @0799 memory[0x40:0x60] // @079E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0787 60 PUSH1 0x40 0789 51 MLOAD 078A 63 PUSH4 0x33d1c039 078F 60 PUSH1 0xe2 0791 1B SHL 0792 81 DUP2 0793 52 MSTORE 0794 60 PUSH1 0x04 0796 01 ADD 0797 60 PUSH1 0x40 0799 51 MLOAD 079A 80 DUP1 079B 91 SWAP2 079C 03 SUB 079D 90 SWAP1 079E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0793 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x33d1c039 << 0xe2 // @079E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_079F: // Incoming jump from 0x0786, if stack[-1] // Inputs[4] // { // @07A3 stack[-2] // @07AE memory[0x00:0x40] // @07AF storage[keccak256(memory[0x00:0x40])] // @07B9 stack[-3] // } 079F 5B JUMPDEST 07A0 50 POP 07A1 60 PUSH1 0x00 07A3 90 SWAP1 07A4 81 DUP2 07A5 52 MSTORE 07A6 60 PUSH1 0x06 07A8 60 PUSH1 0x20 07AA 52 MSTORE 07AB 60 PUSH1 0x40 07AD 90 SWAP1 07AE 20 SHA3 07AF 54 SLOAD 07B0 60 PUSH1 0x01 07B2 60 PUSH1 0x01 07B4 60 PUSH1 0xa0 07B6 1B SHL 07B7 03 SUB 07B8 16 AND 07B9 90 SWAP1 07BA 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @07A5 memory[0x00:0x20] = stack[-2] // @07AA memory[0x20:0x40] = 0x06 // @07B9 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_07BB: // Incoming jump from 0x02C2 // Inputs[1] { @07C1 stack[-1] } 07BB 5B JUMPDEST 07BC 60 PUSH1 0x00 07BE 61 PUSH2 0x07c6 07C1 82 DUP3 07C2 61 PUSH2 0x09ef 07C5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07BC stack[0] = 0x00 // @07BE stack[1] = 0x07c6 // @07C1 stack[2] = stack[-1] // } // Block ends with call to 0x09ef, returns to 0x07C6 label_07C6: // Incoming return from call to 0x09EF at 0x07C5 // Inputs[3] // { // @07C7 stack[-1] // @07C7 stack[-2] // @07D3 stack[-4] // } 07C6 5B JUMPDEST 07C7 90 SWAP1 07C8 50 POP 07C9 80 DUP1 07CA 60 PUSH1 0x01 07CC 60 PUSH1 0x01 07CE 60 PUSH1 0xa0 07D0 1B SHL 07D1 03 SUB 07D2 16 AND 07D3 83 DUP4 07D4 60 PUSH1 0x01 07D6 60 PUSH1 0x01 07D8 60 PUSH1 0xa0 07DA 1B SHL 07DB 03 SUB 07DC 16 AND 07DD 14 EQ 07DE 15 ISZERO 07DF 61 PUSH2 0x07fb 07E2 57 *JUMPI // Stack delta = -1 // Outputs[1] { @07C7 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x07fb, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_07E3: // Incoming jump from 0x07E2, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @07E5 memory[0x40:0x60] // @07F5 memory[0x40:0x60] // @07FA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 07E3 60 PUSH1 0x40 07E5 51 MLOAD 07E6 63 PUSH4 0x250fdee3 07EB 60 PUSH1 0xe2 07ED 1B SHL 07EE 81 DUP2 07EF 52 MSTORE 07F0 60 PUSH1 0x04 07F2 01 ADD 07F3 60 PUSH1 0x40 07F5 51 MLOAD 07F6 80 DUP1 07F7 91 SWAP2 07F8 03 SUB 07F9 90 SWAP1 07FA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @07EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x250fdee3 << 0xe2 // @07FA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_07FB: // Incoming jump from 0x07E2, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @07FC msg.sender // @0805 stack[-1] // } 07FB 5B JUMPDEST 07FC 33 CALLER 07FD 60 PUSH1 0x01 07FF 60 PUSH1 0x01 0801 60 PUSH1 0xa0 0803 1B SHL 0804 03 SUB 0805 82 DUP3 0806 16 AND 0807 14 EQ 0808 80 DUP1 0809 15 ISZERO 080A 90 SWAP1 080B 61 PUSH2 0x081b 080E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @080A stack[0] = !(stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender) } // Block ends with conditional jump to 0x081b, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_080F: // Incoming jump from 0x080E, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0813 stack[-2] // @0814 msg.sender // } 080F 50 POP 0810 61 PUSH2 0x0819 0813 81 DUP2 0814 33 CALLER 0815 61 PUSH2 0x0645 0818 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0810 stack[-1] = 0x0819 // @0813 stack[0] = stack[-2] // @0814 stack[1] = msg.sender // } // Block ends with call to 0x0645, returns to 0x0819 label_0819: // Incoming return from call to 0x0645 at 0x0818 // Inputs[1] { @081A stack[-1] } 0819 5B JUMPDEST 081A 15 ISZERO // Stack delta = +0 // Outputs[1] { @081A stack[-1] = !stack[-1] } // Block continues label_081B: // Incoming jump from 0x081A // Incoming jump from 0x080E, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @081C stack[-1] } 081B 5B JUMPDEST 081C 15 ISZERO 081D 61 PUSH2 0x0839 0820 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0839, if !stack[-1] label_0821: // Incoming jump from 0x0820, if not !stack[-1] // Inputs[3] // { // @0823 memory[0x40:0x60] // @0833 memory[0x40:0x60] // @0838 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0821 60 PUSH1 0x40 0823 51 MLOAD 0824 63 PUSH4 0x67d9dca1 0829 60 PUSH1 0xe1 082B 1B SHL 082C 81 DUP2 082D 52 MSTORE 082E 60 PUSH1 0x04 0830 01 ADD 0831 60 PUSH1 0x40 0833 51 MLOAD 0834 80 DUP1 0835 91 SWAP2 0836 03 SUB 0837 90 SWAP1 0838 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @082D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x67d9dca1 << 0xe1 // @0838 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0839: // Incoming jump from 0x0820, if !stack[-1] // Inputs[3] // { // @083D stack[-3] // @083E stack[-2] // @083F stack[-1] // } 0839 5B JUMPDEST 083A 61 PUSH2 0x0844 083D 83 DUP4 083E 83 DUP4 083F 83 DUP4 0840 61 PUSH2 0x12e0 0843 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @083A stack[0] = 0x0844 // @083D stack[1] = stack[-3] // @083E stack[2] = stack[-2] // @083F stack[3] = stack[-1] // } // Block ends with call to 0x12e0, returns to 0x0844 label_0844: // Incoming return from call to 0x19D4 at 0x195F // Incoming return from call to 0x12E0 at 0x0843 // Inputs[1] { @0848 stack[-4] } 0844 5B JUMPDEST 0845 50 POP 0846 50 POP 0847 50 POP 0848 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0849: // Incoming call from 0x031D, returns to 0x025E // Inputs[1] { @084D storage[0x0e] } 0849 5B JUMPDEST 084A 60 PUSH1 0x0e 084C 80 DUP1 084D 54 SLOAD 084E 61 PUSH2 0x0856 0851 90 SWAP1 0852 61 PUSH2 0x1fd8 0855 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @084A stack[0] = 0x0e // @0851 stack[1] = 0x0856 // @0851 stack[2] = storage[0x0e] // } // Block ends with call to 0x1fd8, returns to 0x0856 label_0856: // Incoming return from call to 0x1FD8 at 0x0855 // Inputs[4] // { // @0857 stack[-1] // @0866 memory[0x40:0x60] // @086E stack[-2] // @0879 storage[stack[-2]] // } 0856 5B JUMPDEST 0857 80 DUP1 0858 60 PUSH1 0x1f 085A 01 ADD 085B 60 PUSH1 0x20 085D 80 DUP1 085E 91 SWAP2 085F 04 DIV 0860 02 MUL 0861 60 PUSH1 0x20 0863 01 ADD 0864 60 PUSH1 0x40 0866 51 MLOAD 0867 90 SWAP1 0868 81 DUP2 0869 01 ADD 086A 60 PUSH1 0x40 086C 52 MSTORE 086D 80 DUP1 086E 92 SWAP3 086F 91 SWAP2 0870 90 SWAP1 0871 81 DUP2 0872 81 DUP2 0873 52 MSTORE 0874 60 PUSH1 0x20 0876 01 ADD 0877 82 DUP3 0878 80 DUP1 0879 54 SLOAD 087A 61 PUSH2 0x0882 087D 90 SWAP1 087E 61 PUSH2 0x1fd8 0881 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @086C memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @086E stack[-2] = memory[0x40:0x60] // @086F stack[-1] = stack[-2] // @0870 stack[0] = stack[-1] // @0873 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0876 stack[1] = 0x20 + memory[0x40:0x60] // @0877 stack[2] = stack[-2] // @087D stack[4] = storage[stack[-2]] // @087D stack[3] = 0x0882 // } // Block ends with call to 0x1fd8, returns to 0x0882 label_0882: // Incoming return from call to 0x1FD8 at 0x0881 // Inputs[1] { @0883 stack[-1] } 0882 5B JUMPDEST 0883 80 DUP1 0884 15 ISZERO 0885 61 PUSH2 0x08cf 0888 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08cf, if !stack[-1] label_0889: // Incoming jump from 0x0888, if not !stack[-1] // Inputs[1] { @0889 stack[-1] } 0889 80 DUP1 088A 60 PUSH1 0x1f 088C 10 LT 088D 61 PUSH2 0x08a4 0890 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08a4, if 0x1f < stack[-1] label_0891: // Incoming jump from 0x0890, if not 0x1f < stack[-1] // Inputs[4] // { // @0895 stack[-2] // @0896 storage[stack[-2]] // @0899 stack[-3] // @089B stack[-1] // } 0891 61 PUSH2 0x0100 0894 80 DUP1 0895 83 DUP4 0896 54 SLOAD 0897 04 DIV 0898 02 MUL 0899 83 DUP4 089A 52 MSTORE 089B 91 SWAP2 089C 60 PUSH1 0x20 089E 01 ADD 089F 91 SWAP2 08A0 61 PUSH2 0x08cf 08A3 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @089A memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @089F stack[-1] = stack[-1] // @089F stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x08cf label_08A4: // Incoming jump from 0x0890, if 0x1f < stack[-1] // Inputs[5] // { // @08A5 stack[-3] // @08A6 stack[-1] // @08A8 stack[-2] // @08B0 memory[0x00:0x20] // @08B4 storage[keccak256(memory[0x00:0x20])] // } 08A4 5B JUMPDEST 08A5 82 DUP3 08A6 01 ADD 08A7 91 SWAP2 08A8 90 SWAP1 08A9 60 PUSH1 0x00 08AB 52 MSTORE 08AC 60 PUSH1 0x20 08AE 60 PUSH1 0x00 08B0 20 SHA3 08B1 90 SWAP1 08B2 5B JUMPDEST 08B3 81 DUP2 08B4 54 SLOAD 08B5 81 DUP2 08B6 52 MSTORE 08B7 90 SWAP1 08B8 60 PUSH1 0x01 08BA 01 ADD 08BB 90 SWAP1 08BC 60 PUSH1 0x20 08BE 01 ADD 08BF 80 DUP1 08C0 83 DUP4 08C1 11 GT 08C2 61 PUSH2 0x08b2 08C5 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @08A7 stack[-3] = stack[-3] + stack[-1] // @08AB memory[0x00:0x20] = stack[-2] // @08B6 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @08BB stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @08BE stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x08b2, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_08C6: // Incoming jump from 0x08C5, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x08C5, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @08C6 stack[-3] // @08C7 stack[-1] // } 08C6 82 DUP3 08C7 90 SWAP1 08C8 03 SUB 08C9 60 PUSH1 0x1f 08CB 16 AND 08CC 82 DUP3 08CD 01 ADD 08CE 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @08CE stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @08CE stack[-1] = stack[-3] // } // Block continues label_08CF: // Incoming jump from 0x08A3 // Incoming jump from 0x0888, if !stack[-1] // Incoming jump from 0x08CE // Inputs[1] { @08D5 stack[-7] } 08CF 5B JUMPDEST 08D0 50 POP 08D1 50 POP 08D2 50 POP 08D3 50 POP 08D4 50 POP 08D5 81 DUP2 08D6 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_08D7: // Incoming jump from 0x0379 // Inputs[3] // { // @08DB stack[-3] // @08DC stack[-2] // @08DD stack[-1] // } 08D7 5B JUMPDEST 08D8 61 PUSH2 0x0844 08DB 83 DUP4 08DC 83 DUP4 08DD 83 DUP4 08DE 61 PUSH2 0x133c 08E1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08D8 stack[0] = 0x0844 // @08DB stack[1] = stack[-3] // @08DC stack[2] = stack[-2] // @08DD stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x133c label_08E2: // Incoming call from 0x03A4, returns to 0x02C3 // Inputs[2] // { // @08E5 storage[0x08] // @08EF msg.sender // } 08E2 5B JUMPDEST 08E3 60 PUSH1 0x08 08E5 54 SLOAD 08E6 60 PUSH1 0x01 08E8 60 PUSH1 0x01 08EA 60 PUSH1 0xa0 08EC 1B SHL 08ED 03 SUB 08EE 16 AND 08EF 33 CALLER 08F0 14 EQ 08F1 61 PUSH2 0x0915 08F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0915, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_08F5: // Incoming jump from 0x08F4, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @08F7 memory[0x40:0x60] } 08F5 60 PUSH1 0x40 08F7 51 MLOAD 08F8 62 PUSH3 0x461bcd 08FC 60 PUSH1 0xe5 08FE 1B SHL 08FF 81 DUP2 0900 52 MSTORE 0901 60 PUSH1 0x04 0903 01 ADD 0904 61 PUSH2 0x090c 0907 90 SWAP1 0908 61 PUSH2 0x2013 090B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0900 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0907 stack[0] = 0x090c // @0907 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2013, returns to 0x090C label_090C: // Incoming return from call to 0x2013 at 0x11FA // Incoming jump from 0x0A9D // Incoming jump from 0x0AFB // Incoming return from call to 0x2013 at 0x0D41 // Incoming jump from 0x0E5E // Incoming jump from 0x0E07 // Incoming jump from 0x0BB1 // Incoming return from call to 0x2013 at 0x090B // Incoming jump from 0x0C0D // Incoming return from call to 0x2013 at 0x0D75 // Incoming jump from 0x0F7F // Incoming jump from 0x0B6A // Incoming jump from 0x0A4F // Incoming jump from 0x0F22 // Incoming return from call to 0x2013 at 0x0DA4 // Incoming return from call to 0x2013 at 0x0988 // Incoming return from call to 0x2013 at 0x1238 // Incoming return from call to 0x2013 at 0x0CFA // Incoming return from call to 0x2013 at 0x0CC4 // Incoming return from call to 0x2013 at 0x09C9 // Incoming jump from 0x10FE // Incoming jump from 0x129D // Incoming jump from 0x0EBC // Inputs[3] // { // @090F memory[0x40:0x60] // @0911 stack[-1] // @0914 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 090C 5B JUMPDEST 090D 60 PUSH1 0x40 090F 51 MLOAD 0910 80 DUP1 0911 91 SWAP2 0912 03 SUB 0913 90 SWAP1 0914 FD *REVERT // Stack delta = -1 // Outputs[1] { @0914 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0915: // Incoming jump from 0x08F4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[6] // { // @0918 memory[0x40:0x60] // @0919 msg.sender // @091B address(this) // @091B address(this).balance // @092B address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @092B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // } 0915 5B JUMPDEST 0916 60 PUSH1 0x40 0918 51 MLOAD 0919 33 CALLER 091A 90 SWAP1 091B 47 SELFBALANCE 091C 80 DUP1 091D 15 ISZERO 091E 61 PUSH2 0x08fc 0921 02 MUL 0922 91 SWAP2 0923 60 PUSH1 0x00 0925 81 DUP2 0926 81 DUP2 0927 81 DUP2 0928 85 DUP6 0929 88 DUP9 092A 88 DUP9 092B F1 CALL 092C 93 SWAP4 092D 50 POP 092E 50 POP 092F 50 POP 0930 50 POP 0931 15 ISZERO 0932 80 DUP1 0933 15 ISZERO 0934 61 PUSH2 0x0941 0937 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @092B 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]) // @0931 stack[0] = !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 0x0941, if !!address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_0938: // Incoming jump from 0x0937, if not !!address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @0938 returndata.length // @093C returndata[0x00:0x00 + returndata.length] // @093D returndata.length // @0940 memory[0x00:0x00 + returndata.length] // } 0938 3D RETURNDATASIZE 0939 60 PUSH1 0x00 093B 80 DUP1 093C 3E RETURNDATACOPY 093D 3D RETURNDATASIZE 093E 60 PUSH1 0x00 0940 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @093C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0940 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0941: // Incoming jump from 0x1C4F, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x0937, if !!address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Incoming return from call to 0x16F5 at 0x12A6 // Incoming return from call to 0x16DB at 0x0FAE // Inputs[1] { @0943 stack[-2] } 0941 5B JUMPDEST 0942 50 POP 0943 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0944: // Incoming jump from 0x03C4 // Inputs[4] // { // @0948 stack[-3] // @0949 stack[-2] // @094A stack[-1] // @094D memory[0x40:0x60] // } 0944 5B JUMPDEST 0945 61 PUSH2 0x0844 0948 83 DUP4 0949 83 DUP4 094A 83 DUP4 094B 60 PUSH1 0x40 094D 51 MLOAD 094E 80 DUP1 094F 60 PUSH1 0x20 0951 01 ADD 0952 60 PUSH1 0x40 0954 52 MSTORE 0955 80 DUP1 0956 60 PUSH1 0x00 0958 81 DUP2 0959 52 MSTORE 095A 50 POP 095B 61 PUSH2 0x1045 095E 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0945 stack[0] = 0x0844 // @0948 stack[1] = stack[-3] // @0949 stack[2] = stack[-2] // @094A stack[3] = stack[-1] // @094D stack[4] = memory[0x40:0x60] // @0954 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0959 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x1045 label_095F: // Incoming jump from 0x03E4 // Inputs[2] // { // @0962 storage[0x08] // @096C msg.sender // } 095F 5B JUMPDEST 0960 60 PUSH1 0x08 0962 54 SLOAD 0963 60 PUSH1 0x01 0965 60 PUSH1 0x01 0967 60 PUSH1 0xa0 0969 1B SHL 096A 03 SUB 096B 16 AND 096C 33 CALLER 096D 14 EQ 096E 61 PUSH2 0x0989 0971 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0989, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0972: // Incoming jump from 0x0971, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0974 memory[0x40:0x60] } 0972 60 PUSH1 0x40 0974 51 MLOAD 0975 62 PUSH3 0x461bcd 0979 60 PUSH1 0xe5 097B 1B SHL 097C 81 DUP2 097D 52 MSTORE 097E 60 PUSH1 0x04 0980 01 ADD 0981 61 PUSH2 0x090c 0984 90 SWAP1 0985 61 PUSH2 0x2013 0988 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @097D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0984 stack[0] = 0x090c // @0984 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2013, returns to 0x090C label_0989: // Incoming jump from 0x0971, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @098A stack[-1] // @098B memory[stack[-1]:stack[-1] + 0x20] // } 0989 5B JUMPDEST 098A 80 DUP1 098B 51 MLOAD 098C 61 PUSH2 0x099c 098F 90 SWAP1 0990 60 PUSH1 0x0e 0992 90 SWAP1 0993 60 PUSH1 0x20 0995 84 DUP5 0996 01 ADD 0997 90 SWAP1 0998 61 PUSH2 0x1ba5 099B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @098F stack[0] = 0x099c // @0992 stack[1] = 0x0e // @0997 stack[2] = stack[-1] + 0x20 // @0997 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1ba5 label_099C: // Incoming return from call to 0x16DB at 0x0D4B // Incoming return from call to 0x1953 at 0x16F4 // Inputs[1] { @099F stack[-3] } 099C 5B JUMPDEST 099D 50 POP 099E 50 POP 099F 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_09A0: // Incoming jump from 0x041E // Inputs[2] // { // @09A3 storage[0x08] // @09AD msg.sender // } 09A0 5B JUMPDEST 09A1 60 PUSH1 0x08 09A3 54 SLOAD 09A4 60 PUSH1 0x01 09A6 60 PUSH1 0x01 09A8 60 PUSH1 0xa0 09AA 1B SHL 09AB 03 SUB 09AC 16 AND 09AD 33 CALLER 09AE 14 EQ 09AF 61 PUSH2 0x09ca 09B2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09ca, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_09B3: // Incoming jump from 0x09B2, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @09B5 memory[0x40:0x60] } 09B3 60 PUSH1 0x40 09B5 51 MLOAD 09B6 62 PUSH3 0x461bcd 09BA 60 PUSH1 0xe5 09BC 1B SHL 09BD 81 DUP2 09BE 52 MSTORE 09BF 60 PUSH1 0x04 09C1 01 ADD 09C2 61 PUSH2 0x090c 09C5 90 SWAP1 09C6 61 PUSH2 0x2013 09C9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09BE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09C5 stack[0] = 0x090c // @09C5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2013, returns to 0x090C label_09CA: // Incoming jump from 0x09B2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @09CE storage[0x10] // @09DD stack[-1] // @09DE memory[stack[-1]:stack[-1] + 0x20] // } 09CA 5B JUMPDEST 09CB 60 PUSH1 0x10 09CD 80 DUP1 09CE 54 SLOAD 09CF 60 PUSH1 0xff 09D1 19 NOT 09D2 81 DUP2 09D3 16 AND 09D4 60 PUSH1 0xff 09D6 90 SWAP1 09D7 91 SWAP2 09D8 16 AND 09D9 15 ISZERO 09DA 17 OR 09DB 90 SWAP1 09DC 55 SSTORE 09DD 80 DUP1 09DE 51 MLOAD 09DF 61 PUSH2 0x099c 09E2 90 SWAP1 09E3 60 PUSH1 0x0e 09E5 90 SWAP1 09E6 60 PUSH1 0x20 09E8 84 DUP5 09E9 01 ADD 09EA 90 SWAP1 09EB 61 PUSH2 0x1ba5 09EE 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @09DC storage[0x10] = !(storage[0x10] & 0xff) | (storage[0x10] & ~0xff) // @09E2 stack[0] = 0x099c // @09E5 stack[1] = 0x0e // @09EA stack[2] = stack[-1] + 0x20 // @09EA stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1ba5 label_09EF: // Incoming call from 0x07C5, returns to 0x07C6 // Incoming jump from 0x043E // Inputs[1] { @09F5 stack[-1] } 09EF 5B JUMPDEST 09F0 60 PUSH1 0x00 09F2 61 PUSH2 0x09fa 09F5 82 DUP3 09F6 61 PUSH2 0x152c 09F9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09F0 stack[0] = 0x00 // @09F2 stack[1] = 0x09fa // @09F5 stack[2] = stack[-1] // } // Block ends with call to 0x152c, returns to 0x09FA label_09FA: // Incoming return from call to 0x152C at 0x09F9 // Inputs[4] // { // @09FB stack[-1] // @09FB memory[stack[-1]:stack[-1] + 0x20] // @09FC stack[-4] // @09FD stack[-3] // } 09FA 5B JUMPDEST 09FB 51 MLOAD 09FC 92 SWAP3 09FD 91 SWAP2 09FE 50 POP 09FF 50 POP 0A00 56 *JUMP // Stack delta = -3 // Outputs[1] { @09FC stack[-4] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-4] label_0A01: // Incoming jump from 0x0467 // Inputs[2] // { // @0A02 tx.origin // @0A03 msg.sender // } 0A01 5B JUMPDEST 0A02 32 ORIGIN 0A03 33 CALLER 0A04 14 EQ 0A05 61 PUSH2 0x0a50 0A08 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a50, if msg.sender == tx.origin label_0A09: // Incoming jump from 0x0A08, if not msg.sender == tx.origin // Inputs[1] { @0A0B memory[0x40:0x60] } 0A09 60 PUSH1 0x40 0A0B 51 MLOAD 0A0C 62 PUSH3 0x461bcd 0A10 60 PUSH1 0xe5 0A12 1B SHL 0A13 81 DUP2 0A14 52 MSTORE 0A15 60 PUSH1 0x20 0A17 60 PUSH1 0x04 0A19 82 DUP3 0A1A 01 ADD 0A1B 52 MSTORE 0A1C 60 PUSH1 0x1e 0A1E 60 PUSH1 0x24 0A20 82 DUP3 0A21 01 ADD 0A22 52 MSTORE 0A23 7F PUSH32 0x43616e6e6f742062652063616c6c6564206279206120636f6e74726163740000 0A44 60 PUSH1 0x44 0A46 82 DUP3 0A47 01 ADD 0A48 52 MSTORE 0A49 60 PUSH1 0x64 0A4B 01 ADD 0A4C 61 PUSH2 0x090c 0A4F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A14 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A1B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A22 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @0A48 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616e6e6f742062652063616c6c6564206279206120636f6e74726163740000 // @0A4B stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x090c label_0A50: // Incoming jump from 0x0A08, if msg.sender == tx.origin // Inputs[2] // { // @0A53 storage[0x0d] // @0A54 msg.sender // } 0A50 5B JUMPDEST 0A51 60 PUSH1 0x0d 0A53 54 SLOAD 0A54 33 CALLER 0A55 90 SWAP1 0A56 60 PUSH1 0xff 0A58 16 AND 0A59 15 ISZERO 0A5A 61 PUSH2 0x0a9e 0A5D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A55 stack[0] = msg.sender } // Block ends with conditional jump to 0x0a9e, if !(0xff & storage[0x0d]) label_0A5E: // Incoming jump from 0x0A5D, if not !(0xff & storage[0x0d]) // Inputs[1] { @0A60 memory[0x40:0x60] } 0A5E 60 PUSH1 0x40 0A60 51 MLOAD 0A61 62 PUSH3 0x461bcd 0A65 60 PUSH1 0xe5 0A67 1B SHL 0A68 81 DUP2 0A69 52 MSTORE 0A6A 60 PUSH1 0x20 0A6C 60 PUSH1 0x04 0A6E 82 DUP3 0A6F 01 ADD 0A70 52 MSTORE 0A71 60 PUSH1 0x16 0A73 60 PUSH1 0x24 0A75 82 DUP3 0A76 01 ADD 0A77 52 MSTORE 0A78 75 PUSH22 0x1d1a194818dbdb9d1c9858dd081a5cc81c185d5cd959 0A8F 60 PUSH1 0x52 0A91 1B SHL 0A92 60 PUSH1 0x44 0A94 82 DUP3 0A95 01 ADD 0A96 52 MSTORE 0A97 60 PUSH1 0x64 0A99 01 ADD 0A9A 61 PUSH2 0x090c 0A9D 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A69 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A70 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A77 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x16 // @0A96 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1d1a194818dbdb9d1c9858dd081a5cc81c185d5cd959 << 0x52 // @0A99 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x090c label_0A9E: // Incoming jump from 0x0A5D, if !(0xff & storage[0x0d]) // Inputs[4] // { // @0AA1 storage[0x0a] // @0AA4 storage[0x01] // @0AA7 storage[0x00] // @0AA8 stack[-4] // } 0A9E 5B JUMPDEST 0A9F 60 PUSH1 0x0a 0AA1 54 SLOAD 0AA2 60 PUSH1 0x01 0AA4 54 SLOAD 0AA5 60 PUSH1 0x00 0AA7 54 SLOAD 0AA8 86 DUP7 0AA9 91 SWAP2 0AAA 90 SWAP1 0AAB 03 SUB 0AAC 60 PUSH1 0x00 0AAE 19 NOT 0AAF 01 ADD 0AB0 61 PUSH2 0x0ab9 0AB3 91 SWAP2 0AB4 90 SWAP1 0AB5 61 PUSH2 0x205e 0AB8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0AA1 stack[0] = storage[0x0a] // @0AB3 stack[1] = 0x0ab9 // @0AB4 stack[2] = stack[-4] // @0AB4 stack[3] = ~0x00 + (storage[0x00] - storage[0x01]) // } // Block ends with call to 0x205e, returns to 0x0AB9 label_0AB9: // Incoming return from call to 0x205E at 0x0AB8 // Inputs[2] // { // @0ABA stack[-1] // @0ABA stack[-2] // } 0AB9 5B JUMPDEST 0ABA 11 GT 0ABB 15 ISZERO 0ABC 61 PUSH2 0x0afc 0ABF 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0afc, if !(stack[-1] > stack[-2]) label_0AC0: // Incoming jump from 0x0ABF, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0AC2 memory[0x40:0x60] } 0AC0 60 PUSH1 0x40 0AC2 51 MLOAD 0AC3 62 PUSH3 0x461bcd 0AC7 60 PUSH1 0xe5 0AC9 1B SHL 0ACA 81 DUP2 0ACB 52 MSTORE 0ACC 60 PUSH1 0x20 0ACE 60 PUSH1 0x04 0AD0 82 DUP3 0AD1 01 ADD 0AD2 52 MSTORE 0AD3 60 PUSH1 0x12 0AD5 60 PUSH1 0x24 0AD7 82 DUP3 0AD8 01 ADD 0AD9 52 MSTORE 0ADA 71 PUSH18 0x1b585e081cdd5c1c1b1e481c995858da1959 0AED 60 PUSH1 0x72 0AEF 1B SHL 0AF0 60 PUSH1 0x44 0AF2 82 DUP3 0AF3 01 ADD 0AF4 52 MSTORE 0AF5 60 PUSH1 0x64 0AF7 01 ADD 0AF8 61 PUSH2 0x090c 0AFB 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0ACB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AD2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0AD9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @0AF4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1b585e081cdd5c1c1b1e481c995858da1959 << 0x72 // @0AF7 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x090c label_0AFC: // Incoming jump from 0x0ABF, if !(stack[-1] > stack[-2]) // Inputs[4] // { // @0B05 stack[-1] // @0B14 memory[0x00:0x40] // @0B15 storage[keccak256(memory[0x00:0x40])] // @0B18 storage[0x0b] // } 0AFC 5B JUMPDEST 0AFD 60 PUSH1 0x01 0AFF 60 PUSH1 0x01 0B01 60 PUSH1 0xa0 0B03 1B SHL 0B04 03 SUB 0B05 81 DUP2 0B06 16 AND 0B07 60 PUSH1 0x00 0B09 90 SWAP1 0B0A 81 DUP2 0B0B 52 MSTORE 0B0C 60 PUSH1 0x14 0B0E 60 PUSH1 0x20 0B10 52 MSTORE 0B11 60 PUSH1 0x40 0B13 90 SWAP1 0B14 20 SHA3 0B15 54 SLOAD 0B16 60 PUSH1 0x0b 0B18 54 SLOAD 0B19 61 PUSH2 0x0b22 0B1C 91 SWAP2 0B1D 90 SWAP1 0B1E 61 PUSH2 0x2076 0B21 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0B0B memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0B10 memory[0x20:0x40] = 0x14 // @0B1C stack[0] = 0x0b22 // @0B1D stack[1] = storage[keccak256(memory[0x00:0x40])] // @0B1D stack[2] = storage[0x0b] // } // Block ends with call to 0x2076, returns to 0x0B22 label_0B22: // Incoming return from call to 0x2076 at 0x0B21 // Inputs[2] // { // @0B23 stack[-5] // @0B24 stack[-1] // } 0B22 5B JUMPDEST 0B23 84 DUP5 0B24 11 GT 0B25 15 ISZERO 0B26 61 PUSH2 0x0b6b 0B29 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b6b, if !(stack[-5] > stack[-1]) label_0B2A: // Incoming jump from 0x0B29, if not !(stack[-5] > stack[-1]) // Inputs[1] { @0B2C memory[0x40:0x60] } 0B2A 60 PUSH1 0x40 0B2C 51 MLOAD 0B2D 62 PUSH3 0x461bcd 0B31 60 PUSH1 0xe5 0B33 1B SHL 0B34 81 DUP2 0B35 52 MSTORE 0B36 60 PUSH1 0x20 0B38 60 PUSH1 0x04 0B3A 82 DUP3 0B3B 01 ADD 0B3C 52 MSTORE 0B3D 60 PUSH1 0x17 0B3F 60 PUSH1 0x24 0B41 82 DUP3 0B42 01 ADD 0B43 52 MSTORE 0B44 76 PUSH23 0x125b9cdd59999a58da595b9d081b5a5b9d1cc81b19599d 0B5C 60 PUSH1 0x4a 0B5E 1B SHL 0B5F 60 PUSH1 0x44 0B61 82 DUP3 0B62 01 ADD 0B63 52 MSTORE 0B64 60 PUSH1 0x64 0B66 01 ADD 0B67 61 PUSH2 0x090c 0B6A 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0B35 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B3C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B43 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x17 // @0B63 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x125b9cdd59999a58da595b9d081b5a5b9d1cc81b19599d << 0x4a // @0B66 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x090c label_0B6B: // Incoming jump from 0x0B29, if !(stack[-5] > stack[-1]) // Inputs[3] // { // @0B6F stack[-3] // @0B70 stack[-2] // @0B71 stack[-1] // } 0B6B 5B JUMPDEST 0B6C 61 PUSH2 0x0b76 0B6F 83 DUP4 0B70 83 DUP4 0B71 83 DUP4 0B72 61 PUSH2 0x1655 0B75 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B6C stack[0] = 0x0b76 // @0B6F stack[1] = stack[-3] // @0B70 stack[2] = stack[-2] // @0B71 stack[3] = stack[-1] // } // Block ends with call to 0x1655, returns to 0x0B76 label_0B76: // Incoming return from call to 0x1655 at 0x0B75 // Inputs[1] { @0B7A stack[-1] } 0B76 5B JUMPDEST 0B77 61 PUSH2 0x0bb2 0B7A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0bb2, if stack[-1] label_0B7B: // Incoming jump from 0x0B7A, if not stack[-1] // Inputs[1] { @0B7D memory[0x40:0x60] } 0B7B 60 PUSH1 0x40 0B7D 51 MLOAD 0B7E 62 PUSH3 0x461bcd 0B82 60 PUSH1 0xe5 0B84 1B SHL 0B85 81 DUP2 0B86 52 MSTORE 0B87 60 PUSH1 0x20 0B89 60 PUSH1 0x04 0B8B 82 DUP3 0B8C 01 ADD 0B8D 52 MSTORE 0B8E 60 PUSH1 0x0d 0B90 60 PUSH1 0x24 0B92 82 DUP3 0B93 01 ADD 0B94 52 MSTORE 0B95 6C PUSH13 0x24b73b30b634b210383937b7b3 0BA3 60 PUSH1 0x99 0BA5 1B SHL 0BA6 60 PUSH1 0x44 0BA8 82 DUP3 0BA9 01 ADD 0BAA 52 MSTORE 0BAB 60 PUSH1 0x64 0BAD 01 ADD 0BAE 61 PUSH2 0x090c 0BB1 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0B86 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B8D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B94 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0d // @0BAA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x24b73b30b634b210383937b7b3 << 0x99 // @0BAD stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x090c label_0BB2: // Incoming jump from 0x0B7A, if stack[-1] // Inputs[2] // { // @0BB3 stack[-4] // @0BB6 storage[0x11] // } 0BB2 5B JUMPDEST 0BB3 83 DUP4 0BB4 60 PUSH1 0x11 0BB6 54 SLOAD 0BB7 61 PUSH2 0x0bc0 0BBA 91 SWAP2 0BBB 90 SWAP1 0BBC 61 PUSH2 0x208d 0BBF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BBA stack[0] = 0x0bc0 // @0BBB stack[1] = stack[-4] // @0BBB stack[2] = storage[0x11] // } // Block ends with call to 0x208d, returns to 0x0BC0 label_0BC0: // Incoming return from call to 0x208D at 0x0BBF // Inputs[2] // { // @0BC1 msg.value // @0BC2 stack[-1] // } 0BC0 5B JUMPDEST 0BC1 34 CALLVALUE 0BC2 14 EQ 0BC3 61 PUSH2 0x0c0e 0BC6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c0e, if msg.value == stack[-1] label_0BC7: // Incoming jump from 0x0BC6, if not msg.value == stack[-1] // Inputs[1] { @0BC9 memory[0x40:0x60] } 0BC7 60 PUSH1 0x40 0BC9 51 MLOAD 0BCA 62 PUSH3 0x461bcd 0BCE 60 PUSH1 0xe5 0BD0 1B SHL 0BD1 81 DUP2 0BD2 52 MSTORE 0BD3 60 PUSH1 0x20 0BD5 60 PUSH1 0x04 0BD7 82 DUP3 0BD8 01 ADD 0BD9 52 MSTORE 0BDA 60 PUSH1 0x18 0BDC 60 PUSH1 0x24 0BDE 82 DUP3 0BDF 01 ADD 0BE0 52 MSTORE 0BE1 7F PUSH32 0x496e636f72726563742070617961626c6520616d6f756e740000000000000000 0C02 60 PUSH1 0x44 0C04 82 DUP3 0C05 01 ADD 0C06 52 MSTORE 0C07 60 PUSH1 0x64 0C09 01 ADD 0C0A 61 PUSH2 0x090c 0C0D 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0BD2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BD9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BE0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x18 // @0C06 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e636f72726563742070617961626c6520616d6f756e740000000000000000 // @0C09 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x090c label_0C0E: // Incoming jump from 0x0BC6, if msg.value == stack[-1] // Inputs[4] // { // @0C17 stack[-1] // @0C26 memory[0x00:0x40] // @0C28 storage[keccak256(memory[0x00:0x40])] // @0C29 stack[-4] // } 0C0E 5B JUMPDEST 0C0F 60 PUSH1 0x01 0C11 60 PUSH1 0x01 0C13 60 PUSH1 0xa0 0C15 1B SHL 0C16 03 SUB 0C17 81 DUP2 0C18 16 AND 0C19 60 PUSH1 0x00 0C1B 90 SWAP1 0C1C 81 DUP2 0C1D 52 MSTORE 0C1E 60 PUSH1 0x14 0C20 60 PUSH1 0x20 0C22 52 MSTORE 0C23 60 PUSH1 0x40 0C25 81 DUP2 0C26 20 SHA3 0C27 80 DUP1 0C28 54 SLOAD 0C29 86 DUP7 0C2A 92 SWAP3 0C2B 90 SWAP1 0C2C 61 PUSH2 0x0c36 0C2F 90 SWAP1 0C30 84 DUP5 0C31 90 SWAP1 0C32 61 PUSH2 0x205e 0C35 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @0C1D memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0C22 memory[0x20:0x40] = 0x14 // @0C26 stack[1] = keccak256(memory[0x00:0x40]) // @0C2A stack[0] = stack[-4] // @0C2B stack[2] = 0x00 // @0C2F stack[3] = 0x0c36 // @0C31 stack[4] = stack[-4] // @0C31 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x205e, returns to 0x0C36 label_0C36: // Incoming return from call to 0x205E at 0x0C35 // Inputs[6] // { // @0C37 stack[-1] // @0C37 stack[-2] // @0C38 stack[-3] // @0C3E stack[-4] // @0C40 stack[-5] // @0C41 stack[-8] // } 0C36 5B JUMPDEST 0C37 90 SWAP1 0C38 91 SWAP2 0C39 55 SSTORE 0C3A 50 POP 0C3B 61 PUSH2 0x0c46 0C3E 90 SWAP1 0C3F 50 POP 0C40 81 DUP2 0C41 85 DUP6 0C42 61 PUSH2 0x16db 0C45 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0C39 storage[stack[-3]] = stack[-1] // @0C3E stack[-4] = 0x0c46 // @0C40 stack[-3] = stack[-5] // @0C41 stack[-2] = stack[-8] // } // Block ends with call to 0x16db, returns to 0x0C46 label_0C46: // Incoming jump from 0x1C9B, if !(stack[-1] > stack[-4]) // Incoming return from call to 0x16DB at 0x0C45 // Inputs[1] { @0C4B stack[-5] } 0C46 5B JUMPDEST 0C47 50 POP 0C48 50 POP 0C49 50 POP 0C4A 50 POP 0C4B 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0C4C: // Incoming jump from 0x0487 // Inputs[1] { @0C57 stack[-1] } 0C4C 5B JUMPDEST 0C4D 60 PUSH1 0x00 0C4F 60 PUSH1 0x01 0C51 60 PUSH1 0x01 0C53 60 PUSH1 0xa0 0C55 1B SHL 0C56 03 SUB 0C57 82 DUP3 0C58 16 AND 0C59 61 PUSH2 0x0c75 0C5C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C4D stack[0] = 0x00 } // Block ends with conditional jump to 0x0c75, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0C5D: // Incoming jump from 0x0C5C, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0C5F memory[0x40:0x60] // @0C6F memory[0x40:0x60] // @0C74 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C5D 60 PUSH1 0x40 0C5F 51 MLOAD 0C60 63 PUSH4 0x23d3ad81 0C65 60 PUSH1 0xe2 0C67 1B SHL 0C68 81 DUP2 0C69 52 MSTORE 0C6A 60 PUSH1 0x04 0C6C 01 ADD 0C6D 60 PUSH1 0x40 0C6F 51 MLOAD 0C70 80 DUP1 0C71 91 SWAP2 0C72 03 SUB 0C73 90 SWAP1 0C74 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C69 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x23d3ad81 << 0xe2 // @0C74 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C75: // Incoming jump from 0x0C5C, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0C7F stack[-2] // @0C8D memory[0x00:0x40] // @0C8E storage[keccak256(memory[0x00:0x40])] // @0C99 stack[-3] // } 0C75 5B JUMPDEST 0C76 50 POP 0C77 60 PUSH1 0x01 0C79 60 PUSH1 0x01 0C7B 60 PUSH1 0xa0 0C7D 1B SHL 0C7E 03 SUB 0C7F 16 AND 0C80 60 PUSH1 0x00 0C82 90 SWAP1 0C83 81 DUP2 0C84 52 MSTORE 0C85 60 PUSH1 0x05 0C87 60 PUSH1 0x20 0C89 52 MSTORE 0C8A 60 PUSH1 0x40 0C8C 90 SWAP1 0C8D 20 SHA3 0C8E 54 SLOAD 0C8F 67 PUSH8 0xffffffffffffffff 0C98 16 AND 0C99 90 SWAP1 0C9A 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0C84 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0C89 memory[0x20:0x40] = 0x05 // @0C99 stack[-3] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0C9B: // Incoming call from 0x049C, returns to 0x02C3 // Inputs[2] // { // @0C9E storage[0x08] // @0CA8 msg.sender // } 0C9B 5B JUMPDEST 0C9C 60 PUSH1 0x08 0C9E 54 SLOAD 0C9F 60 PUSH1 0x01 0CA1 60 PUSH1 0x01 0CA3 60 PUSH1 0xa0 0CA5 1B SHL 0CA6 03 SUB 0CA7 16 AND 0CA8 33 CALLER 0CA9 14 EQ 0CAA 61 PUSH2 0x0cc5 0CAD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cc5, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0CAE: // Incoming jump from 0x0CAD, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0CB0 memory[0x40:0x60] } 0CAE 60 PUSH1 0x40 0CB0 51 MLOAD 0CB1 62 PUSH3 0x461bcd 0CB5 60 PUSH1 0xe5 0CB7 1B SHL 0CB8 81 DUP2 0CB9 52 MSTORE 0CBA 60 PUSH1 0x04 0CBC 01 ADD 0CBD 61 PUSH2 0x090c 0CC0 90 SWAP1 0CC1 61 PUSH2 0x2013 0CC4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0CB9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CC0 stack[0] = 0x090c // @0CC0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2013, returns to 0x090C label_0CC5: // Incoming jump from 0x0CAD, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] 0CC5 5B JUMPDEST 0CC6 61 PUSH2 0x0ccf 0CC9 60 PUSH1 0x00 0CCB 61 PUSH2 0x16f5 0CCE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0CC6 stack[0] = 0x0ccf // @0CC9 stack[1] = 0x00 // } // Block ends with call to 0x16f5, returns to 0x0CCF label_0CCF: // Incoming return from call to 0x16F5 at 0x0CCE // Inputs[1] { @0CD0 stack[-1] } 0CCF 5B JUMPDEST 0CD0 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0CD1: // Incoming call from 0x04B1, returns to 0x02C3 // Inputs[2] // { // @0CD4 storage[0x08] // @0CDE msg.sender // } 0CD1 5B JUMPDEST 0CD2 60 PUSH1 0x08 0CD4 54 SLOAD 0CD5 60 PUSH1 0x01 0CD7 60 PUSH1 0x01 0CD9 60 PUSH1 0xa0 0CDB 1B SHL 0CDC 03 SUB 0CDD 16 AND 0CDE 33 CALLER 0CDF 14 EQ 0CE0 61 PUSH2 0x0cfb 0CE3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cfb, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0CE4: // Incoming jump from 0x0CE3, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0CE6 memory[0x40:0x60] } 0CE4 60 PUSH1 0x40 0CE6 51 MLOAD 0CE7 62 PUSH3 0x461bcd 0CEB 60 PUSH1 0xe5 0CED 1B SHL 0CEE 81 DUP2 0CEF 52 MSTORE 0CF0 60 PUSH1 0x04 0CF2 01 ADD 0CF3 61 PUSH2 0x090c 0CF6 90 SWAP1 0CF7 61 PUSH2 0x2013 0CFA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0CEF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CF6 stack[0] = 0x090c // @0CF6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2013, returns to 0x090C label_0CFB: // Incoming jump from 0x0CE3, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0CFF storage[0x0d] // @0D17 stack[-1] // } 0CFB 5B JUMPDEST 0CFC 60 PUSH1 0x0d 0CFE 80 DUP1 0CFF 54 SLOAD 0D00 61 PUSH2 0xff00 0D03 19 NOT 0D04 81 DUP2 0D05 16 AND 0D06 61 PUSH2 0x0100 0D09 91 SWAP2 0D0A 82 DUP3 0D0B 90 SWAP1 0D0C 04 DIV 0D0D 60 PUSH1 0xff 0D0F 16 AND 0D10 15 ISZERO 0D11 90 SWAP1 0D12 91 SWAP2 0D13 02 MUL 0D14 17 OR 0D15 90 SWAP1 0D16 55 SSTORE 0D17 56 *JUMP // Stack delta = -1 // Outputs[1] { @0D16 storage[0x0d] = 0x0100 * !(0xff & storage[0x0d] / 0x0100) | (storage[0x0d] & ~0xff00) } // Block ends with unconditional jump to stack[-1] label_0D18: // Incoming jump from 0x04D1 // Inputs[2] // { // @0D1B storage[0x08] // @0D25 msg.sender // } 0D18 5B JUMPDEST 0D19 60 PUSH1 0x08 0D1B 54 SLOAD 0D1C 60 PUSH1 0x01 0D1E 60 PUSH1 0x01 0D20 60 PUSH1 0xa0 0D22 1B SHL 0D23 03 SUB 0D24 16 AND 0D25 33 CALLER 0D26 14 EQ 0D27 61 PUSH2 0x0d42 0D2A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d42, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0D2B: // Incoming jump from 0x0D2A, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0D2D memory[0x40:0x60] } 0D2B 60 PUSH1 0x40 0D2D 51 MLOAD 0D2E 62 PUSH3 0x461bcd 0D32 60 PUSH1 0xe5 0D34 1B SHL 0D35 81 DUP2 0D36 52 MSTORE 0D37 60 PUSH1 0x04 0D39 01 ADD 0D3A 61 PUSH2 0x090c 0D3D 90 SWAP1 0D3E 61 PUSH2 0x2013 0D41 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D36 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D3D stack[0] = 0x090c // @0D3D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2013, returns to 0x090C label_0D42: // Incoming jump from 0x0D2A, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0D46 stack[-2] // @0D47 stack[-1] // } 0D42 5B JUMPDEST 0D43 61 PUSH2 0x099c 0D46 82 DUP3 0D47 82 DUP3 0D48 61 PUSH2 0x16db 0D4B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D43 stack[0] = 0x099c // @0D46 stack[1] = stack[-2] // @0D47 stack[2] = stack[-1] // } // Block ends with call to 0x16db, returns to 0x099C label_0D4C: // Incoming jump from 0x0521 // Inputs[2] // { // @0D4F storage[0x08] // @0D59 msg.sender // } 0D4C 5B JUMPDEST 0D4D 60 PUSH1 0x08 0D4F 54 SLOAD 0D50 60 PUSH1 0x01 0D52 60 PUSH1 0x01 0D54 60 PUSH1 0xa0 0D56 1B SHL 0D57 03 SUB 0D58 16 AND 0D59 33 CALLER 0D5A 14 EQ 0D5B 61 PUSH2 0x0d76 0D5E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d76, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0D5F: // Incoming jump from 0x0D5E, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0D61 memory[0x40:0x60] } 0D5F 60 PUSH1 0x40 0D61 51 MLOAD 0D62 62 PUSH3 0x461bcd 0D66 60 PUSH1 0xe5 0D68 1B SHL 0D69 81 DUP2 0D6A 52 MSTORE 0D6B 60 PUSH1 0x04 0D6D 01 ADD 0D6E 61 PUSH2 0x090c 0D71 90 SWAP1 0D72 61 PUSH2 0x2013 0D75 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D6A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D71 stack[0] = 0x090c // @0D71 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2013, returns to 0x090C label_0D76: // Incoming jump from 0x0D5E, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0D79 stack[-1] // @0D7A stack[-2] // } 0D76 5B JUMPDEST 0D77 60 PUSH1 0x09 0D79 55 SSTORE 0D7A 56 *JUMP // Stack delta = -2 // Outputs[1] { @0D79 storage[0x09] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0D7B: // Incoming jump from 0x055F // Inputs[2] // { // @0D7E storage[0x08] // @0D88 msg.sender // } 0D7B 5B JUMPDEST 0D7C 60 PUSH1 0x08 0D7E 54 SLOAD 0D7F 60 PUSH1 0x01 0D81 60 PUSH1 0x01 0D83 60 PUSH1 0xa0 0D85 1B SHL 0D86 03 SUB 0D87 16 AND 0D88 33 CALLER 0D89 14 EQ 0D8A 61 PUSH2 0x0da5 0D8D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0da5, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0D8E: // Incoming jump from 0x0D8D, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0D90 memory[0x40:0x60] } 0D8E 60 PUSH1 0x40 0D90 51 MLOAD 0D91 62 PUSH3 0x461bcd 0D95 60 PUSH1 0xe5 0D97 1B SHL 0D98 81 DUP2 0D99 52 MSTORE 0D9A 60 PUSH1 0x04 0D9C 01 ADD 0D9D 61 PUSH2 0x090c 0DA0 90 SWAP1 0DA1 61 PUSH2 0x2013 0DA4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D99 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DA0 stack[0] = 0x090c // @0DA0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2013, returns to 0x090C label_0DA5: // Incoming jump from 0x0D8D, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0DA8 stack[-1] // @0DA9 stack[-2] // } 0DA5 5B JUMPDEST 0DA6 60 PUSH1 0x11 0DA8 55 SSTORE 0DA9 56 *JUMP // Stack delta = -2 // Outputs[1] { @0DA8 storage[0x11] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0DAA: // Incoming call from 0x0574, returns to 0x025E // Inputs[1] { @0DB0 storage[0x03] } 0DAA 5B JUMPDEST 0DAB 60 PUSH1 0x60 0DAD 60 PUSH1 0x03 0DAF 80 DUP1 0DB0 54 SLOAD 0DB1 61 PUSH2 0x06f4 0DB4 90 SWAP1 0DB5 61 PUSH2 0x1fd8 0DB8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0DAB stack[0] = 0x60 // @0DAD stack[1] = 0x03 // @0DB4 stack[2] = 0x06f4 // @0DB4 stack[3] = storage[0x03] // } // Block ends with call to 0x1fd8, returns to 0x06F4 label_0DB9: // Incoming jump from 0x05B4 // Inputs[2] // { // @0DBA tx.origin // @0DBB msg.sender // } 0DB9 5B JUMPDEST 0DBA 32 ORIGIN 0DBB 33 CALLER 0DBC 14 EQ 0DBD 61 PUSH2 0x0e08 0DC0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e08, if msg.sender == tx.origin label_0DC1: // Incoming jump from 0x0DC0, if not msg.sender == tx.origin // Inputs[1] { @0DC3 memory[0x40:0x60] } 0DC1 60 PUSH1 0x40 0DC3 51 MLOAD 0DC4 62 PUSH3 0x461bcd 0DC8 60 PUSH1 0xe5 0DCA 1B SHL 0DCB 81 DUP2 0DCC 52 MSTORE 0DCD 60 PUSH1 0x20 0DCF 60 PUSH1 0x04 0DD1 82 DUP3 0DD2 01 ADD 0DD3 52 MSTORE 0DD4 60 PUSH1 0x1e 0DD6 60 PUSH1 0x24 0DD8 82 DUP3 0DD9 01 ADD 0DDA 52 MSTORE 0DDB 7F PUSH32 0x43616e6e6f742062652063616c6c6564206279206120636f6e74726163740000 0DFC 60 PUSH1 0x44 0DFE 82 DUP3 0DFF 01 ADD 0E00 52 MSTORE 0E01 60 PUSH1 0x64 0E03 01 ADD 0E04 61 PUSH2 0x090c 0E07 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0DCC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DD3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DDA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @0E00 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616e6e6f742062652063616c6c6564206279206120636f6e74726163740000 // @0E03 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x090c label_0E08: // Incoming jump from 0x0DC0, if msg.sender == tx.origin // Inputs[1] { @0E0B storage[0x0d] } 0E08 5B JUMPDEST 0E09 60 PUSH1 0x0d 0E0B 54 SLOAD 0E0C 61 PUSH2 0x0100 0E0F 90 SWAP1 0E10 04 DIV 0E11 60 PUSH1 0xff 0E13 16 AND 0E14 61 PUSH2 0x0e5f 0E17 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e5f, if 0xff & storage[0x0d] / 0x0100 label_0E18: // Incoming jump from 0x0E17, if not 0xff & storage[0x0d] / 0x0100 // Inputs[1] { @0E1A memory[0x40:0x60] } 0E18 60 PUSH1 0x40 0E1A 51 MLOAD 0E1B 62 PUSH3 0x461bcd 0E1F 60 PUSH1 0xe5 0E21 1B SHL 0E22 81 DUP2 0E23 52 MSTORE 0E24 60 PUSH1 0x20 0E26 60 PUSH1 0x04 0E28 82 DUP3 0E29 01 ADD 0E2A 52 MSTORE 0E2B 60 PUSH1 0x19 0E2D 60 PUSH1 0x24 0E2F 82 DUP3 0E30 01 ADD 0E31 52 MSTORE 0E32 7F PUSH32 0x5075626c69632073616c65206973206e6f742061637469766500000000000000 0E53 60 PUSH1 0x44 0E55 82 DUP3 0E56 01 ADD 0E57 52 MSTORE 0E58 60 PUSH1 0x64 0E5A 01 ADD 0E5B 61 PUSH2 0x090c 0E5E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0E23 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E2A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E31 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @0E57 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5075626c69632073616c65206973206e6f742061637469766500000000000000 // @0E5A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x090c label_0E5F: // Incoming jump from 0x0E17, if 0xff & storage[0x0d] / 0x0100 // Inputs[4] // { // @0E62 storage[0x0a] // @0E65 storage[0x01] // @0E68 storage[0x00] // @0E69 stack[-1] // } 0E5F 5B JUMPDEST 0E60 60 PUSH1 0x0a 0E62 54 SLOAD 0E63 60 PUSH1 0x01 0E65 54 SLOAD 0E66 60 PUSH1 0x00 0E68 54 SLOAD 0E69 83 DUP4 0E6A 91 SWAP2 0E6B 90 SWAP1 0E6C 03 SUB 0E6D 60 PUSH1 0x00 0E6F 19 NOT 0E70 01 ADD 0E71 61 PUSH2 0x0e7a 0E74 91 SWAP2 0E75 90 SWAP1 0E76 61 PUSH2 0x205e 0E79 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E62 stack[0] = storage[0x0a] // @0E74 stack[1] = 0x0e7a // @0E75 stack[2] = stack[-1] // @0E75 stack[3] = ~0x00 + (storage[0x00] - storage[0x01]) // } // Block ends with call to 0x205e, returns to 0x0E7A label_0E7A: // Incoming return from call to 0x205E at 0x0E79 // Inputs[2] // { // @0E7B stack[-2] // @0E7B stack[-1] // } 0E7A 5B JUMPDEST 0E7B 11 GT 0E7C 15 ISZERO 0E7D 61 PUSH2 0x0ebd 0E80 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0ebd, if !(stack[-1] > stack[-2]) label_0E81: // Incoming jump from 0x0E80, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0E83 memory[0x40:0x60] } 0E81 60 PUSH1 0x40 0E83 51 MLOAD 0E84 62 PUSH3 0x461bcd 0E88 60 PUSH1 0xe5 0E8A 1B SHL 0E8B 81 DUP2 0E8C 52 MSTORE 0E8D 60 PUSH1 0x20 0E8F 60 PUSH1 0x04 0E91 82 DUP3 0E92 01 ADD 0E93 52 MSTORE 0E94 60 PUSH1 0x12 0E96 60 PUSH1 0x24 0E98 82 DUP3 0E99 01 ADD 0E9A 52 MSTORE 0E9B 71 PUSH18 0x1b585e081cdd5c1c1b1e481c995858da1959 0EAE 60 PUSH1 0x72 0EB0 1B SHL 0EB1 60 PUSH1 0x44 0EB3 82 DUP3 0EB4 01 ADD 0EB5 52 MSTORE 0EB6 60 PUSH1 0x64 0EB8 01 ADD 0EB9 61 PUSH2 0x090c 0EBC 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0E8C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E93 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E9A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @0EB5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1b585e081cdd5c1c1b1e481c995858da1959 << 0x72 // @0EB8 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x090c label_0EBD: // Incoming jump from 0x0E80, if !(stack[-1] > stack[-2]) // Inputs[4] // { // @0EBE msg.sender // @0ECC memory[0x00:0x40] // @0ECD storage[keccak256(memory[0x00:0x40])] // @0ED0 storage[0x0c] // } 0EBD 5B JUMPDEST 0EBE 33 CALLER 0EBF 60 PUSH1 0x00 0EC1 90 SWAP1 0EC2 81 DUP2 0EC3 52 MSTORE 0EC4 60 PUSH1 0x13 0EC6 60 PUSH1 0x20 0EC8 52 MSTORE 0EC9 60 PUSH1 0x40 0ECB 90 SWAP1 0ECC 20 SHA3 0ECD 54 SLOAD 0ECE 60 PUSH1 0x0c 0ED0 54 SLOAD 0ED1 61 PUSH2 0x0eda 0ED4 91 SWAP2 0ED5 90 SWAP1 0ED6 61 PUSH2 0x2076 0ED9 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0EC3 memory[0x00:0x20] = msg.sender // @0EC8 memory[0x20:0x40] = 0x13 // @0ED4 stack[0] = 0x0eda // @0ED5 stack[1] = storage[keccak256(memory[0x00:0x40])] // @0ED5 stack[2] = storage[0x0c] // } // Block ends with call to 0x2076, returns to 0x0EDA label_0EDA: // Incoming return from call to 0x2076 at 0x0ED9 // Inputs[2] // { // @0EDB stack[-2] // @0EDC stack[-1] // } 0EDA 5B JUMPDEST 0EDB 81 DUP2 0EDC 11 GT 0EDD 15 ISZERO 0EDE 61 PUSH2 0x0f23 0EE1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f23, if !(stack[-2] > stack[-1]) label_0EE2: // Incoming jump from 0x0EE1, if not !(stack[-2] > stack[-1]) // Inputs[1] { @0EE4 memory[0x40:0x60] } 0EE2 60 PUSH1 0x40 0EE4 51 MLOAD 0EE5 62 PUSH3 0x461bcd 0EE9 60 PUSH1 0xe5 0EEB 1B SHL 0EEC 81 DUP2 0EED 52 MSTORE 0EEE 60 PUSH1 0x20 0EF0 60 PUSH1 0x04 0EF2 82 DUP3 0EF3 01 ADD 0EF4 52 MSTORE 0EF5 60 PUSH1 0x17 0EF7 60 PUSH1 0x24 0EF9 82 DUP3 0EFA 01 ADD 0EFB 52 MSTORE 0EFC 76 PUSH23 0x125b9cdd59999a58da595b9d081b5a5b9d1cc81b19599d 0F14 60 PUSH1 0x4a 0F16 1B SHL 0F17 60 PUSH1 0x44 0F19 82 DUP3 0F1A 01 ADD 0F1B 52 MSTORE 0F1C 60 PUSH1 0x64 0F1E 01 ADD 0F1F 61 PUSH2 0x090c 0F22 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0EED memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EF4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0EFB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x17 // @0F1B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x125b9cdd59999a58da595b9d081b5a5b9d1cc81b19599d << 0x4a // @0F1E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x090c label_0F23: // Incoming jump from 0x0EE1, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @0F24 stack[-1] // @0F27 storage[0x12] // } 0F23 5B JUMPDEST 0F24 80 DUP1 0F25 60 PUSH1 0x12 0F27 54 SLOAD 0F28 61 PUSH2 0x0f31 0F2B 91 SWAP2 0F2C 90 SWAP1 0F2D 61 PUSH2 0x208d 0F30 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F2B stack[0] = 0x0f31 // @0F2C stack[1] = stack[-1] // @0F2C stack[2] = storage[0x12] // } // Block ends with call to 0x208d, returns to 0x0F31 label_0F31: // Incoming return from call to 0x208D at 0x0F30 // Inputs[2] // { // @0F32 msg.value // @0F33 stack[-1] // } 0F31 5B JUMPDEST 0F32 34 CALLVALUE 0F33 10 LT 0F34 15 ISZERO 0F35 61 PUSH2 0x0f80 0F38 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f80, if !(msg.value < stack[-1]) label_0F39: // Incoming jump from 0x0F38, if not !(msg.value < stack[-1]) // Inputs[1] { @0F3B memory[0x40:0x60] } 0F39 60 PUSH1 0x40 0F3B 51 MLOAD 0F3C 62 PUSH3 0x461bcd 0F40 60 PUSH1 0xe5 0F42 1B SHL 0F43 81 DUP2 0F44 52 MSTORE 0F45 60 PUSH1 0x20 0F47 60 PUSH1 0x04 0F49 82 DUP3 0F4A 01 ADD 0F4B 52 MSTORE 0F4C 60 PUSH1 0x1b 0F4E 60 PUSH1 0x24 0F50 82 DUP3 0F51 01 ADD 0F52 52 MSTORE 0F53 7F PUSH32 0x696e73756666696369656e742066756e64732070726f76696465640000000000 0F74 60 PUSH1 0x44 0F76 82 DUP3 0F77 01 ADD 0F78 52 MSTORE 0F79 60 PUSH1 0x64 0F7B 01 ADD 0F7C 61 PUSH2 0x090c 0F7F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0F44 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F4B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F52 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1b // @0F78 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x696e73756666696369656e742066756e64732070726f76696465640000000000 // @0F7B stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x090c label_0F80: // Incoming jump from 0x0F38, if !(msg.value < stack[-1]) // Inputs[4] // { // @0F81 msg.sender // @0F8F memory[0x00:0x40] // @0F91 storage[keccak256(memory[0x00:0x40])] // @0F92 stack[-1] // } 0F80 5B JUMPDEST 0F81 33 CALLER 0F82 60 PUSH1 0x00 0F84 90 SWAP1 0F85 81 DUP2 0F86 52 MSTORE 0F87 60 PUSH1 0x13 0F89 60 PUSH1 0x20 0F8B 52 MSTORE 0F8C 60 PUSH1 0x40 0F8E 81 DUP2 0F8F 20 SHA3 0F90 80 DUP1 0F91 54 SLOAD 0F92 83 DUP4 0F93 92 SWAP3 0F94 90 SWAP1 0F95 61 PUSH2 0x0f9f 0F98 90 SWAP1 0F99 84 DUP5 0F9A 90 SWAP1 0F9B 61 PUSH2 0x205e 0F9E 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @0F86 memory[0x00:0x20] = msg.sender // @0F8B memory[0x20:0x40] = 0x13 // @0F8F stack[1] = keccak256(memory[0x00:0x40]) // @0F93 stack[0] = stack[-1] // @0F94 stack[2] = 0x00 // @0F98 stack[3] = 0x0f9f // @0F9A stack[4] = stack[-1] // @0F9A stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x205e, returns to 0x0F9F label_0F9F: // Incoming return from call to 0x205E at 0x0F9E // Inputs[6] // { // @0FA0 stack[-1] // @0FA0 stack[-2] // @0FA1 stack[-3] // @0FA7 stack[-4] // @0FA9 msg.sender // @0FAA stack[-5] // } 0F9F 5B JUMPDEST 0FA0 90 SWAP1 0FA1 91 SWAP2 0FA2 55 SSTORE 0FA3 50 POP 0FA4 61 PUSH2 0x0941 0FA7 90 SWAP1 0FA8 50 POP 0FA9 33 CALLER 0FAA 82 DUP3 0FAB 61 PUSH2 0x16db 0FAE 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0FA2 storage[stack[-3]] = stack[-1] // @0FA7 stack[-4] = 0x0941 // @0FA9 stack[-3] = msg.sender // @0FAA stack[-2] = stack[-5] // } // Block ends with call to 0x16db, returns to 0x0941 label_0FAF: // Incoming jump from 0x05D4 // Inputs[2] // { // @0FB8 stack[-2] // @0FBA msg.sender // } 0FAF 5B JUMPDEST 0FB0 60 PUSH1 0x01 0FB2 60 PUSH1 0x01 0FB4 60 PUSH1 0xa0 0FB6 1B SHL 0FB7 03 SUB 0FB8 82 DUP3 0FB9 16 AND 0FBA 33 CALLER 0FBB 14 EQ 0FBC 15 ISZERO 0FBD 61 PUSH2 0x0fd9 0FC0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fd9, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) label_0FC1: // Incoming jump from 0x0FC0, if not !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @0FC3 memory[0x40:0x60] // @0FD3 memory[0x40:0x60] // @0FD8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0FC1 60 PUSH1 0x40 0FC3 51 MLOAD 0FC4 63 PUSH4 0xb06307db 0FC9 60 PUSH1 0xe0 0FCB 1B SHL 0FCC 81 DUP2 0FCD 52 MSTORE 0FCE 60 PUSH1 0x04 0FD0 01 ADD 0FD1 60 PUSH1 0x40 0FD3 51 MLOAD 0FD4 80 DUP1 0FD5 91 SWAP2 0FD6 03 SUB 0FD7 90 SWAP1 0FD8 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0FCD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb06307db << 0xe0 // @0FD8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0FD9: // Incoming jump from 0x0FC0, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[10] // { // @0FDA msg.sender // @0FEB memory[0x00:0x40] // @0FF4 stack[-2] // @0FFF memory[0x00:0x40] // @1001 storage[keccak256(memory[0x00:0x40])] // @1006 stack[-1] // @1010 memory[0x40:0x60] // @103C memory[0x40:0x60] // @1041 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1044 stack[-3] // } 0FD9 5B JUMPDEST 0FDA 33 CALLER 0FDB 60 PUSH1 0x00 0FDD 81 DUP2 0FDE 81 DUP2 0FDF 52 MSTORE 0FE0 60 PUSH1 0x07 0FE2 60 PUSH1 0x20 0FE4 90 SWAP1 0FE5 81 DUP2 0FE6 52 MSTORE 0FE7 60 PUSH1 0x40 0FE9 80 DUP1 0FEA 83 DUP4 0FEB 20 SHA3 0FEC 60 PUSH1 0x01 0FEE 60 PUSH1 0x01 0FF0 60 PUSH1 0xa0 0FF2 1B SHL 0FF3 03 SUB 0FF4 87 DUP8 0FF5 16 AND 0FF6 80 DUP1 0FF7 85 DUP6 0FF8 52 MSTORE 0FF9 90 SWAP1 0FFA 83 DUP4 0FFB 52 MSTORE 0FFC 92 SWAP3 0FFD 81 DUP2 0FFE 90 SWAP1 0FFF 20 SHA3 1000 80 DUP1 1001 54 SLOAD 1002 60 PUSH1 0xff 1004 19 NOT 1005 16 AND 1006 86 DUP7 1007 15 ISZERO 1008 15 ISZERO 1009 90 SWAP1 100A 81 DUP2 100B 17 OR 100C 90 SWAP1 100D 91 SWAP2 100E 55 SSTORE 100F 90 SWAP1 1010 51 MLOAD 1011 90 SWAP1 1012 81 DUP2 1013 52 MSTORE 1014 91 SWAP2 1015 92 SWAP3 1016 91 SWAP2 1017 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1038 91 SWAP2 1039 01 ADD 103A 60 PUSH1 0x40 103C 51 MLOAD 103D 80 DUP1 103E 91 SWAP2 103F 03 SUB 1040 90 SWAP1 1041 A3 LOG3 1042 50 POP 1043 50 POP 1044 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0FDF memory[0x00:0x20] = msg.sender // @0FE6 memory[0x20:0x40] = 0x07 // @0FF8 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0FFB memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @100E storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1013 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @1041 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-3] label_1045: // Incoming jump from 0x095E // Incoming jump from 0x05F4 // Inputs[3] // { // @1049 stack[-4] // @104A stack[-3] // @104B stack[-2] // } 1045 5B JUMPDEST 1046 61 PUSH2 0x1050 1049 84 DUP5 104A 84 DUP5 104B 84 DUP5 104C 61 PUSH2 0x133c 104F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1046 stack[0] = 0x1050 // @1049 stack[1] = stack[-4] // @104A stack[2] = stack[-3] // @104B stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x133c 1050 5B JUMPDEST 1051 60 PUSH1 0x01 1053 60 PUSH1 0x01 1055 60 PUSH1 0xa0 1057 1B SHL 1058 03 SUB 1059 83 DUP4 105A 16 AND 105B 3B EXTCODESIZE 105C 15 ISZERO 105D 15 ISZERO 105E 80 DUP1 105F 15 ISZERO 1060 61 PUSH2 0x1072 1063 57 *JUMPI 1064 50 POP 1065 61 PUSH2 0x1070 1068 84 DUP5 1069 84 DUP5 106A 84 DUP5 106B 84 DUP5 106C 61 PUSH2 0x1747 106F 56 *JUMP 1070 5B JUMPDEST 1071 15 ISZERO 1072 5B JUMPDEST 1073 15 ISZERO 1074 61 PUSH2 0x0c46 1077 57 *JUMPI 1078 60 PUSH1 0x40 107A 51 MLOAD 107B 63 PUSH4 0x68d2bf6b 1080 60 PUSH1 0xe1 1082 1B SHL 1083 81 DUP2 1084 52 MSTORE 1085 60 PUSH1 0x04 1087 01 ADD 1088 60 PUSH1 0x40 108A 51 MLOAD 108B 80 DUP1 108C 91 SWAP2 108D 03 SUB 108E 90 SWAP1 108F FD *REVERT label_1090: // Incoming jump from 0x0614 // Inputs[1] { @1096 stack[-1] } 1090 5B JUMPDEST 1091 60 PUSH1 0x60 1093 61 PUSH2 0x109b 1096 82 DUP3 1097 61 PUSH2 0x12a7 109A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1091 stack[0] = 0x60 // @1093 stack[1] = 0x109b // @1096 stack[2] = stack[-1] // } // Block ends with call to 0x12a7, returns to 0x109B label_109B: // Incoming return from call to 0x12A7 at 0x109A // Inputs[1] { @109F stack[-1] } 109B 5B JUMPDEST 109C 61 PUSH2 0x10ff 109F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x10ff, if stack[-1] label_10A0: // Incoming jump from 0x109F, if not stack[-1] // Inputs[1] { @10A2 memory[0x40:0x60] } 10A0 60 PUSH1 0x40 10A2 51 MLOAD 10A3 62 PUSH3 0x461bcd 10A7 60 PUSH1 0xe5 10A9 1B SHL 10AA 81 DUP2 10AB 52 MSTORE 10AC 60 PUSH1 0x20 10AE 60 PUSH1 0x04 10B0 82 DUP3 10B1 01 ADD 10B2 52 MSTORE 10B3 60 PUSH1 0x2f 10B5 60 PUSH1 0x24 10B7 82 DUP3 10B8 01 ADD 10B9 52 MSTORE 10BA 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 10DB 60 PUSH1 0x44 10DD 82 DUP3 10DE 01 ADD 10DF 52 MSTORE 10E0 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 10F0 60 PUSH1 0x89 10F2 1B SHL 10F3 60 PUSH1 0x64 10F5 82 DUP3 10F6 01 ADD 10F7 52 MSTORE 10F8 60 PUSH1 0x84 10FA 01 ADD 10FB 61 PUSH2 0x090c 10FE 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @10AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10B2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10B9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @10DF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @10F7 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3732bc34b9ba32b73a103a37b5b2b7 << 0x89 // @10FA stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x090c label_10FF: // Incoming jump from 0x109F, if stack[-1] // Inputs[1] { @1102 storage[0x10] } 10FF 5B JUMPDEST 1100 60 PUSH1 0x10 1102 54 SLOAD 1103 60 PUSH1 0xff 1105 16 AND 1106 15 ISZERO 1107 61 PUSH2 0x113f 110A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x113f, if !(0xff & storage[0x10]) label_110B: // Incoming jump from 0x110A, if not !(0xff & storage[0x10]) // Inputs[1] { @1110 stack[-2] } 110B 60 PUSH1 0x0e 110D 61 PUSH2 0x1115 1110 83 DUP4 1111 61 PUSH2 0x183f 1114 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @110B stack[0] = 0x0e // @110D stack[1] = 0x1115 // @1110 stack[2] = stack[-2] // } // Block ends with call to 0x183f, returns to 0x1115 label_1115: // Incoming return from call to 0x183F at 0x1114 // Inputs[3] // { // @111A memory[0x40:0x60] // @1121 stack[-2] // @1122 stack[-1] // } 1115 5B JUMPDEST 1116 60 PUSH1 0x0f 1118 60 PUSH1 0x40 111A 51 MLOAD 111B 60 PUSH1 0x20 111D 01 ADD 111E 61 PUSH2 0x1129 1121 93 SWAP4 1122 92 SWAP3 1123 91 SWAP2 1124 90 SWAP1 1125 61 PUSH2 0x2146 1128 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1121 stack[-2] = 0x1129 // @1122 stack[-1] = stack[-2] // @1123 stack[0] = stack[-1] // @1124 stack[1] = 0x0f // @1124 stack[2] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x2146, returns to 0x1129 label_1129: // Incoming return from call to 0x2146 at 0x1128 // Inputs[5] // { // @112C memory[0x40:0x60] // @1130 stack[-1] // @1139 stack[-2] // @113B stack[-4] // @113C stack[-3] // } 1129 5B JUMPDEST 112A 60 PUSH1 0x40 112C 51 MLOAD 112D 60 PUSH1 0x20 112F 81 DUP2 1130 83 DUP4 1131 03 SUB 1132 03 SUB 1133 81 DUP2 1134 52 MSTORE 1135 90 SWAP1 1136 60 PUSH1 0x40 1138 52 MSTORE 1139 90 SWAP1 113A 50 POP 113B 91 SWAP2 113C 90 SWAP1 113D 50 POP 113E 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1134 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @1138 memory[0x40:0x60] = stack[-1] // @113B stack[-4] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-4] label_113F: // Incoming jump from 0x110A, if !(0xff & storage[0x10]) // Inputs[1] { @1143 storage[0x0e] } 113F 5B JUMPDEST 1140 60 PUSH1 0x0e 1142 80 DUP1 1143 54 SLOAD 1144 61 PUSH2 0x114c 1147 90 SWAP1 1148 61 PUSH2 0x1fd8 114B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1140 stack[0] = 0x0e // @1147 stack[1] = 0x114c // @1147 stack[2] = storage[0x0e] // } // Block ends with call to 0x1fd8, returns to 0x114C label_114C: // Incoming return from call to 0x1FD8 at 0x114B // Inputs[4] // { // @114D stack[-1] // @115C memory[0x40:0x60] // @1164 stack[-2] // @116F storage[stack[-2]] // } 114C 5B JUMPDEST 114D 80 DUP1 114E 60 PUSH1 0x1f 1150 01 ADD 1151 60 PUSH1 0x20 1153 80 DUP1 1154 91 SWAP2 1155 04 DIV 1156 02 MUL 1157 60 PUSH1 0x20 1159 01 ADD 115A 60 PUSH1 0x40 115C 51 MLOAD 115D 90 SWAP1 115E 81 DUP2 115F 01 ADD 1160 60 PUSH1 0x40 1162 52 MSTORE 1163 80 DUP1 1164 92 SWAP3 1165 91 SWAP2 1166 90 SWAP1 1167 81 DUP2 1168 81 DUP2 1169 52 MSTORE 116A 60 PUSH1 0x20 116C 01 ADD 116D 82 DUP3 116E 80 DUP1 116F 54 SLOAD 1170 61 PUSH2 0x1178 1173 90 SWAP1 1174 61 PUSH2 0x1fd8 1177 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @1162 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @1164 stack[-2] = memory[0x40:0x60] // @1165 stack[-1] = stack[-2] // @1166 stack[0] = stack[-1] // @1169 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @116C stack[1] = 0x20 + memory[0x40:0x60] // @116D stack[2] = stack[-2] // @1173 stack[4] = storage[stack[-2]] // @1173 stack[3] = 0x1178 // } // Block ends with call to 0x1fd8, returns to 0x1178 label_1178: // Incoming return from call to 0x1FD8 at 0x1177 // Inputs[1] { @1179 stack[-1] } 1178 5B JUMPDEST 1179 80 DUP1 117A 15 ISZERO 117B 61 PUSH2 0x11c5 117E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11c5, if !stack[-1] label_117F: // Incoming jump from 0x117E, if not !stack[-1] // Inputs[1] { @117F stack[-1] } 117F 80 DUP1 1180 60 PUSH1 0x1f 1182 10 LT 1183 61 PUSH2 0x119a 1186 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x119a, if 0x1f < stack[-1] label_1187: // Incoming jump from 0x1186, if not 0x1f < stack[-1] // Inputs[4] // { // @118B stack[-2] // @118C storage[stack[-2]] // @118F stack[-3] // @1191 stack[-1] // } 1187 61 PUSH2 0x0100 118A 80 DUP1 118B 83 DUP4 118C 54 SLOAD 118D 04 DIV 118E 02 MUL 118F 83 DUP4 1190 52 MSTORE 1191 91 SWAP2 1192 60 PUSH1 0x20 1194 01 ADD 1195 91 SWAP2 1196 61 PUSH2 0x11c5 1199 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1190 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1195 stack[-1] = stack[-1] // @1195 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x11c5 label_119A: // Incoming jump from 0x1186, if 0x1f < stack[-1] // Inputs[5] // { // @119B stack[-3] // @119C stack[-1] // @119E stack[-2] // @11A6 memory[0x00:0x20] // @11AA storage[keccak256(memory[0x00:0x20])] // } 119A 5B JUMPDEST 119B 82 DUP3 119C 01 ADD 119D 91 SWAP2 119E 90 SWAP1 119F 60 PUSH1 0x00 11A1 52 MSTORE 11A2 60 PUSH1 0x20 11A4 60 PUSH1 0x00 11A6 20 SHA3 11A7 90 SWAP1 11A8 5B JUMPDEST 11A9 81 DUP2 11AA 54 SLOAD 11AB 81 DUP2 11AC 52 MSTORE 11AD 90 SWAP1 11AE 60 PUSH1 0x01 11B0 01 ADD 11B1 90 SWAP1 11B2 60 PUSH1 0x20 11B4 01 ADD 11B5 80 DUP1 11B6 83 DUP4 11B7 11 GT 11B8 61 PUSH2 0x11a8 11BB 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @119D stack[-3] = stack[-3] + stack[-1] // @11A1 memory[0x00:0x20] = stack[-2] // @11AC memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @11B1 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @11B4 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x11a8, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_11BC: // Incoming jump from 0x11BB, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x11BB, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @11BC stack[-3] // @11BD stack[-1] // } 11BC 82 DUP3 11BD 90 SWAP1 11BE 03 SUB 11BF 60 PUSH1 0x1f 11C1 16 AND 11C2 82 DUP3 11C3 01 ADD 11C4 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @11C4 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @11C4 stack[-1] = stack[-3] // } // Block continues label_11C5: // Incoming jump from 0x117E, if !stack[-1] // Incoming jump from 0x1199 // Incoming jump from 0x11C4 // Inputs[4] // { // @11CB stack[-6] // @11CB stack[-7] // @11CD stack[-9] // @11CE stack[-8] // } 11C5 5B JUMPDEST 11C6 50 POP 11C7 50 POP 11C8 50 POP 11C9 50 POP 11CA 50 POP 11CB 90 SWAP1 11CC 50 POP 11CD 91 SWAP2 11CE 90 SWAP1 11CF 50 POP 11D0 56 *JUMP // Stack delta = -8 // Outputs[1] { @11CD stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_11D1: // Incoming call from 0x0629, returns to 0x02C3 // Inputs[2] // { // @11D4 storage[0x08] // @11DE msg.sender // } 11D1 5B JUMPDEST 11D2 60 PUSH1 0x08 11D4 54 SLOAD 11D5 60 PUSH1 0x01 11D7 60 PUSH1 0x01 11D9 60 PUSH1 0xa0 11DB 1B SHL 11DC 03 SUB 11DD 16 AND 11DE 33 CALLER 11DF 14 EQ 11E0 61 PUSH2 0x11fb 11E3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11fb, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_11E4: // Incoming jump from 0x11E3, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @11E6 memory[0x40:0x60] } 11E4 60 PUSH1 0x40 11E6 51 MLOAD 11E7 62 PUSH3 0x461bcd 11EB 60 PUSH1 0xe5 11ED 1B SHL 11EE 81 DUP2 11EF 52 MSTORE 11F0 60 PUSH1 0x04 11F2 01 ADD 11F3 61 PUSH2 0x090c 11F6 90 SWAP1 11F7 61 PUSH2 0x2013 11FA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @11EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11F6 stack[0] = 0x090c // @11F6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2013, returns to 0x090C label_11FB: // Incoming jump from 0x11E3, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @11FF storage[0x0d] // @120E stack[-1] // } 11FB 5B JUMPDEST 11FC 60 PUSH1 0x0d 11FE 80 DUP1 11FF 54 SLOAD 1200 60 PUSH1 0xff 1202 19 NOT 1203 81 DUP2 1204 16 AND 1205 60 PUSH1 0xff 1207 90 SWAP1 1208 91 SWAP2 1209 16 AND 120A 15 ISZERO 120B 17 OR 120C 90 SWAP1 120D 55 SSTORE 120E 56 *JUMP // Stack delta = -1 // Outputs[1] { @120D storage[0x0d] = !(storage[0x0d] & 0xff) | (storage[0x0d] & ~0xff) } // Block ends with unconditional jump to stack[-1] label_120F: // Incoming jump from 0x0692 // Inputs[2] // { // @1212 storage[0x08] // @121C msg.sender // } 120F 5B JUMPDEST 1210 60 PUSH1 0x08 1212 54 SLOAD 1213 60 PUSH1 0x01 1215 60 PUSH1 0x01 1217 60 PUSH1 0xa0 1219 1B SHL 121A 03 SUB 121B 16 AND 121C 33 CALLER 121D 14 EQ 121E 61 PUSH2 0x1239 1221 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1239, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_1222: // Incoming jump from 0x1221, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @1224 memory[0x40:0x60] } 1222 60 PUSH1 0x40 1224 51 MLOAD 1225 62 PUSH3 0x461bcd 1229 60 PUSH1 0xe5 122B 1B SHL 122C 81 DUP2 122D 52 MSTORE 122E 60 PUSH1 0x04 1230 01 ADD 1231 61 PUSH2 0x090c 1234 90 SWAP1 1235 61 PUSH2 0x2013 1238 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @122D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1234 stack[0] = 0x090c // @1234 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2013, returns to 0x090C label_1239: // Incoming jump from 0x1221, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @1242 stack[-1] } 1239 5B JUMPDEST 123A 60 PUSH1 0x01 123C 60 PUSH1 0x01 123E 60 PUSH1 0xa0 1240 1B SHL 1241 03 SUB 1242 81 DUP2 1243 16 AND 1244 61 PUSH2 0x129e 1247 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x129e, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1248: // Incoming jump from 0x1247, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @124A memory[0x40:0x60] } 1248 60 PUSH1 0x40 124A 51 MLOAD 124B 62 PUSH3 0x461bcd 124F 60 PUSH1 0xe5 1251 1B SHL 1252 81 DUP2 1253 52 MSTORE 1254 60 PUSH1 0x20 1256 60 PUSH1 0x04 1258 82 DUP3 1259 01 ADD 125A 52 MSTORE 125B 60 PUSH1 0x26 125D 60 PUSH1 0x24 125F 82 DUP3 1260 01 ADD 1261 52 MSTORE 1262 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 1283 60 PUSH1 0x44 1285 82 DUP3 1286 01 ADD 1287 52 MSTORE 1288 65 PUSH6 0x646472657373 128F 60 PUSH1 0xd0 1291 1B SHL 1292 60 PUSH1 0x64 1294 82 DUP3 1295 01 ADD 1296 52 MSTORE 1297 60 PUSH1 0x84 1299 01 ADD 129A 61 PUSH2 0x090c 129D 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1253 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @125A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1261 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1287 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @1296 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @1299 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x090c label_129E: // Incoming jump from 0x1247, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @12A2 stack[-1] } 129E 5B JUMPDEST 129F 61 PUSH2 0x0941 12A2 81 DUP2 12A3 61 PUSH2 0x16f5 12A6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @129F stack[0] = 0x0941 // @12A2 stack[1] = stack[-1] // } // Block ends with call to 0x16f5, returns to 0x0941 label_12A7: // Incoming call from 0x109A, returns to 0x109B // Incoming call from 0x0781, returns to 0x0782 // Inputs[1] { @12AA stack[-1] } 12A7 5B JUMPDEST 12A8 60 PUSH1 0x00 12AA 81 DUP2 12AB 60 PUSH1 0x01 12AD 11 GT 12AE 15 ISZERO 12AF 80 DUP1 12B0 15 ISZERO 12B1 61 PUSH2 0x12bb 12B4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @12A8 stack[0] = 0x00 // @12AE stack[1] = !(0x01 > stack[-1]) // } // Block ends with conditional jump to 0x12bb, if !!(0x01 > stack[-1]) label_12B5: // Incoming jump from 0x12B4, if not !!(0x01 > stack[-1]) // Inputs[2] // { // @12B8 storage[0x00] // @12B9 stack[-3] // } 12B5 50 POP 12B6 60 PUSH1 0x00 12B8 54 SLOAD 12B9 82 DUP3 12BA 10 LT 12BB 5B JUMPDEST 12BC 80 DUP1 12BD 15 ISZERO 12BE 61 PUSH2 0x06df 12C1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @12BA stack[-1] = stack[-3] < storage[0x00] } // Block ends with conditional jump to 0x06df, if !(stack[-3] < storage[0x00]) label_12C2: // Incoming jump from 0x12C1, if not !(stack[-3] < storage[0x00]) // Incoming jump from 0x12C1, if not !stack[-1] // Inputs[4] // { // @12C6 stack[-3] // @12D1 memory[0x00:0x40] // @12D2 storage[keccak256(memory[0x00:0x40])] // @12DE stack[-4] // } 12C2 50 POP 12C3 50 POP 12C4 60 PUSH1 0x00 12C6 90 SWAP1 12C7 81 DUP2 12C8 52 MSTORE 12C9 60 PUSH1 0x04 12CB 60 PUSH1 0x20 12CD 52 MSTORE 12CE 60 PUSH1 0x40 12D0 90 SWAP1 12D1 20 SHA3 12D2 54 SLOAD 12D3 60 PUSH1 0x01 12D5 60 PUSH1 0xe0 12D7 1B SHL 12D8 90 SWAP1 12D9 04 DIV 12DA 60 PUSH1 0xff 12DC 16 AND 12DD 15 ISZERO 12DE 90 SWAP1 12DF 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @12C8 memory[0x00:0x20] = stack[-3] // @12CD memory[0x20:0x40] = 0x04 // @12DE stack[-4] = !(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with unconditional jump to stack[-4] label_12E0: // Incoming call from 0x1409, returns to 0x140A // Incoming call from 0x0843, returns to 0x0844 // Inputs[8] // { // @12E3 stack[-2] // @12EF memory[0x00:0x40] // @12F1 storage[keccak256(memory[0x00:0x40])] // @1304 stack[-3] // @130E memory[0x40:0x60] // @1312 stack[-1] // @1337 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @133B stack[-4] // } 12E0 5B JUMPDEST 12E1 60 PUSH1 0x00 12E3 82 DUP3 12E4 81 DUP2 12E5 52 MSTORE 12E6 60 PUSH1 0x06 12E8 60 PUSH1 0x20 12EA 52 MSTORE 12EB 60 PUSH1 0x40 12ED 80 DUP1 12EE 82 DUP3 12EF 20 SHA3 12F0 80 DUP1 12F1 54 SLOAD 12F2 60 PUSH1 0x01 12F4 60 PUSH1 0x01 12F6 60 PUSH1 0xa0 12F8 1B SHL 12F9 03 SUB 12FA 19 NOT 12FB 16 AND 12FC 60 PUSH1 0x01 12FE 60 PUSH1 0x01 1300 60 PUSH1 0xa0 1302 1B SHL 1303 03 SUB 1304 87 DUP8 1305 81 DUP2 1306 16 AND 1307 91 SWAP2 1308 82 DUP3 1309 17 OR 130A 90 SWAP1 130B 92 SWAP3 130C 55 SSTORE 130D 91 SWAP2 130E 51 MLOAD 130F 85 DUP6 1310 93 SWAP4 1311 91 SWAP2 1312 85 DUP6 1313 16 AND 1314 91 SWAP2 1315 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1336 91 SWAP2 1337 A4 LOG4 1338 50 POP 1339 50 POP 133A 50 POP 133B 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @12E5 memory[0x00:0x20] = stack[-2] // @12EA memory[0x20:0x40] = 0x06 // @130C storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1337 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_133C: // Incoming jump from 0x08E1 // Incoming jump from 0x104F // Inputs[1] { @1342 stack[-1] } 133C 5B JUMPDEST 133D 60 PUSH1 0x00 133F 61 PUSH2 0x1347 1342 82 DUP3 1343 61 PUSH2 0x152c 1346 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @133D stack[0] = 0x00 // @133F stack[1] = 0x1347 // @1342 stack[2] = stack[-1] // } // Block ends with call to 0x152c, returns to 0x1347 label_1347: // Incoming return from call to 0x152C at 0x1346 // Inputs[4] // { // @1348 stack[-1] // @1348 stack[-2] // @134A stack[-5] // @1358 memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } 1347 5B JUMPDEST 1348 90 SWAP1 1349 50 POP 134A 83 DUP4 134B 60 PUSH1 0x01 134D 60 PUSH1 0x01 134F 60 PUSH1 0xa0 1351 1B SHL 1352 03 SUB 1353 16 AND 1354 81 DUP2 1355 60 PUSH1 0x00 1357 01 ADD 1358 51 MLOAD 1359 60 PUSH1 0x01 135B 60 PUSH1 0x01 135D 60 PUSH1 0xa0 135F 1B SHL 1360 03 SUB 1361 16 AND 1362 14 EQ 1363 61 PUSH2 0x137e 1366 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1348 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x137e, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] label_1367: // Incoming jump from 0x1366, if not (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @1369 memory[0x40:0x60] // @1378 memory[0x40:0x60] // @137D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1367 60 PUSH1 0x40 1369 51 MLOAD 136A 62 PUSH3 0xa11481 136E 60 PUSH1 0xe8 1370 1B SHL 1371 81 DUP2 1372 52 MSTORE 1373 60 PUSH1 0x04 1375 01 ADD 1376 60 PUSH1 0x40 1378 51 MLOAD 1379 80 DUP1 137A 91 SWAP2 137B 03 SUB 137C 90 SWAP1 137D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1372 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa11481 << 0xe8 // @137D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_137E: // Incoming jump from 0x1366, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[2] // { // @1381 msg.sender // @138A stack[-4] // } 137E 5B JUMPDEST 137F 60 PUSH1 0x00 1381 33 CALLER 1382 60 PUSH1 0x01 1384 60 PUSH1 0x01 1386 60 PUSH1 0xa0 1388 1B SHL 1389 03 SUB 138A 86 DUP7 138B 16 AND 138C 14 EQ 138D 80 DUP1 138E 61 PUSH2 0x139c 1391 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @137F stack[0] = 0x00 // @138C stack[1] = stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // } // Block ends with conditional jump to 0x139c, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender label_1392: // Incoming jump from 0x1391, if not stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @1396 stack[-6] // @1397 msg.sender // } 1392 50 POP 1393 61 PUSH2 0x139c 1396 85 DUP6 1397 33 CALLER 1398 61 PUSH2 0x0645 139B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1393 stack[-1] = 0x139c // @1396 stack[0] = stack[-6] // @1397 stack[1] = msg.sender // } // Block ends with call to 0x0645, returns to 0x139C label_139C: // Incoming jump from 0x1391, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming return from call to 0x0645 at 0x139B // Inputs[1] { @139D stack[-1] } 139C 5B JUMPDEST 139D 80 DUP1 139E 61 PUSH2 0x13b7 13A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13b7, if stack[-1] label_13A2: // Incoming jump from 0x13A1, if not stack[-1] // Inputs[2] // { // @13A3 msg.sender // @13A7 stack[-4] // } 13A2 50 POP 13A3 33 CALLER 13A4 61 PUSH2 0x13ac 13A7 84 DUP5 13A8 61 PUSH2 0x0777 13AB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @13A3 stack[-1] = msg.sender // @13A4 stack[0] = 0x13ac // @13A7 stack[1] = stack[-4] // } // Block ends with call to 0x0777, returns to 0x13AC label_13AC: // Incoming return from call to 0x0777 at 0x13AB // Inputs[2] // { // @13B5 stack[-1] // @13B6 stack[-2] // } 13AC 5B JUMPDEST 13AD 60 PUSH1 0x01 13AF 60 PUSH1 0x01 13B1 60 PUSH1 0xa0 13B3 1B SHL 13B4 03 SUB 13B5 16 AND 13B6 14 EQ // Stack delta = -1 // Outputs[1] { @13B6 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_13B7: // Incoming jump from 0x13A1, if stack[-1] // Incoming jump from 0x13B6 // Inputs[2] // { // @13B8 stack[-1] // @13B8 stack[-2] // } 13B7 5B JUMPDEST 13B8 90 SWAP1 13B9 50 POP 13BA 80 DUP1 13BB 61 PUSH2 0x13d7 13BE 57 *JUMPI // Stack delta = -1 // Outputs[1] { @13B8 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x13d7, if stack[-1] label_13BF: // Incoming jump from 0x13BE, if not stack[-1] // Inputs[3] // { // @13C1 memory[0x40:0x60] // @13D1 memory[0x40:0x60] // @13D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 13BF 60 PUSH1 0x40 13C1 51 MLOAD 13C2 63 PUSH4 0x2ce44b5f 13C7 60 PUSH1 0xe1 13C9 1B SHL 13CA 81 DUP2 13CB 52 MSTORE 13CC 60 PUSH1 0x04 13CE 01 ADD 13CF 60 PUSH1 0x40 13D1 51 MLOAD 13D2 80 DUP1 13D3 91 SWAP2 13D4 03 SUB 13D5 90 SWAP1 13D6 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @13CB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @13D6 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_13D7: // Incoming jump from 0x13BE, if stack[-1] // Inputs[1] { @13E0 stack[-4] } 13D7 5B JUMPDEST 13D8 60 PUSH1 0x01 13DA 60 PUSH1 0x01 13DC 60 PUSH1 0xa0 13DE 1B SHL 13DF 03 SUB 13E0 84 DUP5 13E1 16 AND 13E2 61 PUSH2 0x13fe 13E5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13fe, if stack[-4] & (0x01 << 0xa0) - 0x01 label_13E6: // Incoming jump from 0x13E5, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @13E8 memory[0x40:0x60] // @13F8 memory[0x40:0x60] // @13FD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 13E6 60 PUSH1 0x40 13E8 51 MLOAD 13E9 63 PUSH4 0x3a954ecd 13EE 60 PUSH1 0xe2 13F0 1B SHL 13F1 81 DUP2 13F2 52 MSTORE 13F3 60 PUSH1 0x04 13F5 01 ADD 13F6 60 PUSH1 0x40 13F8 51 MLOAD 13F9 80 DUP1 13FA 91 SWAP2 13FB 03 SUB 13FC 90 SWAP1 13FD FD *REVERT // Stack delta = +0 // Outputs[2] // { // @13F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3a954ecd << 0xe2 // @13FD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_13FE: // Incoming jump from 0x13E5, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1404 stack[-3] // @1405 stack[-5] // } 13FE 5B JUMPDEST 13FF 61 PUSH2 0x140a 1402 60 PUSH1 0x00 1404 84 DUP5 1405 87 DUP8 1406 61 PUSH2 0x12e0 1409 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @13FF stack[0] = 0x140a // @1402 stack[1] = 0x00 // @1404 stack[2] = stack[-3] // @1405 stack[3] = stack[-5] // } // Block ends with call to 0x12e0, returns to 0x140A label_140A: // Incoming return from call to 0x12E0 at 0x1409 // Inputs[12] // { // @1413 stack[-5] // @1426 memory[0x00:0x40] // @1428 storage[keccak256(memory[0x00:0x40])] // @144C stack[-4] // @1454 memory[0x00:0x40] // @1456 storage[keccak256(memory[0x00:0x40])] // @146A stack[-3] // @1474 memory[0x00:0x40] // @1476 storage[keccak256(memory[0x00:0x40])] // @1489 block.timestamp // @149A memory[0x00:0x40] // @149C storage[keccak256(memory[0x00:0x40])] // } 140A 5B JUMPDEST 140B 60 PUSH1 0x01 140D 60 PUSH1 0x01 140F 60 PUSH1 0xa0 1411 1B SHL 1412 03 SUB 1413 85 DUP6 1414 81 DUP2 1415 16 AND 1416 60 PUSH1 0x00 1418 90 SWAP1 1419 81 DUP2 141A 52 MSTORE 141B 60 PUSH1 0x05 141D 60 PUSH1 0x20 141F 90 SWAP1 1420 81 DUP2 1421 52 MSTORE 1422 60 PUSH1 0x40 1424 80 DUP1 1425 83 DUP4 1426 20 SHA3 1427 80 DUP1 1428 54 SLOAD 1429 67 PUSH8 0xffffffffffffffff 1432 19 NOT 1433 80 DUP1 1434 82 DUP3 1435 16 AND 1436 67 PUSH8 0xffffffffffffffff 143F 92 SWAP3 1440 83 DUP4 1441 16 AND 1442 60 PUSH1 0x00 1444 19 NOT 1445 01 ADD 1446 83 DUP4 1447 16 AND 1448 17 OR 1449 90 SWAP1 144A 92 SWAP3 144B 55 SSTORE 144C 89 DUP10 144D 86 DUP7 144E 16 AND 144F 80 DUP1 1450 86 DUP7 1451 52 MSTORE 1452 83 DUP4 1453 86 DUP7 1454 20 SHA3 1455 80 DUP1 1456 54 SLOAD 1457 93 SWAP4 1458 84 DUP5 1459 16 AND 145A 93 SWAP4 145B 83 DUP4 145C 16 AND 145D 60 PUSH1 0x01 145F 90 SWAP1 1460 81 DUP2 1461 01 ADD 1462 84 DUP5 1463 16 AND 1464 94 SWAP5 1465 90 SWAP1 1466 94 SWAP5 1467 17 OR 1468 90 SWAP1 1469 55 SSTORE 146A 89 DUP10 146B 86 DUP7 146C 52 MSTORE 146D 60 PUSH1 0x04 146F 90 SWAP1 1470 94 SWAP5 1471 52 MSTORE 1472 82 DUP3 1473 85 DUP6 1474 20 SHA3 1475 80 DUP1 1476 54 SLOAD 1477 60 PUSH1 0x01 1479 60 PUSH1 0x01 147B 60 PUSH1 0xe0 147D 1B SHL 147E 03 SUB 147F 19 NOT 1480 16 AND 1481 90 SWAP1 1482 94 SWAP5 1483 17 OR 1484 60 PUSH1 0x01 1486 60 PUSH1 0xa0 1488 1B SHL 1489 42 TIMESTAMP 148A 90 SWAP1 148B 92 SWAP3 148C 16 AND 148D 91 SWAP2 148E 90 SWAP1 148F 91 SWAP2 1490 02 MUL 1491 17 OR 1492 83 DUP4 1493 55 SSTORE 1494 87 DUP8 1495 01 ADD 1496 80 DUP1 1497 84 DUP5 1498 52 MSTORE 1499 92 SWAP3 149A 20 SHA3 149B 80 DUP1 149C 54 SLOAD 149D 91 SWAP2 149E 93 SWAP4 149F 90 SWAP1 14A0 91 SWAP2 14A1 16 AND 14A2 61 PUSH2 0x14e0 14A5 57 *JUMPI // Stack delta = +3 // Outputs[12] // { // @141A memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1421 memory[0x20:0x40] = 0x05 // @144B storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & ~0x00 + (0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @1451 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @1469 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & 0x01 + (0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @146C memory[0x00:0x20] = stack[-3] // @1471 memory[0x20:0x40] = 0x04 // @1493 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | ((0x01 << 0xa0) - 0x01 & stack[-4]) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1498 memory[0x00:0x20] = stack[-3] + 0x01 // @1499 stack[1] = stack[-3] + 0x01 // @149E stack[0] = keccak256(memory[0x00:0x40]) // @14A0 stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x14e0, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_14A6: // Incoming jump from 0x14A5, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @14A8 storage[0x00] // @14A9 stack[-2] // } 14A6 60 PUSH1 0x00 14A8 54 SLOAD 14A9 82 DUP3 14AA 14 EQ 14AB 61 PUSH2 0x14e0 14AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14e0, if stack[-2] == storage[0x00] label_14AF: // Incoming jump from 0x14AE, if not stack[-2] == storage[0x00] // Inputs[5] // { // @14AF stack[-1] // @14B0 storage[stack[-1]] // @14B3 stack[-5] // @14B5 memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @14DA stack[-8] // } 14AF 80 DUP1 14B0 54 SLOAD 14B1 60 PUSH1 0x20 14B3 86 DUP7 14B4 01 ADD 14B5 51 MLOAD 14B6 67 PUSH8 0xffffffffffffffff 14BF 16 AND 14C0 60 PUSH1 0x01 14C2 60 PUSH1 0xa0 14C4 1B SHL 14C5 02 MUL 14C6 60 PUSH1 0x01 14C8 60 PUSH1 0x01 14CA 60 PUSH1 0xe0 14CC 1B SHL 14CD 03 SUB 14CE 19 NOT 14CF 90 SWAP1 14D0 91 SWAP2 14D1 16 AND 14D2 60 PUSH1 0x01 14D4 60 PUSH1 0x01 14D6 60 PUSH1 0xa0 14D8 1B SHL 14D9 03 SUB 14DA 8A DUP11 14DB 16 AND 14DC 17 OR 14DD 17 OR 14DE 81 DUP2 14DF 55 SSTORE // Stack delta = +0 // Outputs[1] { @14DF storage[stack[-1]] = (stack[-8] & (0x01 << 0xa0) - 0x01) | (storage[stack[-1]] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * (0xffffffffffffffff & memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20]) } // Block continues label_14E0: // Incoming jump from 0x14DF // Incoming jump from 0x14AE, if stack[-2] == storage[0x00] // Incoming jump from 0x14A5, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @14E4 stack[-6] // @14E5 stack[-7] // @14EF stack[-8] // @151C memory[0x40:0x60] // @151F memory[0x40:0x60] // @1524 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 14E0 5B JUMPDEST 14E1 50 POP 14E2 50 POP 14E3 50 POP 14E4 82 DUP3 14E5 84 DUP5 14E6 60 PUSH1 0x01 14E8 60 PUSH1 0x01 14EA 60 PUSH1 0xa0 14EC 1B SHL 14ED 03 SUB 14EE 16 AND 14EF 86 DUP7 14F0 60 PUSH1 0x01 14F2 60 PUSH1 0x01 14F4 60 PUSH1 0xa0 14F6 1B SHL 14F7 03 SUB 14F8 16 AND 14F9 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 151A 60 PUSH1 0x40 151C 51 MLOAD 151D 60 PUSH1 0x40 151F 51 MLOAD 1520 80 DUP1 1521 91 SWAP2 1522 03 SUB 1523 90 SWAP1 1524 A4 LOG4 // Stack delta = -3 // Outputs[1] { @1524 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-8] & (0x01 << 0xa0) - 0x01, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-6]]); } // Block continues label_1525: // Incoming jump from 0x1BA4 // Incoming jump from 0x1524 // Inputs[1] { @152B stack[-6] } 1525 5B JUMPDEST 1526 50 POP 1527 50 POP 1528 50 POP 1529 50 POP 152A 50 POP 152B 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_152C: // Incoming call from 0x1346, returns to 0x1347 // Incoming call from 0x09F9, returns to 0x09FA // Inputs[2] // { // @1530 memory[0x40:0x60] // @154A stack[-1] // } 152C 5B JUMPDEST 152D 60 PUSH1 0x40 152F 80 DUP1 1530 51 MLOAD 1531 60 PUSH1 0x60 1533 81 DUP2 1534 01 ADD 1535 82 DUP3 1536 52 MSTORE 1537 60 PUSH1 0x00 1539 80 DUP1 153A 82 DUP3 153B 52 MSTORE 153C 60 PUSH1 0x20 153E 82 DUP3 153F 01 ADD 1540 81 DUP2 1541 90 SWAP1 1542 52 MSTORE 1543 91 SWAP2 1544 81 DUP2 1545 01 ADD 1546 91 SWAP2 1547 90 SWAP1 1548 91 SWAP2 1549 52 MSTORE 154A 81 DUP2 154B 80 DUP1 154C 60 PUSH1 0x01 154E 11 GT 154F 15 ISZERO 1550 80 DUP1 1551 15 ISZERO 1552 61 PUSH2 0x155c 1555 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @1536 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @153B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1542 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @1548 stack[0] = memory[0x40:0x60] // @1549 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @154A stack[1] = stack[-1] // @154F stack[2] = !(0x01 > stack[-1]) // } // Block ends with conditional jump to 0x155c, if !!(0x01 > stack[-1]) label_1556: // Incoming jump from 0x1555, if not !!(0x01 > stack[-1]) // Inputs[2] // { // @1559 storage[0x00] // @155A stack[-2] // } 1556 50 POP 1557 60 PUSH1 0x00 1559 54 SLOAD 155A 81 DUP2 155B 10 LT 155C 5B JUMPDEST 155D 15 ISZERO 155E 61 PUSH2 0x163c 1561 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x163c, if !(stack[-2] < storage[0x00]) label_1562: // Incoming jump from 0x1561, if not !(stack[-2] < storage[0x00]) // Incoming jump from 0x1561, if not !stack[-1] // Inputs[4] // { // @1564 stack[-1] // @1573 memory[0x00:0x40] // @1575 memory[0x40:0x60] // @157D storage[keccak256(memory[0x00:0x40])] // } 1562 60 PUSH1 0x00 1564 81 DUP2 1565 81 DUP2 1566 52 MSTORE 1567 60 PUSH1 0x04 1569 60 PUSH1 0x20 156B 90 SWAP1 156C 81 DUP2 156D 52 MSTORE 156E 60 PUSH1 0x40 1570 91 SWAP2 1571 82 DUP3 1572 90 SWAP1 1573 20 SHA3 1574 82 DUP3 1575 51 MLOAD 1576 60 PUSH1 0x60 1578 81 DUP2 1579 01 ADD 157A 84 DUP5 157B 52 MSTORE 157C 90 SWAP1 157D 54 SLOAD 157E 60 PUSH1 0x01 1580 60 PUSH1 0x01 1582 60 PUSH1 0xa0 1584 1B SHL 1585 03 SUB 1586 81 DUP2 1587 16 AND 1588 82 DUP3 1589 52 MSTORE 158A 60 PUSH1 0x01 158C 60 PUSH1 0xa0 158E 1B SHL 158F 81 DUP2 1590 04 DIV 1591 67 PUSH8 0xffffffffffffffff 159A 16 AND 159B 92 SWAP3 159C 82 DUP3 159D 01 ADD 159E 92 SWAP3 159F 90 SWAP1 15A0 92 SWAP3 15A1 52 MSTORE 15A2 60 PUSH1 0x01 15A4 60 PUSH1 0xe0 15A6 1B SHL 15A7 90 SWAP1 15A8 91 SWAP2 15A9 04 DIV 15AA 60 PUSH1 0xff 15AC 16 AND 15AD 15 ISZERO 15AE 15 ISZERO 15AF 91 SWAP2 15B0 81 DUP2 15B1 01 ADD 15B2 82 DUP3 15B3 90 SWAP1 15B4 52 MSTORE 15B5 90 SWAP1 15B6 61 PUSH2 0x163a 15B9 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @1566 memory[0x00:0x20] = stack[-1] // @156D memory[0x20:0x40] = 0x04 // @157B memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1589 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @15A1 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @15B4 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // @15B5 stack[0] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x163a, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) label_15BA: // Incoming jump from 0x15B9, if not !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // Inputs[2] // { // @15BA stack[-1] // @15BB memory[stack[-1]:stack[-1] + 0x20] // } 15BA 80 DUP1 15BB 51 MLOAD 15BC 60 PUSH1 0x01 15BE 60 PUSH1 0x01 15C0 60 PUSH1 0xa0 15C2 1B SHL 15C3 03 SUB 15C4 16 AND 15C5 15 ISZERO 15C6 61 PUSH2 0x15d0 15C9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15d0, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) label_15CA: // Incoming jump from 0x15C9, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @15CA stack[-1] // @15CA stack[-5] // @15CB stack[-4] // } 15CA 93 SWAP4 15CB 92 SWAP3 15CC 50 POP 15CD 50 POP 15CE 50 POP 15CF 56 *JUMP // Stack delta = -4 // Outputs[1] { @15CA stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_15D0: // Incoming jump from 0x15C9, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1639 // Inputs[4] // { // @15D5 stack[-2] // @15E7 memory[0x00:0x40] // @15E9 memory[0x40:0x60] // @15F1 storage[keccak256(memory[0x00:0x40])] // } 15D0 5B JUMPDEST 15D1 50 POP 15D2 60 PUSH1 0x00 15D4 19 NOT 15D5 01 ADD 15D6 60 PUSH1 0x00 15D8 81 DUP2 15D9 81 DUP2 15DA 52 MSTORE 15DB 60 PUSH1 0x04 15DD 60 PUSH1 0x20 15DF 90 SWAP1 15E0 81 DUP2 15E1 52 MSTORE 15E2 60 PUSH1 0x40 15E4 91 SWAP2 15E5 82 DUP3 15E6 90 SWAP1 15E7 20 SHA3 15E8 82 DUP3 15E9 51 MLOAD 15EA 60 PUSH1 0x60 15EC 81 DUP2 15ED 01 ADD 15EE 84 DUP5 15EF 52 MSTORE 15F0 90 SWAP1 15F1 54 SLOAD 15F2 60 PUSH1 0x01 15F4 60 PUSH1 0x01 15F6 60 PUSH1 0xa0 15F8 1B SHL 15F9 03 SUB 15FA 81 DUP2 15FB 16 AND 15FC 80 DUP1 15FD 83 DUP4 15FE 52 MSTORE 15FF 60 PUSH1 0x01 1601 60 PUSH1 0xa0 1603 1B SHL 1604 82 DUP3 1605 04 DIV 1606 67 PUSH8 0xffffffffffffffff 160F 16 AND 1610 93 SWAP4 1611 83 DUP4 1612 01 ADD 1613 93 SWAP4 1614 90 SWAP1 1615 93 SWAP4 1616 52 MSTORE 1617 60 PUSH1 0x01 1619 60 PUSH1 0xe0 161B 1B SHL 161C 90 SWAP1 161D 04 DIV 161E 60 PUSH1 0xff 1620 16 AND 1621 15 ISZERO 1622 15 ISZERO 1623 92 SWAP3 1624 81 DUP2 1625 01 ADD 1626 92 SWAP3 1627 90 SWAP1 1628 92 SWAP3 1629 52 MSTORE 162A 15 ISZERO 162B 61 PUSH2 0x1635 162E 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @15D5 stack[-2] = ~0x00 + stack[-2] // @15DA memory[0x00:0x20] = ~0x00 + stack[-2] // @15E1 memory[0x20:0x40] = 0x04 // @15EF memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @15FE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @1616 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @1628 stack[-1] = memory[0x40:0x60] // @1629 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with conditional jump to 0x1635, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_162F: // Incoming jump from 0x162E, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @162F stack[-5] // @162F stack[-1] // @1630 stack[-4] // } 162F 93 SWAP4 1630 92 SWAP3 1631 50 POP 1632 50 POP 1633 50 POP 1634 56 *JUMP // Stack delta = -4 // Outputs[1] { @162F stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1635: // Incoming jump from 0x162E, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) 1635 5B JUMPDEST 1636 61 PUSH2 0x15d0 1639 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x15d0 label_163A: // Incoming jump from 0x15B9, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) 163A 5B JUMPDEST 163B 50 POP // Stack delta = -1 // Block continues label_163C: // Incoming jump from 0x1561, if !(stack[-2] < storage[0x00]) // Incoming jump from 0x1561, if !stack[-1] // Incoming jump from 0x163B // Inputs[3] // { // @163F memory[0x40:0x60] // @164F memory[0x40:0x60] // @1654 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 163C 5B JUMPDEST 163D 60 PUSH1 0x40 163F 51 MLOAD 1640 63 PUSH4 0x6f96cda1 1645 60 PUSH1 0xe1 1647 1B SHL 1648 81 DUP2 1649 52 MSTORE 164A 60 PUSH1 0x04 164C 01 ADD 164D 60 PUSH1 0x40 164F 51 MLOAD 1650 80 DUP1 1651 91 SWAP2 1652 03 SUB 1653 90 SWAP1 1654 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1649 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @1654 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1655: // Incoming call from 0x0B75, returns to 0x0B76 // Inputs[10] // { // @1658 memory[0x40:0x60] // @1669 stack[-1] // @167C memory[0x40:0x60] // @168A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @168F memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @1695 stack[-3] // @1696 stack[-2] // @16A1 memory[0x40:0x60] // @16BB msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @16C8 storage[0x09] // } 1655 5B JUMPDEST 1656 60 PUSH1 0x40 1658 51 MLOAD 1659 6B PUSH12 0xffffffffffffffffffffffff 1666 19 NOT 1667 60 PUSH1 0x60 1669 83 DUP4 166A 90 SWAP1 166B 1B SHL 166C 16 AND 166D 60 PUSH1 0x20 166F 82 DUP3 1670 01 ADD 1671 52 MSTORE 1672 60 PUSH1 0x00 1674 90 SWAP1 1675 81 DUP2 1676 90 SWAP1 1677 60 PUSH1 0x34 1679 01 ADD 167A 60 PUSH1 0x40 167C 51 MLOAD 167D 60 PUSH1 0x20 167F 81 DUP2 1680 83 DUP4 1681 03 SUB 1682 03 SUB 1683 81 DUP2 1684 52 MSTORE 1685 90 SWAP1 1686 60 PUSH1 0x40 1688 52 MSTORE 1689 80 DUP1 168A 51 MLOAD 168B 90 SWAP1 168C 60 PUSH1 0x20 168E 01 ADD 168F 20 SHA3 1690 90 SWAP1 1691 50 POP 1692 61 PUSH2 0x16d2 1695 85 DUP6 1696 85 DUP6 1697 80 DUP1 1698 80 DUP1 1699 60 PUSH1 0x20 169B 02 MUL 169C 60 PUSH1 0x20 169E 01 ADD 169F 60 PUSH1 0x40 16A1 51 MLOAD 16A2 90 SWAP1 16A3 81 DUP2 16A4 01 ADD 16A5 60 PUSH1 0x40 16A7 52 MSTORE 16A8 80 DUP1 16A9 93 SWAP4 16AA 92 SWAP3 16AB 91 SWAP2 16AC 90 SWAP1 16AD 81 DUP2 16AE 81 DUP2 16AF 52 MSTORE 16B0 60 PUSH1 0x20 16B2 01 ADD 16B3 83 DUP4 16B4 83 DUP4 16B5 60 PUSH1 0x20 16B7 02 MUL 16B8 80 DUP1 16B9 82 DUP3 16BA 84 DUP5 16BB 37 CALLDATACOPY 16BC 60 PUSH1 0x00 16BE 92 SWAP3 16BF 01 ADD 16C0 91 SWAP2 16C1 90 SWAP1 16C2 91 SWAP2 16C3 52 MSTORE 16C4 50 POP 16C5 50 POP 16C6 60 PUSH1 0x09 16C8 54 SLOAD 16C9 91 SWAP2 16CA 50 POP 16CB 84 DUP5 16CC 90 SWAP1 16CD 50 POP 16CE 61 PUSH2 0x193d 16D1 56 *JUMP // Stack delta = +6 // Outputs[13] // { // @1671 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (stack[-1] << 0x60) & ~0xffffffffffffffffffffffff // @1674 stack[0] = 0x00 // @1684 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x34 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @1688 memory[0x40:0x60] = 0x34 + memory[0x40:0x60] // @1690 stack[1] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @1692 stack[2] = 0x16d2 // @16A7 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @16A9 stack[3] = memory[0x40:0x60] // @16AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @16BB memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @16C3 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @16C9 stack[4] = storage[0x09] // @16CC stack[5] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with call to 0x193d, returns to 0x16D2 label_16D2: // Incoming return from call to 0x193D at 0x16D1 // Inputs[3] // { // @16D3 stack[-1] // @16D3 stack[-7] // @16D4 stack[-6] // } 16D2 5B JUMPDEST 16D3 95 SWAP6 16D4 94 SWAP5 16D5 50 POP 16D6 50 POP 16D7 50 POP 16D8 50 POP 16D9 50 POP 16DA 56 *JUMP // Stack delta = -6 // Outputs[1] { @16D3 stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] label_16DB: // Incoming call from 0x0D4B, returns to 0x099C // Incoming call from 0x0FAE, returns to 0x0941 // Incoming call from 0x0C45, returns to 0x0C46 // Inputs[3] // { // @16DF stack[-2] // @16E0 stack[-1] // @16E3 memory[0x40:0x60] // } 16DB 5B JUMPDEST 16DC 61 PUSH2 0x099c 16DF 82 DUP3 16E0 82 DUP3 16E1 60 PUSH1 0x40 16E3 51 MLOAD 16E4 80 DUP1 16E5 60 PUSH1 0x20 16E7 01 ADD 16E8 60 PUSH1 0x40 16EA 52 MSTORE 16EB 80 DUP1 16EC 60 PUSH1 0x00 16EE 81 DUP2 16EF 52 MSTORE 16F0 50 POP 16F1 61 PUSH2 0x1953 16F4 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @16DC stack[0] = 0x099c // @16DF stack[1] = stack[-2] // @16E0 stack[2] = stack[-1] // @16E3 stack[3] = memory[0x40:0x60] // @16EA memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @16EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x1953, returns to 0x099C label_16F5: // Incoming call from 0x12A6, returns to 0x0941 // Incoming call from 0x0CCE, returns to 0x0CCF // Inputs[5] // { // @16F9 storage[0x08] // @1702 stack[-1] // @1717 memory[0x40:0x60] // @1743 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1746 stack[-2] // } 16F5 5B JUMPDEST 16F6 60 PUSH1 0x08 16F8 80 DUP1 16F9 54 SLOAD 16FA 60 PUSH1 0x01 16FC 60 PUSH1 0x01 16FE 60 PUSH1 0xa0 1700 1B SHL 1701 03 SUB 1702 83 DUP4 1703 81 DUP2 1704 16 AND 1705 60 PUSH1 0x01 1707 60 PUSH1 0x01 1709 60 PUSH1 0xa0 170B 1B SHL 170C 03 SUB 170D 19 NOT 170E 83 DUP4 170F 16 AND 1710 81 DUP2 1711 17 OR 1712 90 SWAP1 1713 93 SWAP4 1714 55 SSTORE 1715 60 PUSH1 0x40 1717 51 MLOAD 1718 91 SWAP2 1719 16 AND 171A 91 SWAP2 171B 90 SWAP1 171C 82 DUP3 171D 90 SWAP1 171E 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 173F 90 SWAP1 1740 60 PUSH1 0x00 1742 90 SWAP1 1743 A3 LOG3 1744 50 POP 1745 50 POP 1746 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1714 storage[0x08] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x08] & ~((0x01 << 0xa0) - 0x01)) // @1743 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x08] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_1747: // Incoming jump from 0x1B1D // Inputs[6] // { // @174A memory[0x40:0x60] // @1760 stack[-3] // @176D msg.sender // @176F stack[-4] // @1771 stack[-2] // @1773 stack[-1] // } 1747 5B JUMPDEST 1748 60 PUSH1 0x40 174A 51 MLOAD 174B 63 PUSH4 0x0a85bd01 1750 60 PUSH1 0xe1 1752 1B SHL 1753 81 DUP2 1754 52 MSTORE 1755 60 PUSH1 0x00 1757 90 SWAP1 1758 60 PUSH1 0x01 175A 60 PUSH1 0x01 175C 60 PUSH1 0xa0 175E 1B SHL 175F 03 SUB 1760 85 DUP6 1761 16 AND 1762 90 SWAP1 1763 63 PUSH4 0x150b7a02 1768 90 SWAP1 1769 61 PUSH2 0x177c 176C 90 SWAP1 176D 33 CALLER 176E 90 SWAP1 176F 89 DUP10 1770 90 SWAP1 1771 88 DUP9 1772 90 SWAP1 1773 88 DUP9 1774 90 SWAP1 1775 60 PUSH1 0x04 1777 01 ADD 1778 61 PUSH2 0x2179 177B 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @1754 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @1757 stack[0] = 0x00 // @1762 stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1768 stack[2] = 0x150b7a02 // @176C stack[3] = 0x177c // @176E stack[4] = msg.sender // @1770 stack[5] = stack[-4] // @1772 stack[6] = stack[-2] // @1774 stack[7] = stack[-1] // @1777 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2179, returns to 0x177C label_177C: // Incoming return from call to 0x2179 at 0x177B // Inputs[4] // { // @1781 memory[0x40:0x60] // @1783 stack[-1] // @1788 stack[-3] // @178A address(stack[-3]).code.length // } 177C 5B JUMPDEST 177D 60 PUSH1 0x20 177F 60 PUSH1 0x40 1781 51 MLOAD 1782 80 DUP1 1783 83 DUP4 1784 03 SUB 1785 81 DUP2 1786 60 PUSH1 0x00 1788 87 DUP8 1789 80 DUP1 178A 3B EXTCODESIZE 178B 15 ISZERO 178C 80 DUP1 178D 15 ISZERO 178E 61 PUSH2 0x1796 1791 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @177D stack[0] = 0x20 // @1781 stack[1] = memory[0x40:0x60] // @1784 stack[2] = stack[-1] - memory[0x40:0x60] // @1785 stack[3] = memory[0x40:0x60] // @1786 stack[4] = 0x00 // @1788 stack[5] = stack[-3] // @178B stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1796, if !!address(stack[-3]).code.length label_1792: // Incoming jump from 0x1791, if not !!address(stack[-3]).code.length // Inputs[1] { @1795 memory[0x00:0x00] } 1792 60 PUSH1 0x00 1794 80 DUP1 1795 FD *REVERT // Stack delta = +0 // Outputs[1] { @1795 revert(memory[0x00:0x00]); } // Block terminates label_1796: // Incoming jump from 0x1791, if !!address(stack[-3]).code.length // Inputs[10] // { // @1798 msg.gas // @1799 stack[-4] // @1799 stack[-5] // @1799 stack[-7] // @1799 stack[-6] // @1799 memory[stack[-4]:stack[-4] + stack[-5]] // @1799 stack[-3] // @1799 stack[-2] // @1799 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @179A stack[-10] // } 1796 5B JUMPDEST 1797 50 POP 1798 5A GAS 1799 F1 CALL 179A 92 SWAP3 179B 50 POP 179C 50 POP 179D 50 POP 179E 80 DUP1 179F 15 ISZERO 17A0 61 PUSH2 0x17c6 17A3 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @1799 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @179A stack[-10] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x17c6, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_17A4: // Incoming jump from 0x17A3, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @17A8 memory[0x40:0x60] // @17AB returndata.length // } 17A4 50 POP 17A5 60 PUSH1 0x40 17A7 80 DUP1 17A8 51 MLOAD 17A9 60 PUSH1 0x1f 17AB 3D RETURNDATASIZE 17AC 90 SWAP1 17AD 81 DUP2 17AE 01 ADD 17AF 60 PUSH1 0x1f 17B1 19 NOT 17B2 16 AND 17B3 82 DUP3 17B4 01 ADD 17B5 90 SWAP1 17B6 92 SWAP3 17B7 52 MSTORE 17B8 61 PUSH2 0x17c3 17BB 91 SWAP2 17BC 81 DUP2 17BD 01 ADD 17BE 90 SWAP1 17BF 61 PUSH2 0x21b6 17C2 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @17B7 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @17BB stack[-1] = 0x17c3 // @17BE stack[1] = memory[0x40:0x60] // @17BE stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x21b6 17C3 5B JUMPDEST 17C4 60 PUSH1 0x01 label_17C6: // Incoming jump from 0x17A3, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @17CA stack[-1] } 17C6 5B JUMPDEST 17C7 61 PUSH2 0x1821 17CA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1821, if stack[-1] label_17CB: // Incoming jump from 0x17CA, if not stack[-1] // Inputs[1] { @17CB returndata.length } 17CB 3D RETURNDATASIZE 17CC 80 DUP1 17CD 80 DUP1 17CE 15 ISZERO 17CF 61 PUSH2 0x17f4 17D2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @17CB stack[0] = returndata.length // @17CC stack[1] = returndata.length // } // Block ends with conditional jump to 0x17f4, if !returndata.length label_17D3: // Incoming jump from 0x17D2, if not !returndata.length // Inputs[6] // { // @17D5 memory[0x40:0x60] // @17D6 stack[-2] // @17DD returndata.length // @17E5 returndata.length // @17E8 returndata.length // @17EF returndata[0x00:0x00 + returndata.length] // } 17D3 60 PUSH1 0x40 17D5 51 MLOAD 17D6 91 SWAP2 17D7 50 POP 17D8 60 PUSH1 0x1f 17DA 19 NOT 17DB 60 PUSH1 0x3f 17DD 3D RETURNDATASIZE 17DE 01 ADD 17DF 16 AND 17E0 82 DUP3 17E1 01 ADD 17E2 60 PUSH1 0x40 17E4 52 MSTORE 17E5 3D RETURNDATASIZE 17E6 82 DUP3 17E7 52 MSTORE 17E8 3D RETURNDATASIZE 17E9 60 PUSH1 0x00 17EB 60 PUSH1 0x20 17ED 84 DUP5 17EE 01 ADD 17EF 3E RETURNDATACOPY 17F0 61 PUSH2 0x17f9 17F3 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @17D6 stack[-2] = memory[0x40:0x60] // @17E4 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @17E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @17EF memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x17f9 label_17F4: // Incoming jump from 0x17D2, if !returndata.length // Inputs[2] // { // @17F7 stack[-2] // @17FC memory[0x60:0x80] // } 17F4 5B JUMPDEST 17F5 60 PUSH1 0x60 17F7 91 SWAP2 17F8 50 POP 17F9 5B JUMPDEST 17FA 50 POP 17FB 80 DUP1 17FC 51 MLOAD 17FD 61 PUSH2 0x1819 1800 57 *JUMPI // Stack delta = -1 // Outputs[1] { @17F7 stack[-2] = 0x60 } // Block ends with conditional jump to 0x1819, if memory[0x60:0x80] label_1801: // Incoming jump from 0x1800, if not memory[0x60:0x80] // Incoming jump from 0x1800, if not memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @1803 memory[0x40:0x60] // @1813 memory[0x40:0x60] // @1818 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1801 60 PUSH1 0x40 1803 51 MLOAD 1804 63 PUSH4 0x68d2bf6b 1809 60 PUSH1 0xe1 180B 1B SHL 180C 81 DUP2 180D 52 MSTORE 180E 60 PUSH1 0x04 1810 01 ADD 1811 60 PUSH1 0x40 1813 51 MLOAD 1814 80 DUP1 1815 91 SWAP2 1816 03 SUB 1817 90 SWAP1 1818 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @180D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @1818 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1819: // Incoming jump from 0x1800, if memory[0x60:0x80] // Incoming jump from 0x1800, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @181A stack[-1] // @181B memory[stack[-1]:stack[-1] + 0x20] // @1820 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 1819 5B JUMPDEST 181A 80 DUP1 181B 51 MLOAD 181C 81 DUP2 181D 60 PUSH1 0x20 181F 01 ADD 1820 FD *REVERT // Stack delta = +0 // Outputs[1] { @1820 revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_1821: // Incoming jump from 0x17CA, if stack[-1] // Inputs[2] // { // @182B stack[-1] // @1835 stack[-2] // } 1821 5B JUMPDEST 1822 60 PUSH1 0x01 1824 60 PUSH1 0x01 1826 60 PUSH1 0xe0 1828 1B SHL 1829 03 SUB 182A 19 NOT 182B 16 AND 182C 63 PUSH4 0x0a85bd01 1831 60 PUSH1 0xe1 1833 1B SHL 1834 14 EQ 1835 90 SWAP1 1836 50 POP // Stack delta = -1 // Outputs[1] { @1835 stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block continues label_1837: // Incoming return from call to 0x1DAF at 0x1E6D // Incoming jump from 0x18DC, if !stack[-5] // Incoming jump from 0x18DC, if !stack[-7] // Incoming jump from 0x1836 // Incoming jump from 0x18DC, if !stack[-7] // Inputs[3] // { // @1838 stack[-6] // @1838 stack[-1] // @1839 stack[-5] // } 1837 5B JUMPDEST 1838 94 SWAP5 1839 93 SWAP4 183A 50 POP 183B 50 POP 183C 50 POP 183D 50 POP 183E 56 *JUMP // Stack delta = -5 // Outputs[1] { @1838 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_183F: // Incoming call from 0x1114, returns to 0x1115 // Inputs[1] { @1842 stack[-1] } 183F 5B JUMPDEST 1840 60 PUSH1 0x60 1842 81 DUP2 1843 61 PUSH2 0x1863 1846 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1840 stack[0] = 0x60 } // Block ends with conditional jump to 0x1863, if stack[-1] label_1847: // Incoming jump from 0x1846, if not stack[-1] // Inputs[2] // { // @184C memory[0x40:0x60] // @1861 stack[-3] // } 1847 50 POP 1848 50 POP 1849 60 PUSH1 0x40 184B 80 DUP1 184C 51 MLOAD 184D 80 DUP1 184E 82 DUP3 184F 01 ADD 1850 90 SWAP1 1851 91 SWAP2 1852 52 MSTORE 1853 60 PUSH1 0x01 1855 81 DUP2 1856 52 MSTORE 1857 60 PUSH1 0x03 1859 60 PUSH1 0xfc 185B 1B SHL 185C 60 PUSH1 0x20 185E 82 DUP3 185F 01 ADD 1860 52 MSTORE 1861 90 SWAP1 1862 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @1852 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1856 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @1860 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x03 << 0xfc // @1861 stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_1863: // Incoming jump from 0x1846, if stack[-1] // Inputs[1] { @1864 stack[-2] } 1863 5B JUMPDEST 1864 81 DUP2 1865 60 PUSH1 0x00 1867 5B JUMPDEST 1868 81 DUP2 1869 15 ISZERO 186A 61 PUSH2 0x188d 186D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1864 stack[0] = stack[-2] // @1865 stack[1] = 0x00 // } // Block ends with conditional jump to 0x188d, if !stack[-2] label_186E: // Incoming jump from 0x186D, if not !stack[-2] // Incoming jump from 0x186D, if not !stack[-2] // Inputs[1] { @186E stack[-1] } 186E 80 DUP1 186F 61 PUSH2 0x1877 1872 81 DUP2 1873 61 PUSH2 0x21d3 1876 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @186E stack[0] = stack[-1] // @186F stack[1] = 0x1877 // @1872 stack[2] = stack[-1] // } // Block ends with call to 0x21d3, returns to 0x1877 label_1877: // Incoming return from call to 0x21D3 at 0x1876 // Inputs[4] // { // @1878 stack[-1] // @1878 stack[-3] // @187D stack[-2] // @1881 stack[-4] // } 1877 5B JUMPDEST 1878 91 SWAP2 1879 50 POP 187A 61 PUSH2 0x1886 187D 90 SWAP1 187E 50 POP 187F 60 PUSH1 0x0a 1881 83 DUP4 1882 61 PUSH2 0x2204 1885 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1878 stack[-3] = stack[-1] // @187D stack[-2] = 0x1886 // @187F stack[-1] = 0x0a // @1881 stack[0] = stack[-4] // } // Block ends with call to 0x2204, returns to 0x1886 label_1886: // Incoming return from call to 0x2204 at 0x1885 // Inputs[2] // { // @1887 stack[-3] // @1887 stack[-1] // } 1886 5B JUMPDEST 1887 91 SWAP2 1888 50 POP 1889 61 PUSH2 0x1867 188C 56 *JUMP // Stack delta = -1 // Outputs[1] { @1887 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1867 label_188D: // Incoming jump from 0x186D, if !stack[-2] // Incoming jump from 0x186D, if !stack[-2] // Inputs[1] { @1890 stack[-1] } 188D 5B JUMPDEST 188E 60 PUSH1 0x00 1890 81 DUP2 1891 67 PUSH8 0xffffffffffffffff 189A 81 DUP2 189B 11 GT 189C 15 ISZERO 189D 61 PUSH2 0x18a8 18A0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @188E stack[0] = 0x00 // @1890 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x18a8, if !(stack[-1] > 0xffffffffffffffff) label_18A1: // Incoming jump from 0x18A0, if not !(stack[-1] > 0xffffffffffffffff) 18A1 61 PUSH2 0x18a8 18A4 61 PUSH2 0x1d99 18A7 56 *JUMP // Stack delta = +1 // Outputs[1] { @18A1 stack[0] = 0x18a8 } // Block ends with unconditional jump to 0x1d99 label_18A8: // Incoming jump from 0x18A0, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @18AB memory[0x40:0x60] // @18AC stack[-1] // } 18A8 5B JUMPDEST 18A9 60 PUSH1 0x40 18AB 51 MLOAD 18AC 90 SWAP1 18AD 80 DUP1 18AE 82 DUP3 18AF 52 MSTORE 18B0 80 DUP1 18B1 60 PUSH1 0x1f 18B3 01 ADD 18B4 60 PUSH1 0x1f 18B6 19 NOT 18B7 16 AND 18B8 60 PUSH1 0x20 18BA 01 ADD 18BB 82 DUP3 18BC 01 ADD 18BD 60 PUSH1 0x40 18BF 52 MSTORE 18C0 80 DUP1 18C1 15 ISZERO 18C2 61 PUSH2 0x18d2 18C5 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @18AC stack[-1] = memory[0x40:0x60] // @18AC stack[0] = stack[-1] // @18AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @18BF memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x18d2, if !stack[-1] label_18C6: // Incoming jump from 0x18C5, if not !stack[-1] // Inputs[6] // { // @18C8 stack[-2] // @18CA stack[-1] // @18CC msg.data.length // @18CE msg.data[msg.data.length:msg.data.length + stack[-1]] // @18D4 stack[-3] // @18D7 stack[-7] // } 18C6 60 PUSH1 0x20 18C8 82 DUP3 18C9 01 ADD 18CA 81 DUP2 18CB 80 DUP1 18CC 36 CALLDATASIZE 18CD 83 DUP4 18CE 37 CALLDATACOPY 18CF 01 ADD 18D0 90 SWAP1 18D1 50 POP 18D2 5B JUMPDEST 18D3 50 POP 18D4 90 SWAP1 18D5 50 POP 18D6 5B JUMPDEST 18D7 84 DUP5 18D8 15 ISZERO 18D9 61 PUSH2 0x1837 18DC 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @18CE memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @18D4 stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x1837, if !stack[-7] label_18DD: // Incoming jump from 0x18DC, if not !stack[-7] // Incoming jump from 0x18DC, if not !stack[-5] // Incoming jump from 0x18DC, if not !stack[-7] // Inputs[1] { @18E2 stack[-2] } 18DD 61 PUSH2 0x18e7 18E0 60 PUSH1 0x01 18E2 83 DUP4 18E3 61 PUSH2 0x2076 18E6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @18DD stack[0] = 0x18e7 // @18E0 stack[1] = 0x01 // @18E2 stack[2] = stack[-2] // } // Block ends with call to 0x2076, returns to 0x18E7 label_18E7: // Incoming return from call to 0x2076 at 0x18E6 // Inputs[3] // { // @18E8 stack[-3] // @18E8 stack[-1] // @18EF stack[-6] // } 18E7 5B JUMPDEST 18E8 91 SWAP2 18E9 50 POP 18EA 61 PUSH2 0x18f4 18ED 60 PUSH1 0x0a 18EF 86 DUP7 18F0 61 PUSH2 0x2218 18F3 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @18E8 stack[-3] = stack[-1] // @18EA stack[-1] = 0x18f4 // @18ED stack[0] = 0x0a // @18EF stack[1] = stack[-6] // } // Block ends with call to 0x2218, returns to 0x18F4 label_18F4: // Incoming return from call to 0x2218 at 0x18F3 // Inputs[1] { @18F8 stack[-1] } 18F4 5B JUMPDEST 18F5 61 PUSH2 0x18ff 18F8 90 SWAP1 18F9 60 PUSH1 0x30 18FB 61 PUSH2 0x205e 18FE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @18F8 stack[0] = stack[-1] // @18F8 stack[-1] = 0x18ff // @18F9 stack[1] = 0x30 // } // Block ends with call to 0x205e, returns to 0x18FF label_18FF: // Incoming return from call to 0x205E at 0x18FE // Inputs[4] // { // @1902 stack[-1] // @1903 stack[-2] // @1904 stack[-3] // @1906 memory[stack[-2]:stack[-2] + 0x20] // } 18FF 5B JUMPDEST 1900 60 PUSH1 0xf8 1902 1B SHL 1903 81 DUP2 1904 83 DUP4 1905 81 DUP2 1906 51 MLOAD 1907 81 DUP2 1908 10 LT 1909 61 PUSH2 0x1914 190C 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1902 stack[-1] = stack[-1] << 0xf8 // @1903 stack[0] = stack[-2] // @1904 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x1914, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_190D: // Incoming jump from 0x190C, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] 190D 61 PUSH2 0x1914 1910 61 PUSH2 0x222c 1913 56 *JUMP // Stack delta = +1 // Outputs[1] { @190D stack[0] = 0x1914 } // Block ends with unconditional jump to 0x222c label_1914: // Incoming jump from 0x190C, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @1917 stack[-1] // @1918 stack[-2] // @1919 stack[-3] // @1931 stack[-8] // } 1914 5B JUMPDEST 1915 60 PUSH1 0x20 1917 01 ADD 1918 01 ADD 1919 90 SWAP1 191A 60 PUSH1 0x01 191C 60 PUSH1 0x01 191E 60 PUSH1 0xf8 1920 1B SHL 1921 03 SUB 1922 19 NOT 1923 16 AND 1924 90 SWAP1 1925 81 DUP2 1926 60 PUSH1 0x00 1928 1A BYTE 1929 90 SWAP1 192A 53 MSTORE8 192B 50 POP 192C 61 PUSH2 0x1936 192F 60 PUSH1 0x0a 1931 86 DUP7 1932 61 PUSH2 0x2204 1935 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @192A memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @192C stack[-3] = 0x1936 // @192F stack[-2] = 0x0a // @1931 stack[-1] = stack[-8] // } // Block ends with call to 0x2204, returns to 0x1936 label_1936: // Incoming return from call to 0x2204 at 0x1935 // Inputs[2] // { // @1937 stack[-6] // @1937 stack[-1] // } 1936 5B JUMPDEST 1937 94 SWAP5 1938 50 POP 1939 61 PUSH2 0x18d6 193C 56 *JUMP // Stack delta = -1 // Outputs[1] { @1937 stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x18d6 label_193D: // Incoming call from 0x16D1, returns to 0x16D2 // Inputs[3] // { // @1940 stack[-2] // @1944 stack[-3] // @1945 stack[-1] // } 193D 5B JUMPDEST 193E 60 PUSH1 0x00 1940 82 DUP3 1941 61 PUSH2 0x194a 1944 85 DUP6 1945 84 DUP5 1946 61 PUSH2 0x1960 1949 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @193E stack[0] = 0x00 // @1940 stack[1] = stack[-2] // @1941 stack[2] = 0x194a // @1944 stack[3] = stack[-3] // @1945 stack[4] = stack[-1] // } // Block ends with call to 0x1960, returns to 0x194A label_194A: // Incoming return from call to 0x1960 at 0x1949 // Inputs[4] // { // @194B stack[-1] // @194B stack[-2] // @194C stack[-7] // @194D stack[-6] // } 194A 5B JUMPDEST 194B 14 EQ 194C 94 SWAP5 194D 93 SWAP4 194E 50 POP 194F 50 POP 1950 50 POP 1951 50 POP 1952 56 *JUMP // Stack delta = -6 // Outputs[1] { @194C stack[-7] = stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-7] label_1953: // Incoming call from 0x16F4, returns to 0x099C // Inputs[3] // { // @1957 stack[-3] // @1958 stack[-2] // @1959 stack[-1] // } 1953 5B JUMPDEST 1954 61 PUSH2 0x0844 1957 83 DUP4 1958 83 DUP4 1959 83 DUP4 195A 60 PUSH1 0x01 195C 61 PUSH2 0x19d4 195F 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1954 stack[0] = 0x0844 // @1957 stack[1] = stack[-3] // @1958 stack[2] = stack[-2] // @1959 stack[3] = stack[-1] // @195A stack[4] = 0x01 // } // Block ends with call to 0x19d4, returns to 0x0844 label_1960: // Incoming call from 0x1949, returns to 0x194A // Inputs[3] // { // @1963 stack[-1] // @1966 stack[-2] // @1967 memory[stack[-2]:stack[-2] + 0x20] // } 1960 5B JUMPDEST 1961 60 PUSH1 0x00 1963 81 DUP2 1964 81 DUP2 1965 5B JUMPDEST 1966 84 DUP5 1967 51 MLOAD 1968 81 DUP2 1969 10 LT 196A 15 ISZERO 196B 61 PUSH2 0x19cc 196E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1961 stack[0] = 0x00 // @1963 stack[1] = stack[-1] // @1964 stack[2] = 0x00 // } // Block ends with conditional jump to 0x19cc, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_196F: // Incoming jump from 0x196E, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x196E, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1971 stack[-5] // @1972 stack[-1] // @1974 memory[stack[-5]:stack[-5] + 0x20] // } 196F 60 PUSH1 0x00 1971 85 DUP6 1972 82 DUP3 1973 81 DUP2 1974 51 MLOAD 1975 81 DUP2 1976 10 LT 1977 61 PUSH2 0x1982 197A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @196F stack[0] = 0x00 // @1971 stack[1] = stack[-5] // @1972 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x1982, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_197B: // Incoming jump from 0x197A, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 197B 61 PUSH2 0x1982 197E 61 PUSH2 0x222c 1981 56 *JUMP // Stack delta = +1 // Outputs[1] { @197B stack[0] = 0x1982 } // Block ends with unconditional jump to 0x222c label_1982: // Incoming jump from 0x197A, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[5] // { // @1985 stack[-1] // @1989 stack[-2] // @198A memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @198B stack[-3] // @198E stack[-5] // } 1982 5B JUMPDEST 1983 60 PUSH1 0x20 1985 02 MUL 1986 60 PUSH1 0x20 1988 01 ADD 1989 01 ADD 198A 51 MLOAD 198B 90 SWAP1 198C 50 POP 198D 80 DUP1 198E 83 DUP4 198F 11 GT 1990 61 PUSH2 0x19a8 1993 57 *JUMPI // Stack delta = -2 // Outputs[1] { @198B stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with conditional jump to 0x19a8, if stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_1994: // Incoming jump from 0x1993, if not stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[3] // { // @1996 stack[-3] // @199B stack[-1] // @19A1 memory[0x00:0x40] // } 1994 60 PUSH1 0x00 1996 83 DUP4 1997 81 DUP2 1998 52 MSTORE 1999 60 PUSH1 0x20 199B 82 DUP3 199C 90 SWAP1 199D 52 MSTORE 199E 60 PUSH1 0x40 19A0 90 SWAP1 19A1 20 SHA3 19A2 92 SWAP3 19A3 50 POP 19A4 61 PUSH2 0x19b9 19A7 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1998 memory[0x00:0x20] = stack[-3] // @199D memory[0x20:0x40] = stack[-1] // @19A2 stack[-3] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to 0x19b9 label_19A8: // Incoming jump from 0x1993, if stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[4] // { // @19AB stack[-1] // @19B0 stack[-3] // @19B6 memory[0x00:0x40] // @19BB stack[-2] // } 19A8 5B JUMPDEST 19A9 60 PUSH1 0x00 19AB 81 DUP2 19AC 81 DUP2 19AD 52 MSTORE 19AE 60 PUSH1 0x20 19B0 84 DUP5 19B1 90 SWAP1 19B2 52 MSTORE 19B3 60 PUSH1 0x40 19B5 90 SWAP1 19B6 20 SHA3 19B7 92 SWAP3 19B8 50 POP 19B9 5B JUMPDEST 19BA 50 POP 19BB 80 DUP1 19BC 61 PUSH2 0x19c4 19BF 81 DUP2 19C0 61 PUSH2 0x21d3 19C3 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @19AD memory[0x00:0x20] = stack[-1] // @19B2 memory[0x20:0x40] = stack[-3] // @19B7 stack[-3] = keccak256(memory[0x00:0x40]) // @19BB stack[-1] = stack[-2] // @19BC stack[0] = 0x19c4 // @19BF stack[1] = stack[-2] // } // Block ends with call to 0x21d3, returns to 0x19C4 label_19C4: // Incoming return from call to 0x21D3 at 0x19C3 // Incoming return from call to 0x21D3 at 0x19C3 // Inputs[2] // { // @19C5 stack[-1] // @19C5 stack[-3] // } 19C4 5B JUMPDEST 19C5 91 SWAP2 19C6 50 POP 19C7 50 POP 19C8 61 PUSH2 0x1965 19CB 56 *JUMP // Stack delta = -2 // Outputs[1] { @19C5 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1965 label_19CC: // Incoming jump from 0x196E, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x196E, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @19CE stack[-2] // @19CE stack[-6] // @19CF stack[-5] // } 19CC 5B JUMPDEST 19CD 50 POP 19CE 93 SWAP4 19CF 92 SWAP3 19D0 50 POP 19D1 50 POP 19D2 50 POP 19D3 56 *JUMP // Stack delta = -5 // Outputs[1] { @19CE stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_19D4: // Incoming call from 0x195F, returns to 0x0844 // Inputs[2] // { // @19D7 storage[0x00] // @19E0 stack[-4] // } 19D4 5B JUMPDEST 19D5 60 PUSH1 0x00 19D7 54 SLOAD 19D8 60 PUSH1 0x01 19DA 60 PUSH1 0x01 19DC 60 PUSH1 0xa0 19DE 1B SHL 19DF 03 SUB 19E0 85 DUP6 19E1 16 AND 19E2 61 PUSH2 0x19fd 19E5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @19D7 stack[0] = storage[0x00] } // Block ends with conditional jump to 0x19fd, if stack[-4] & (0x01 << 0xa0) - 0x01 label_19E6: // Incoming jump from 0x19E5, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @19E8 memory[0x40:0x60] // @19F7 memory[0x40:0x60] // @19FC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 19E6 60 PUSH1 0x40 19E8 51 MLOAD 19E9 62 PUSH3 0x2e0763 19ED 60 PUSH1 0xe8 19EF 1B SHL 19F0 81 DUP2 19F1 52 MSTORE 19F2 60 PUSH1 0x04 19F4 01 ADD 19F5 60 PUSH1 0x40 19F7 51 MLOAD 19F8 80 DUP1 19F9 91 SWAP2 19FA 03 SUB 19FB 90 SWAP1 19FC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @19F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e0763 << 0xe8 // @19FC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_19FD: // Incoming jump from 0x19E5, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @19FE stack[-4] } 19FD 5B JUMPDEST 19FE 83 DUP4 19FF 61 PUSH2 0x1a1b 1A02 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1a1b, if stack[-4] label_1A03: // Incoming jump from 0x1A02, if not stack[-4] // Inputs[3] // { // @1A05 memory[0x40:0x60] // @1A15 memory[0x40:0x60] // @1A1A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1A03 60 PUSH1 0x40 1A05 51 MLOAD 1A06 63 PUSH4 0xb562e8dd 1A0B 60 PUSH1 0xe0 1A0D 1B SHL 1A0E 81 DUP2 1A0F 52 MSTORE 1A10 60 PUSH1 0x04 1A12 01 ADD 1A13 60 PUSH1 0x40 1A15 51 MLOAD 1A16 80 DUP1 1A17 91 SWAP2 1A18 03 SUB 1A19 90 SWAP1 1A1A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1A0F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd << 0xe0 // @1A1A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1A1B: // Incoming jump from 0x1A02, if stack[-4] // Inputs[9] // { // @1A24 stack[-5] // @1A36 memory[0x00:0x40] // @1A38 storage[keccak256(memory[0x00:0x40])] // @1A59 stack[-4] // @1A8A stack[-1] // @1A94 memory[0x00:0x40] // @1A96 storage[keccak256(memory[0x00:0x40])] // @1AA9 block.timestamp // @1AB8 stack[-2] // } 1A1B 5B JUMPDEST 1A1C 60 PUSH1 0x01 1A1E 60 PUSH1 0x01 1A20 60 PUSH1 0xa0 1A22 1B SHL 1A23 03 SUB 1A24 85 DUP6 1A25 16 AND 1A26 60 PUSH1 0x00 1A28 81 DUP2 1A29 81 DUP2 1A2A 52 MSTORE 1A2B 60 PUSH1 0x05 1A2D 60 PUSH1 0x20 1A2F 90 SWAP1 1A30 81 DUP2 1A31 52 MSTORE 1A32 60 PUSH1 0x40 1A34 80 DUP1 1A35 83 DUP4 1A36 20 SHA3 1A37 80 DUP1 1A38 54 SLOAD 1A39 6F PUSH16 0xffffffffffffffffffffffffffffffff 1A4A 19 NOT 1A4B 81 DUP2 1A4C 16 AND 1A4D 67 PUSH8 0xffffffffffffffff 1A56 80 DUP1 1A57 83 DUP4 1A58 16 AND 1A59 8C DUP13 1A5A 01 ADD 1A5B 81 DUP2 1A5C 16 AND 1A5D 91 SWAP2 1A5E 82 DUP3 1A5F 17 OR 1A60 68 PUSH9 0x010000000000000000 1A6A 67 PUSH8 0xffffffffffffffff 1A73 19 NOT 1A74 90 SWAP1 1A75 94 SWAP5 1A76 16 AND 1A77 90 SWAP1 1A78 92 SWAP3 1A79 17 OR 1A7A 83 DUP4 1A7B 90 SWAP1 1A7C 04 DIV 1A7D 81 DUP2 1A7E 16 AND 1A7F 8C DUP13 1A80 01 ADD 1A81 81 DUP2 1A82 16 AND 1A83 90 SWAP1 1A84 92 SWAP3 1A85 02 MUL 1A86 17 OR 1A87 90 SWAP1 1A88 91 SWAP2 1A89 55 SSTORE 1A8A 85 DUP6 1A8B 84 DUP5 1A8C 52 MSTORE 1A8D 60 PUSH1 0x04 1A8F 90 SWAP1 1A90 92 SWAP3 1A91 52 MSTORE 1A92 90 SWAP1 1A93 91 SWAP2 1A94 20 SHA3 1A95 80 DUP1 1A96 54 SLOAD 1A97 60 PUSH1 0x01 1A99 60 PUSH1 0x01 1A9B 60 PUSH1 0xe0 1A9D 1B SHL 1A9E 03 SUB 1A9F 19 NOT 1AA0 16 AND 1AA1 90 SWAP1 1AA2 92 SWAP3 1AA3 17 OR 1AA4 60 PUSH1 0x01 1AA6 60 PUSH1 0xa0 1AA8 1B SHL 1AA9 42 TIMESTAMP 1AAA 90 SWAP1 1AAB 92 SWAP3 1AAC 16 AND 1AAD 91 SWAP2 1AAE 90 SWAP1 1AAF 91 SWAP2 1AB0 02 MUL 1AB1 17 OR 1AB2 90 SWAP1 1AB3 55 SSTORE 1AB4 80 DUP1 1AB5 80 DUP1 1AB6 85 DUP6 1AB7 01 ADD 1AB8 83 DUP4 1AB9 80 DUP1 1ABA 15 ISZERO 1ABB 61 PUSH2 0x1acd 1ABE 57 *JUMPI // Stack delta = +3 // Outputs[9] // { // @1A2A memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1A31 memory[0x20:0x40] = 0x05 // @1A89 storage[keccak256(memory[0x00:0x40])] = 0x010000000000000000 * (0xffffffffffffffff & stack[-4] + (0xffffffffffffffff & ((0xffffffffffffffff & stack[-4] + (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff)) / 0x010000000000000000)) | (0xffffffffffffffff & stack[-4] + (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffffffffffffffffffff) // @1A8C memory[0x00:0x20] = stack[-1] // @1A91 memory[0x20:0x40] = 0x04 // @1AB3 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1AB4 stack[0] = stack[-1] // @1AB7 stack[1] = stack[-4] + stack[-1] // @1AB8 stack[2] = stack[-2] // } // Block ends with conditional jump to 0x1acd, if !stack[-2] label_1ABF: // Incoming jump from 0x1ABE, if not !stack[-2] // Inputs[2] // { // @1AC8 stack[-8] // @1ACA address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // } 1ABF 50 POP 1AC0 60 PUSH1 0x01 1AC2 60 PUSH1 0x01 1AC4 60 PUSH1 0xa0 1AC6 1B SHL 1AC7 03 SUB 1AC8 87 DUP8 1AC9 16 AND 1ACA 3B EXTCODESIZE 1ACB 15 ISZERO 1ACC 15 ISZERO 1ACD 5B JUMPDEST 1ACE 15 ISZERO 1ACF 61 PUSH2 0x1b56 1AD2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b56, if !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length label_1AD3: // Incoming jump from 0x1AD2, if not !stack[-1] // Incoming jump from 0x1AD2, if not !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Inputs[5] // { // @1AD6 memory[0x40:0x60] // @1AD7 stack[-2] // @1AE1 stack[-7] // @1B0B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1B19 stack[-5] // } 1AD3 5B JUMPDEST 1AD4 60 PUSH1 0x40 1AD6 51 MLOAD 1AD7 82 DUP3 1AD8 90 SWAP1 1AD9 60 PUSH1 0x01 1ADB 60 PUSH1 0x01 1ADD 60 PUSH1 0xa0 1ADF 1B SHL 1AE0 03 SUB 1AE1 89 DUP10 1AE2 16 AND 1AE3 90 SWAP1 1AE4 60 PUSH1 0x00 1AE6 90 SWAP1 1AE7 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1B08 90 SWAP1 1B09 82 DUP3 1B0A 90 SWAP1 1B0B A4 LOG4 1B0C 61 PUSH2 0x1b1e 1B0F 60 PUSH1 0x00 1B11 88 DUP9 1B12 84 DUP5 1B13 80 DUP1 1B14 60 PUSH1 0x01 1B16 01 ADD 1B17 95 SWAP6 1B18 50 POP 1B19 88 DUP9 1B1A 61 PUSH2 0x1747 1B1D 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1B0B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // @1B0C stack[0] = 0x1b1e // @1B0F stack[1] = 0x00 // @1B11 stack[2] = stack[-7] // @1B12 stack[3] = stack[-2] // @1B17 stack[-2] = 0x01 + stack[-2] // @1B19 stack[4] = stack[-5] // } // Block ends with unconditional jump to 0x1747 1B1E 5B JUMPDEST 1B1F 61 PUSH2 0x1b3b 1B22 57 *JUMPI 1B23 60 PUSH1 0x40 1B25 51 MLOAD 1B26 63 PUSH4 0x68d2bf6b 1B2B 60 PUSH1 0xe1 1B2D 1B SHL 1B2E 81 DUP2 1B2F 52 MSTORE 1B30 60 PUSH1 0x04 1B32 01 ADD 1B33 60 PUSH1 0x40 1B35 51 MLOAD 1B36 80 DUP1 1B37 91 SWAP2 1B38 03 SUB 1B39 90 SWAP1 1B3A FD *REVERT 1B3B 5B JUMPDEST 1B3C 80 DUP1 1B3D 82 DUP3 1B3E 14 EQ 1B3F 15 ISZERO 1B40 61 PUSH2 0x1ad3 1B43 57 *JUMPI 1B44 82 DUP3 1B45 60 PUSH1 0x00 1B47 54 SLOAD 1B48 14 EQ 1B49 61 PUSH2 0x1b51 1B4C 57 *JUMPI 1B4D 60 PUSH1 0x00 1B4F 80 DUP1 1B50 FD *REVERT 1B51 5B JUMPDEST 1B52 61 PUSH2 0x1b9c 1B55 56 *JUMP label_1B56: // Incoming jump from 0x1AD2, if !stack[-1] // Incoming jump from 0x1AD2, if !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Inputs[5] // { // @1B5A memory[0x40:0x60] // @1B5D stack[-2] // @1B69 stack[-7] // @1B93 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1B94 stack[-1] // } 1B56 5B JUMPDEST 1B57 5B JUMPDEST 1B58 60 PUSH1 0x40 1B5A 51 MLOAD 1B5B 60 PUSH1 0x01 1B5D 83 DUP4 1B5E 01 ADD 1B5F 92 SWAP3 1B60 90 SWAP1 1B61 60 PUSH1 0x01 1B63 60 PUSH1 0x01 1B65 60 PUSH1 0xa0 1B67 1B SHL 1B68 03 SUB 1B69 89 DUP10 1B6A 16 AND 1B6B 90 SWAP1 1B6C 60 PUSH1 0x00 1B6E 90 SWAP1 1B6F 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1B90 90 SWAP1 1B91 82 DUP3 1B92 90 SWAP1 1B93 A4 LOG4 1B94 80 DUP1 1B95 82 DUP3 1B96 14 EQ 1B97 15 ISZERO 1B98 61 PUSH2 0x1b57 1B9B 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1B5F stack[-2] = stack[-2] + 0x01 // @1B93 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with conditional jump to 0x1b57, if !(stack[-2] + 0x01 == stack[-1]) label_1B9C: // Incoming jump from 0x1B9B, if not !(stack[-2] + 0x01 == stack[-1]) // Incoming jump from 0x1B9B, if not !(stack[-2] + 0x01 == stack[-1]) // Inputs[1] { @1BA0 stack[-2] } 1B9C 5B JUMPDEST 1B9D 50 POP 1B9E 60 PUSH1 0x00 1BA0 55 SSTORE 1BA1 61 PUSH2 0x1525 1BA4 56 *JUMP // Stack delta = -2 // Outputs[1] { @1BA0 storage[0x00] = stack[-2] } // Block ends with unconditional jump to 0x1525 label_1BA5: // Incoming jump from 0x09EE // Incoming jump from 0x099B // Inputs[2] // { // @1BA6 stack[-3] // @1BA8 storage[stack[-3]] // } 1BA5 5B JUMPDEST 1BA6 82 DUP3 1BA7 80 DUP1 1BA8 54 SLOAD 1BA9 61 PUSH2 0x1bb1 1BAC 90 SWAP1 1BAD 61 PUSH2 0x1fd8 1BB0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1BA6 stack[0] = stack[-3] // @1BAC stack[1] = 0x1bb1 // @1BAC stack[2] = storage[stack[-3]] // } // Block ends with call to 0x1fd8, returns to 0x1BB1 label_1BB1: // Incoming return from call to 0x1FD8 at 0x1BB0 // Inputs[5] // { // @1BB2 stack[-1] // @1BB2 stack[-2] // @1BBA memory[0x00:0x20] // @1BC5 stack[-4] // @1BC6 stack[-3] // } 1BB1 5B JUMPDEST 1BB2 90 SWAP1 1BB3 60 PUSH1 0x00 1BB5 52 MSTORE 1BB6 60 PUSH1 0x20 1BB8 60 PUSH1 0x00 1BBA 20 SHA3 1BBB 90 SWAP1 1BBC 60 PUSH1 0x1f 1BBE 01 ADD 1BBF 60 PUSH1 0x20 1BC1 90 SWAP1 1BC2 04 DIV 1BC3 81 DUP2 1BC4 01 ADD 1BC5 92 SWAP3 1BC6 82 DUP3 1BC7 61 PUSH2 0x1bd3 1BCA 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1BB5 memory[0x00:0x20] = stack[-2] // @1BBB stack[-2] = keccak256(memory[0x00:0x20]) // @1BC5 stack[-1] = stack[-4] // @1BC5 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x1bd3, if stack[-3] label_1BCB: // Incoming jump from 0x1BCA, if not stack[-3] // Inputs[1] { @1BCD stack[-5] } 1BCB 60 PUSH1 0x00 1BCD 85 DUP6 1BCE 55 SSTORE 1BCF 61 PUSH2 0x1c19 1BD2 56 *JUMP // Stack delta = +0 // Outputs[1] { @1BCE storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x1c19 label_1BD3: // Incoming jump from 0x1BCA, if stack[-3] // Inputs[1] { @1BD4 stack[-3] } 1BD3 5B JUMPDEST 1BD4 82 DUP3 1BD5 60 PUSH1 0x1f 1BD7 10 LT 1BD8 61 PUSH2 0x1bec 1BDB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1bec, if 0x1f < stack[-3] label_1BDC: // Incoming jump from 0x1BDB, if not 0x1f < stack[-3] // Inputs[4] // { // @1BDC stack[-1] // @1BDD memory[stack[-1]:stack[-1] + 0x20] // @1BE2 stack[-3] // @1BE6 stack[-5] // } 1BDC 80 DUP1 1BDD 51 MLOAD 1BDE 60 PUSH1 0xff 1BE0 19 NOT 1BE1 16 AND 1BE2 83 DUP4 1BE3 80 DUP1 1BE4 01 ADD 1BE5 17 OR 1BE6 85 DUP6 1BE7 55 SSTORE 1BE8 61 PUSH2 0x1c19 1BEB 56 *JUMP // Stack delta = +0 // Outputs[1] { @1BE7 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x1c19 label_1BEC: // Incoming jump from 0x1BDB, if 0x1f < stack[-3] // Inputs[2] // { // @1BED stack[-3] // @1BF3 stack[-5] // } 1BEC 5B JUMPDEST 1BED 82 DUP3 1BEE 80 DUP1 1BEF 01 ADD 1BF0 60 PUSH1 0x01 1BF2 01 ADD 1BF3 85 DUP6 1BF4 55 SSTORE 1BF5 82 DUP3 1BF6 15 ISZERO 1BF7 61 PUSH2 0x1c19 1BFA 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1BF4 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1c19, if !stack[-3] label_1BFB: // Incoming jump from 0x1BFA, if not !stack[-3] // Inputs[2] // { // @1BFB stack[-1] // @1BFB stack[-3] // } 1BFB 91 SWAP2 1BFC 82 DUP3 1BFD 01 ADD 1BFE 5B JUMPDEST 1BFF 82 DUP3 1C00 81 DUP2 1C01 11 GT 1C02 15 ISZERO 1C03 61 PUSH2 0x1c19 1C06 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1BFB stack[-3] = stack[-1] // @1BFD stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1c19, if !(stack[-1] + stack[-3] > stack[-1]) label_1C07: // Incoming jump from 0x1C06, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x1C06, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @1C07 stack[-3] // @1C08 memory[stack[-3]:stack[-3] + 0x20] // @1C09 stack[-2] // @1C0B stack[-1] // } 1C07 82 DUP3 1C08 51 MLOAD 1C09 82 DUP3 1C0A 55 SSTORE 1C0B 91 SWAP2 1C0C 60 PUSH1 0x20 1C0E 01 ADD 1C0F 91 SWAP2 1C10 90 SWAP1 1C11 60 PUSH1 0x01 1C13 01 ADD 1C14 90 SWAP1 1C15 61 PUSH2 0x1bfe 1C18 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1C0A storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1C0F stack[-3] = 0x20 + stack[-3] // @1C14 stack[-2] = 0x01 + stack[-2] // @1C14 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1bfe label_1C19: // Incoming jump from 0x1C06, if !(stack[-1] > stack[-3]) // Incoming jump from 0x1BFA, if !stack[-3] // Incoming jump from 0x1BEB // Incoming jump from 0x1BD2 // Incoming jump from 0x1C06, if !(stack[-1] + stack[-3] > stack[-1]) // Inputs[2] // { // @1C1E stack[-4] // @1C1F stack[-3] // } 1C19 5B JUMPDEST 1C1A 50 POP 1C1B 61 PUSH2 0x1c25 1C1E 92 SWAP3 1C1F 91 SWAP2 1C20 50 POP 1C21 61 PUSH2 0x1c29 1C24 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1C1E stack[-4] = 0x1c25 // @1C1F stack[-3] = stack[-4] // } // Block ends with call to 0x1c29, returns to 0x1C25 label_1C25: // Incoming return from call to 0x1C29 at 0x1C24 // Incoming jump from 0x1C32, if !(stack[-2] > stack[-1]) // Incoming jump from 0x1C32, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @1C27 stack[-2] // @1C27 stack[-3] // } 1C25 5B JUMPDEST 1C26 50 POP 1C27 90 SWAP1 1C28 56 *JUMP // Stack delta = -2 // Outputs[1] { @1C27 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1C29: // Incoming call from 0x1C24, returns to 0x1C25 // Inputs[2] // { // @1C2B stack[-1] // @1C2C stack[-2] // } 1C29 5B JUMPDEST 1C2A 5B JUMPDEST 1C2B 80 DUP1 1C2C 82 DUP3 1C2D 11 GT 1C2E 15 ISZERO 1C2F 61 PUSH2 0x1c25 1C32 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c25, if !(stack[-2] > stack[-1]) label_1C33: // Incoming jump from 0x1C32, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1C32, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1C35 stack[-1] } 1C33 60 PUSH1 0x00 1C35 81 DUP2 1C36 55 SSTORE 1C37 60 PUSH1 0x01 1C39 01 ADD 1C3A 61 PUSH2 0x1c2a 1C3D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1C36 storage[stack[-1]] = 0x00 // @1C39 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1c2a label_1C3E: // Incoming call from 0x1C70, returns to 0x1C71 // Incoming call from 0x21D2, returns to 0x1C71 // Inputs[1] { @1C48 stack[-1] } 1C3E 5B JUMPDEST 1C3F 60 PUSH1 0x01 1C41 60 PUSH1 0x01 1C43 60 PUSH1 0xe0 1C45 1B SHL 1C46 03 SUB 1C47 19 NOT 1C48 81 DUP2 1C49 16 AND 1C4A 81 DUP2 1C4B 14 EQ 1C4C 61 PUSH2 0x0941 1C4F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0941, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1C50: // Incoming jump from 0x1C4F, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1C53 memory[0x00:0x00] } 1C50 60 PUSH1 0x00 1C52 80 DUP1 1C53 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C53 revert(memory[0x00:0x00]); } // Block terminates label_1C54: // Incoming call from 0x022E, returns to 0x022F // Inputs[2] // { // @1C59 stack[-1] // @1C5A stack[-2] // } 1C54 5B JUMPDEST 1C55 60 PUSH1 0x00 1C57 60 PUSH1 0x20 1C59 82 DUP3 1C5A 84 DUP5 1C5B 03 SUB 1C5C 12 SLT 1C5D 15 ISZERO 1C5E 61 PUSH2 0x1c66 1C61 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C55 stack[0] = 0x00 } // Block ends with conditional jump to 0x1c66, if !(stack[-2] - stack[-1] i< 0x20) label_1C62: // Incoming jump from 0x1C61, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1C65 memory[0x00:0x00] } 1C62 60 PUSH1 0x00 1C64 80 DUP1 1C65 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C65 revert(memory[0x00:0x00]); } // Block terminates label_1C66: // Incoming jump from 0x1C61, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1C67 stack[-2] // @1C68 msg.data[stack[-2]:stack[-2] + 0x20] // } 1C66 5B JUMPDEST 1C67 81 DUP2 1C68 35 CALLDATALOAD 1C69 61 PUSH2 0x1c71 1C6C 81 DUP2 1C6D 61 PUSH2 0x1c3e 1C70 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C68 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1C69 stack[1] = 0x1c71 // @1C6C stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1c3e, returns to 0x1C71 label_1C71: // Incoming return from call to 0x1C3E at 0x21D2 // Incoming return from call to 0x1CFC at 0x1D5C // Incoming return from call to 0x1C3E at 0x1C70 // Incoming return from call to 0x1CA4 at 0x1CE2 // Inputs[3] // { // @1C72 stack[-5] // @1C72 stack[-1] // @1C73 stack[-4] // } 1C71 5B JUMPDEST 1C72 93 SWAP4 1C73 92 SWAP3 1C74 50 POP 1C75 50 POP 1C76 50 POP 1C77 56 *JUMP // Stack delta = -4 // Outputs[1] { @1C72 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1C78: // Incoming call from 0x2161, returns to 0x2162 // Incoming call from 0x1CBB, returns to 0x1CBC // Inputs[1] { @1C7C stack[-3] } 1C78 5B JUMPDEST 1C79 60 PUSH1 0x00 1C7B 5B JUMPDEST 1C7C 83 DUP4 1C7D 81 DUP2 1C7E 10 LT 1C7F 15 ISZERO 1C80 61 PUSH2 0x1c93 1C83 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C79 stack[0] = 0x00 } // Block ends with conditional jump to 0x1c93, if !(0x00 < stack[-3]) label_1C84: // Incoming jump from 0x1C83, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1C83, if not !(0x00 < stack[-3]) // Inputs[4] // { // @1C84 stack[-2] // @1C85 stack[-1] // @1C87 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1C88 stack[-3] // } 1C84 81 DUP2 1C85 81 DUP2 1C86 01 ADD 1C87 51 MLOAD 1C88 83 DUP4 1C89 82 DUP3 1C8A 01 ADD 1C8B 52 MSTORE 1C8C 60 PUSH1 0x20 1C8E 01 ADD 1C8F 61 PUSH2 0x1c7b 1C92 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1C8B memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1C8E stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1c7b label_1C93: // Incoming jump from 0x1C83, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1C83, if !(0x00 < stack[-3]) // Inputs[2] // { // @1C94 stack[-4] // @1C95 stack[-1] // } 1C93 5B JUMPDEST 1C94 83 DUP4 1C95 81 DUP2 1C96 11 GT 1C97 15 ISZERO 1C98 61 PUSH2 0x0c46 1C9B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c46, if !(stack[-1] > stack[-4]) label_1C9C: // Incoming jump from 0x1C9B, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @1CA0 stack[-4] // @1CA1 stack[-3] // @1CA3 stack[-5] // } 1C9C 50 POP 1C9D 50 POP 1C9E 60 PUSH1 0x00 1CA0 91 SWAP2 1CA1 01 ADD 1CA2 52 MSTORE 1CA3 56 *JUMP // Stack delta = -5 // Outputs[1] { @1CA2 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1CA4: // Incoming call from 0x21AB, returns to 0x21AC // Incoming call from 0x1CE2, returns to 0x1C71 // Inputs[3] // { // @1CA7 stack[-1] // @1CA8 memory[stack[-1]:stack[-1] + 0x20] // @1CAA stack[-2] // } 1CA4 5B JUMPDEST 1CA5 60 PUSH1 0x00 1CA7 81 DUP2 1CA8 51 MLOAD 1CA9 80 DUP1 1CAA 84 DUP5 1CAB 52 MSTORE 1CAC 61 PUSH2 0x1cbc 1CAF 81 DUP2 1CB0 60 PUSH1 0x20 1CB2 86 DUP7 1CB3 01 ADD 1CB4 60 PUSH1 0x20 1CB6 86 DUP7 1CB7 01 ADD 1CB8 61 PUSH2 0x1c78 1CBB 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1CA5 stack[0] = 0x00 // @1CA8 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1CAB memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1CAC stack[2] = 0x1cbc // @1CAF stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1CB3 stack[4] = stack[-2] + 0x20 // @1CB7 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x1c78, returns to 0x1CBC label_1CBC: // Incoming return from call to 0x1C78 at 0x1CBB // Inputs[4] // { // @1CBF stack[-1] // @1CC4 stack[-4] // @1CC5 stack[-2] // @1CCB stack[-5] // } 1CBC 5B JUMPDEST 1CBD 60 PUSH1 0x1f 1CBF 01 ADD 1CC0 60 PUSH1 0x1f 1CC2 19 NOT 1CC3 16 AND 1CC4 92 SWAP3 1CC5 90 SWAP1 1CC6 92 SWAP3 1CC7 01 ADD 1CC8 60 PUSH1 0x20 1CCA 01 ADD 1CCB 92 SWAP3 1CCC 91 SWAP2 1CCD 50 POP 1CCE 50 POP 1CCF 56 *JUMP // Stack delta = -4 // Outputs[1] { @1CCB stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1CD0: // Incoming jump from 0x026A // Inputs[2] // { // @1CD3 stack[-1] // @1CDE stack[-2] // } 1CD0 5B JUMPDEST 1CD1 60 PUSH1 0x20 1CD3 81 DUP2 1CD4 52 MSTORE 1CD5 60 PUSH1 0x00 1CD7 61 PUSH2 0x1c71 1CDA 60 PUSH1 0x20 1CDC 83 DUP4 1CDD 01 ADD 1CDE 84 DUP5 1CDF 61 PUSH2 0x1ca4 1CE2 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1CD4 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1CD5 stack[0] = 0x00 // @1CD7 stack[1] = 0x1c71 // @1CDD stack[2] = stack[-1] + 0x20 // @1CDE stack[3] = stack[-2] // } // Block ends with call to 0x1ca4, returns to 0x1C71 label_1CE3: // Incoming call from 0x060F, returns to 0x0610 // Incoming call from 0x05AF, returns to 0x05B0 // Incoming call from 0x0439, returns to 0x043A // Incoming call from 0x055A, returns to 0x055B // Incoming call from 0x051C, returns to 0x051D // Incoming call from 0x0285, returns to 0x0286 // Inputs[2] // { // @1CE8 stack[-1] // @1CE9 stack[-2] // } 1CE3 5B JUMPDEST 1CE4 60 PUSH1 0x00 1CE6 60 PUSH1 0x20 1CE8 82 DUP3 1CE9 84 DUP5 1CEA 03 SUB 1CEB 12 SLT 1CEC 15 ISZERO 1CED 61 PUSH2 0x1cf5 1CF0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CE4 stack[0] = 0x00 } // Block ends with conditional jump to 0x1cf5, if !(stack[-2] - stack[-1] i< 0x20) label_1CF1: // Incoming jump from 0x1CF0, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1CF4 memory[0x00:0x00] } 1CF1 60 PUSH1 0x00 1CF3 80 DUP1 1CF4 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CF4 revert(memory[0x00:0x00]); } // Block terminates label_1CF5: // Incoming jump from 0x1CF0, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1CF7 msg.data[stack[-2]:stack[-2] + 0x20] // @1CF7 stack[-2] // @1CF8 stack[-4] // @1CF9 stack[-3] // } 1CF5 5B JUMPDEST 1CF6 50 POP 1CF7 35 CALLDATALOAD 1CF8 91 SWAP2 1CF9 90 SWAP1 1CFA 50 POP 1CFB 56 *JUMP // Stack delta = -3 // Outputs[1] { @1CF8 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1CFC: // Incoming call from 0x1FC0, returns to 0x1FC1 // Incoming call from 0x1D33, returns to 0x1D34 // Incoming call from 0x1FCE, returns to 0x1FCF // Incoming call from 0x1D7A, returns to 0x1D7B // Incoming call from 0x1D88, returns to 0x1D89 // Incoming call from 0x1F47, returns to 0x1F48 // Incoming call from 0x1F08, returns to 0x1F09 // Incoming call from 0x1F55, returns to 0x1F56 // Incoming call from 0x1D5C, returns to 0x1C71 // Inputs[2] // { // @1CFD stack[-1] // @1CFE msg.data[stack[-1]:stack[-1] + 0x20] // } 1CFC 5B JUMPDEST 1CFD 80 DUP1 1CFE 35 CALLDATALOAD 1CFF 60 PUSH1 0x01 1D01 60 PUSH1 0x01 1D03 60 PUSH1 0xa0 1D05 1B SHL 1D06 03 SUB 1D07 81 DUP2 1D08 16 AND 1D09 81 DUP2 1D0A 14 EQ 1D0B 61 PUSH2 0x1d13 1D0E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CFE stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1d13, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_1D0F: // Incoming jump from 0x1D0E, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1D12 memory[0x00:0x00] } 1D0F 60 PUSH1 0x00 1D11 80 DUP1 1D12 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D12 revert(memory[0x00:0x00]); } // Block terminates label_1D13: // Incoming jump from 0x1D0E, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1D14 stack[-3] // @1D14 stack[-1] // @1D15 stack[-2] // } 1D13 5B JUMPDEST 1D14 91 SWAP2 1D15 90 SWAP1 1D16 50 POP 1D17 56 *JUMP // Stack delta = -2 // Outputs[1] { @1D14 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1D18: // Incoming call from 0x02BD, returns to 0x02BE // Incoming call from 0x04CC, returns to 0x04CD // Inputs[2] // { // @1D1E stack[-1] // @1D1F stack[-2] // } 1D18 5B JUMPDEST 1D19 60 PUSH1 0x00 1D1B 80 DUP1 1D1C 60 PUSH1 0x40 1D1E 83 DUP4 1D1F 85 DUP6 1D20 03 SUB 1D21 12 SLT 1D22 15 ISZERO 1D23 61 PUSH2 0x1d2b 1D26 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D19 stack[0] = 0x00 // @1D1B stack[1] = 0x00 // } // Block ends with conditional jump to 0x1d2b, if !(stack[-2] - stack[-1] i< 0x40) label_1D27: // Incoming jump from 0x1D26, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1D2A memory[0x00:0x00] } 1D27 60 PUSH1 0x00 1D29 80 DUP1 1D2A FD *REVERT // Stack delta = +0 // Outputs[1] { @1D2A revert(memory[0x00:0x00]); } // Block terminates label_1D2B: // Incoming jump from 0x1D26, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1D2F stack[-3] } 1D2B 5B JUMPDEST 1D2C 61 PUSH2 0x1d34 1D2F 83 DUP4 1D30 61 PUSH2 0x1cfc 1D33 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D2C stack[0] = 0x1d34 // @1D2F stack[1] = stack[-3] // } // Block ends with call to 0x1cfc, returns to 0x1D34 label_1D34: // Incoming return from call to 0x1CFC at 0x1D33 // Inputs[5] // { // @1D35 stack[-1] // @1D35 stack[-6] // @1D38 stack[-4] // @1D3C msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1D3D stack[-5] // } 1D34 5B JUMPDEST 1D35 94 SWAP5 1D36 60 PUSH1 0x20 1D38 93 SWAP4 1D39 90 SWAP1 1D3A 93 SWAP4 1D3B 01 ADD 1D3C 35 CALLDATALOAD 1D3D 93 SWAP4 1D3E 50 POP 1D3F 50 POP 1D40 50 POP 1D41 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1D35 stack[-6] = stack[-1] // @1D3D stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_1D42: // Incoming call from 0x02DF, returns to 0x02E0 // Incoming call from 0x068D, returns to 0x068E // Incoming call from 0x0482, returns to 0x0483 // Incoming call from 0x058F, returns to 0x0590 // Inputs[2] // { // @1D47 stack[-1] // @1D48 stack[-2] // } 1D42 5B JUMPDEST 1D43 60 PUSH1 0x00 1D45 60 PUSH1 0x20 1D47 82 DUP3 1D48 84 DUP5 1D49 03 SUB 1D4A 12 SLT 1D4B 15 ISZERO 1D4C 61 PUSH2 0x1d54 1D4F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D43 stack[0] = 0x00 } // Block ends with conditional jump to 0x1d54, if !(stack[-2] - stack[-1] i< 0x20) label_1D50: // Incoming jump from 0x1D4F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1D53 memory[0x00:0x00] } 1D50 60 PUSH1 0x00 1D52 80 DUP1 1D53 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D53 revert(memory[0x00:0x00]); } // Block terminates label_1D54: // Incoming jump from 0x1D4F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1D58 stack[-2] } 1D54 5B JUMPDEST 1D55 61 PUSH2 0x1c71 1D58 82 DUP3 1D59 61 PUSH2 0x1cfc 1D5C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D55 stack[0] = 0x1c71 // @1D58 stack[1] = stack[-2] // } // Block ends with call to 0x1cfc, returns to 0x1C71 label_1D5D: // Incoming call from 0x0374, returns to 0x0375 // Incoming call from 0x03BF, returns to 0x03C0 // Inputs[2] // { // @1D65 stack[-1] // @1D66 stack[-2] // } 1D5D 5B JUMPDEST 1D5E 60 PUSH1 0x00 1D60 80 DUP1 1D61 60 PUSH1 0x00 1D63 60 PUSH1 0x60 1D65 84 DUP5 1D66 86 DUP7 1D67 03 SUB 1D68 12 SLT 1D69 15 ISZERO 1D6A 61 PUSH2 0x1d72 1D6D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1D5E stack[0] = 0x00 // @1D60 stack[1] = 0x00 // @1D61 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1d72, if !(stack[-2] - stack[-1] i< 0x60) label_1D6E: // Incoming jump from 0x1D6D, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1D71 memory[0x00:0x00] } 1D6E 60 PUSH1 0x00 1D70 80 DUP1 1D71 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D71 revert(memory[0x00:0x00]); } // Block terminates label_1D72: // Incoming jump from 0x1D6D, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1D76 stack[-4] } 1D72 5B JUMPDEST 1D73 61 PUSH2 0x1d7b 1D76 84 DUP5 1D77 61 PUSH2 0x1cfc 1D7A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D73 stack[0] = 0x1d7b // @1D76 stack[1] = stack[-4] // } // Block ends with call to 0x1cfc, returns to 0x1D7B label_1D7B: // Incoming return from call to 0x1CFC at 0x1D7A // Inputs[3] // { // @1D7C stack[-1] // @1D7C stack[-4] // @1D83 stack[-5] // } 1D7B 5B JUMPDEST 1D7C 92 SWAP3 1D7D 50 POP 1D7E 61 PUSH2 0x1d89 1D81 60 PUSH1 0x20 1D83 85 DUP6 1D84 01 ADD 1D85 61 PUSH2 0x1cfc 1D88 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1D7C stack[-4] = stack[-1] // @1D7E stack[-1] = 0x1d89 // @1D84 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x1cfc, returns to 0x1D89 label_1D89: // Incoming return from call to 0x1CFC at 0x1D88 // Inputs[8] // { // @1D8A stack[-1] // @1D8A stack[-3] // @1D8E stack[-5] // @1D90 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1D91 stack[-2] // @1D95 stack[-6] // @1D97 stack[-7] // @1D97 stack[-4] // } 1D89 5B JUMPDEST 1D8A 91 SWAP2 1D8B 50 POP 1D8C 60 PUSH1 0x40 1D8E 84 DUP5 1D8F 01 ADD 1D90 35 CALLDATALOAD 1D91 90 SWAP1 1D92 50 POP 1D93 92 SWAP3 1D94 50 POP 1D95 92 SWAP3 1D96 50 POP 1D97 92 SWAP3 1D98 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1D93 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1D95 stack[-6] = stack[-1] // @1D97 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1D99: // Incoming jump from 0x1DC9 // Incoming jump from 0x1DF1 // Incoming jump from 0x18A7 // Inputs[1] { @1DAE memory[0x00:0x24] } 1D99 5B JUMPDEST 1D9A 63 PUSH4 0x4e487b71 1D9F 60 PUSH1 0xe0 1DA1 1B SHL 1DA2 60 PUSH1 0x00 1DA4 52 MSTORE 1DA5 60 PUSH1 0x41 1DA7 60 PUSH1 0x04 1DA9 52 MSTORE 1DAA 60 PUSH1 0x24 1DAC 60 PUSH1 0x00 1DAE FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1DA4 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1DA9 memory[0x04:0x24] = 0x41 // @1DAE revert(memory[0x00:0x24]); // } // Block terminates label_1DAF: // Incoming call from 0x1E6D, returns to 0x1837 // Incoming call from 0x1F98, returns to 0x1F99 // Inputs[1] { @1DBC stack[-2] } 1DAF 5B JUMPDEST 1DB0 60 PUSH1 0x00 1DB2 67 PUSH8 0xffffffffffffffff 1DBB 80 DUP1 1DBC 84 DUP5 1DBD 11 GT 1DBE 15 ISZERO 1DBF 61 PUSH2 0x1dca 1DC2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DB0 stack[0] = 0x00 // @1DB2 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1dca, if !(stack[-2] > 0xffffffffffffffff) label_1DC3: // Incoming jump from 0x1DC2, if not !(stack[-2] > 0xffffffffffffffff) 1DC3 61 PUSH2 0x1dca 1DC6 61 PUSH2 0x1d99 1DC9 56 *JUMP // Stack delta = +1 // Outputs[1] { @1DC3 stack[0] = 0x1dca } // Block ends with unconditional jump to 0x1d99 label_1DCA: // Incoming jump from 0x1DC2, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @1DCD memory[0x40:0x60] // @1DD0 stack[-4] // @1DDF stack[-1] // } 1DCA 5B JUMPDEST 1DCB 60 PUSH1 0x40 1DCD 51 MLOAD 1DCE 60 PUSH1 0x1f 1DD0 85 DUP6 1DD1 01 ADD 1DD2 60 PUSH1 0x1f 1DD4 19 NOT 1DD5 90 SWAP1 1DD6 81 DUP2 1DD7 16 AND 1DD8 60 PUSH1 0x3f 1DDA 01 ADD 1DDB 16 AND 1DDC 81 DUP2 1DDD 01 ADD 1DDE 90 SWAP1 1DDF 82 DUP3 1DE0 82 DUP3 1DE1 11 GT 1DE2 81 DUP2 1DE3 83 DUP4 1DE4 10 LT 1DE5 17 OR 1DE6 15 ISZERO 1DE7 61 PUSH2 0x1df2 1DEA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DDE stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @1DDE stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x1df2, 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_1DEB: // Incoming jump from 0x1DEA, 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])) 1DEB 61 PUSH2 0x1df2 1DEE 61 PUSH2 0x1d99 1DF1 56 *JUMP // Stack delta = +1 // Outputs[1] { @1DEB stack[0] = 0x1df2 } // Block ends with unconditional jump to 0x1d99 label_1DF2: // Incoming jump from 0x1DEA, 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] // { // @1DF3 stack[-2] // @1DF7 stack[-1] // @1DF8 stack[-4] // @1DFA stack[-6] // @1DFD stack[-7] // @1DFF stack[-5] // } 1DF2 5B JUMPDEST 1DF3 81 DUP2 1DF4 60 PUSH1 0x40 1DF6 52 MSTORE 1DF7 80 DUP1 1DF8 93 SWAP4 1DF9 50 POP 1DFA 85 DUP6 1DFB 81 DUP2 1DFC 52 MSTORE 1DFD 86 DUP7 1DFE 86 DUP7 1DFF 86 DUP7 1E00 01 ADD 1E01 11 GT 1E02 15 ISZERO 1E03 61 PUSH2 0x1e0b 1E06 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1DF6 memory[0x40:0x60] = stack[-2] // @1DF8 stack[-4] = stack[-1] // @1DFC memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x1e0b, if !(stack[-5] + stack[-6] > stack[-7]) label_1E07: // Incoming jump from 0x1E06, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @1E0A memory[0x00:0x00] } 1E07 60 PUSH1 0x00 1E09 80 DUP1 1E0A FD *REVERT // Stack delta = +0 // Outputs[1] { @1E0A revert(memory[0x00:0x00]); } // Block terminates label_1E0B: // Incoming jump from 0x1E06, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @1E0C stack[-6] // @1E0D stack[-5] // @1E10 stack[-1] // @1E12 msg.data[stack[-5]:stack[-5] + stack[-6]] // @1E1F stack[-4] // @1E1F stack[-8] // @1E20 stack[-7] // } 1E0B 5B JUMPDEST 1E0C 85 DUP6 1E0D 85 DUP6 1E0E 60 PUSH1 0x20 1E10 83 DUP4 1E11 01 ADD 1E12 37 CALLDATACOPY 1E13 60 PUSH1 0x00 1E15 60 PUSH1 0x20 1E17 87 DUP8 1E18 83 DUP4 1E19 01 ADD 1E1A 01 ADD 1E1B 52 MSTORE 1E1C 50 POP 1E1D 50 POP 1E1E 50 POP 1E1F 93 SWAP4 1E20 92 SWAP3 1E21 50 POP 1E22 50 POP 1E23 50 POP 1E24 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @1E12 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @1E1B memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @1E1F stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_1E25: // Incoming call from 0x0419, returns to 0x041A // Incoming call from 0x03DF, returns to 0x03E0 // Inputs[2] // { // @1E2A stack[-1] // @1E2B stack[-2] // } 1E25 5B JUMPDEST 1E26 60 PUSH1 0x00 1E28 60 PUSH1 0x20 1E2A 82 DUP3 1E2B 84 DUP5 1E2C 03 SUB 1E2D 12 SLT 1E2E 15 ISZERO 1E2F 61 PUSH2 0x1e37 1E32 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E26 stack[0] = 0x00 } // Block ends with conditional jump to 0x1e37, if !(stack[-2] - stack[-1] i< 0x20) label_1E33: // Incoming jump from 0x1E32, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1E36 memory[0x00:0x00] } 1E33 60 PUSH1 0x00 1E35 80 DUP1 1E36 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E36 revert(memory[0x00:0x00]); } // Block terminates label_1E37: // Incoming jump from 0x1E32, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E38 stack[-2] // @1E39 msg.data[stack[-2]:stack[-2] + 0x20] // } 1E37 5B JUMPDEST 1E38 81 DUP2 1E39 35 CALLDATALOAD 1E3A 67 PUSH8 0xffffffffffffffff 1E43 81 DUP2 1E44 11 GT 1E45 15 ISZERO 1E46 61 PUSH2 0x1e4e 1E49 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E39 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1e4e, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1E4A: // Incoming jump from 0x1E49, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1E4D memory[0x00:0x00] } 1E4A 60 PUSH1 0x00 1E4C 80 DUP1 1E4D FD *REVERT // Stack delta = +0 // Outputs[1] { @1E4D revert(memory[0x00:0x00]); } // Block terminates label_1E4E: // Incoming jump from 0x1E49, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1E4F stack[-3] // @1E50 stack[-1] // @1E55 stack[-4] // } 1E4E 5B JUMPDEST 1E4F 82 DUP3 1E50 01 ADD 1E51 60 PUSH1 0x1f 1E53 81 DUP2 1E54 01 ADD 1E55 84 DUP5 1E56 13 SGT 1E57 61 PUSH2 0x1e5f 1E5A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1E50 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1e5f, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_1E5B: // Incoming jump from 0x1E5A, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // 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[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @1E63 stack[-4] // @1E64 stack[-1] // @1E65 msg.data[stack[-1]:stack[-1] + 0x20] // } 1E5F 5B JUMPDEST 1E60 61 PUSH2 0x1837 1E63 84 DUP5 1E64 82 DUP3 1E65 35 CALLDATALOAD 1E66 60 PUSH1 0x20 1E68 84 DUP5 1E69 01 ADD 1E6A 61 PUSH2 0x1daf 1E6D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E60 stack[0] = 0x1837 // @1E63 stack[1] = stack[-4] // @1E65 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1E69 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1daf, returns to 0x1837 label_1E6E: // Incoming call from 0x0462, returns to 0x0463 // Inputs[2] // { // @1E76 stack[-1] // @1E77 stack[-2] // } 1E6E 5B JUMPDEST 1E6F 60 PUSH1 0x00 1E71 80 DUP1 1E72 60 PUSH1 0x00 1E74 60 PUSH1 0x40 1E76 84 DUP5 1E77 86 DUP7 1E78 03 SUB 1E79 12 SLT 1E7A 15 ISZERO 1E7B 61 PUSH2 0x1e83 1E7E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1E6F stack[0] = 0x00 // @1E71 stack[1] = 0x00 // @1E72 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1e83, if !(stack[-2] - stack[-1] i< 0x40) label_1E7F: // Incoming jump from 0x1E7E, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1E82 memory[0x00:0x00] } 1E7F 60 PUSH1 0x00 1E81 80 DUP1 1E82 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E82 revert(memory[0x00:0x00]); } // Block terminates label_1E83: // Incoming jump from 0x1E7E, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @1E84 stack[-4] // @1E85 msg.data[stack[-4]:stack[-4] + 0x20] // @1E86 stack[-3] // @1E8C msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1E83 5B JUMPDEST 1E84 83 DUP4 1E85 35 CALLDATALOAD 1E86 92 SWAP3 1E87 50 POP 1E88 60 PUSH1 0x20 1E8A 84 DUP5 1E8B 01 ADD 1E8C 35 CALLDATALOAD 1E8D 67 PUSH8 0xffffffffffffffff 1E96 80 DUP1 1E97 82 DUP3 1E98 11 GT 1E99 15 ISZERO 1E9A 61 PUSH2 0x1ea2 1E9D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1E86 stack[-3] = msg.data[stack[-4]:stack[-4] + 0x20] // @1E8C stack[0] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @1E8D stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1ea2, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) label_1E9E: // Incoming jump from 0x1E9D, if not !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1EA1 memory[0x00:0x00] } 1E9E 60 PUSH1 0x00 1EA0 80 DUP1 1EA1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EA1 revert(memory[0x00:0x00]); } // Block terminates label_1EA2: // Incoming jump from 0x1E9D, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1EA3 stack[-2] // @1EA4 stack[-6] // @1EA8 stack[-7] // } 1EA2 5B JUMPDEST 1EA3 81 DUP2 1EA4 86 DUP7 1EA5 01 ADD 1EA6 91 SWAP2 1EA7 50 POP 1EA8 86 DUP7 1EA9 60 PUSH1 0x1f 1EAB 83 DUP4 1EAC 01 ADD 1EAD 12 SLT 1EAE 61 PUSH2 0x1eb6 1EB1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1EA6 stack[-2] = stack[-6] + stack[-2] } // Block ends with conditional jump to 0x1eb6, if stack[-6] + stack[-2] + 0x1f i< stack[-7] label_1EB2: // Incoming jump from 0x1EB1, if not stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[1] { @1EB5 memory[0x00:0x00] } 1EB2 60 PUSH1 0x00 1EB4 80 DUP1 1EB5 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EB5 revert(memory[0x00:0x00]); } // Block terminates label_1EB6: // Incoming jump from 0x1EB1, if stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[3] // { // @1EB7 stack[-2] // @1EB8 msg.data[stack[-2]:stack[-2] + 0x20] // @1EB9 stack[-1] // } 1EB6 5B JUMPDEST 1EB7 81 DUP2 1EB8 35 CALLDATALOAD 1EB9 81 DUP2 1EBA 81 DUP2 1EBB 11 GT 1EBC 15 ISZERO 1EBD 61 PUSH2 0x1ec5 1EC0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1EB8 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1ec5, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_1EC1: // Incoming jump from 0x1EC0, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @1EC4 memory[0x00:0x00] } 1EC1 60 PUSH1 0x00 1EC3 80 DUP1 1EC4 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EC4 revert(memory[0x00:0x00]); } // Block terminates label_1EC5: // Incoming jump from 0x1EC0, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @1EC6 stack[-8] // @1EC9 stack[-1] // @1ECD stack[-3] // } 1EC5 5B JUMPDEST 1EC6 87 DUP8 1EC7 60 PUSH1 0x20 1EC9 82 DUP3 1ECA 60 PUSH1 0x05 1ECC 1B SHL 1ECD 85 DUP6 1ECE 01 ADD 1ECF 01 ADD 1ED0 11 GT 1ED1 15 ISZERO 1ED2 61 PUSH2 0x1eda 1ED5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1eda, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-8]) label_1ED6: // Incoming jump from 0x1ED5, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-8]) // Inputs[1] { @1ED9 memory[0x00:0x00] } 1ED6 60 PUSH1 0x00 1ED8 80 DUP1 1ED9 FD *REVERT // Stack delta = +0 // Outputs[1] { @1ED9 revert(memory[0x00:0x00]); } // Block terminates label_1EDA: // Incoming jump from 0x1ED5, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-8]) // Inputs[8] // { // @1EDD stack[-3] // @1EDF stack[-5] // @1EE1 stack[-1] // @1EE2 stack[-4] // @1EE7 stack[-7] // @1EE9 stack[-8] // @1EEB stack[-9] // @1EEB stack[-6] // } 1EDA 5B JUMPDEST 1EDB 60 PUSH1 0x20 1EDD 83 DUP4 1EDE 01 ADD 1EDF 94 SWAP5 1EE0 50 POP 1EE1 80 DUP1 1EE2 93 SWAP4 1EE3 50 POP 1EE4 50 POP 1EE5 50 POP 1EE6 50 POP 1EE7 92 SWAP3 1EE8 50 POP 1EE9 92 SWAP3 1EEA 50 POP 1EEB 92 SWAP3 1EEC 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @1EE7 stack[-7] = stack[-1] // @1EE9 stack[-8] = stack[-3] + 0x20 // @1EEB stack[-9] = stack[-6] // } // Block ends with unconditional jump to stack[-9] label_1EED: // Incoming call from 0x05CF, returns to 0x05D0 // Inputs[2] // { // @1EF3 stack[-1] // @1EF4 stack[-2] // } 1EED 5B JUMPDEST 1EEE 60 PUSH1 0x00 1EF0 80 DUP1 1EF1 60 PUSH1 0x40 1EF3 83 DUP4 1EF4 85 DUP6 1EF5 03 SUB 1EF6 12 SLT 1EF7 15 ISZERO 1EF8 61 PUSH2 0x1f00 1EFB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1EEE stack[0] = 0x00 // @1EF0 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1f00, if !(stack[-2] - stack[-1] i< 0x40) label_1EFC: // Incoming jump from 0x1EFB, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1EFF memory[0x00:0x00] } 1EFC 60 PUSH1 0x00 1EFE 80 DUP1 1EFF FD *REVERT // Stack delta = +0 // Outputs[1] { @1EFF revert(memory[0x00:0x00]); } // Block terminates label_1F00: // Incoming jump from 0x1EFB, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1F04 stack[-3] } 1F00 5B JUMPDEST 1F01 61 PUSH2 0x1f09 1F04 83 DUP4 1F05 61 PUSH2 0x1cfc 1F08 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F01 stack[0] = 0x1f09 // @1F04 stack[1] = stack[-3] // } // Block ends with call to 0x1cfc, returns to 0x1F09 label_1F09: // Incoming return from call to 0x1CFC at 0x1F08 // Inputs[4] // { // @1F0A stack[-1] // @1F0A stack[-3] // @1F0E stack[-4] // @1F10 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1F09 5B JUMPDEST 1F0A 91 SWAP2 1F0B 50 POP 1F0C 60 PUSH1 0x20 1F0E 83 DUP4 1F0F 01 ADD 1F10 35 CALLDATALOAD 1F11 80 DUP1 1F12 15 ISZERO 1F13 15 ISZERO 1F14 81 DUP2 1F15 14 EQ 1F16 61 PUSH2 0x1f1e 1F19 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1F0A stack[-3] = stack[-1] // @1F10 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1f1e, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_1F1A: // Incoming jump from 0x1F19, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // 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 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @1F1F stack[-1] // @1F20 stack[-2] // @1F23 stack[-5] // @1F25 stack[-3] // @1F25 stack[-6] // @1F26 stack[-4] // } 1F1E 5B JUMPDEST 1F1F 80 DUP1 1F20 91 SWAP2 1F21 50 POP 1F22 50 POP 1F23 92 SWAP3 1F24 50 POP 1F25 92 SWAP3 1F26 90 SWAP1 1F27 50 POP 1F28 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1F23 stack[-5] = stack[-1] // @1F25 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1F29: // Incoming call from 0x05EF, returns to 0x05F0 // Inputs[2] // { // @1F32 stack[-1] // @1F33 stack[-2] // } 1F29 5B JUMPDEST 1F2A 60 PUSH1 0x00 1F2C 80 DUP1 1F2D 60 PUSH1 0x00 1F2F 80 DUP1 1F30 60 PUSH1 0x80 1F32 85 DUP6 1F33 87 DUP8 1F34 03 SUB 1F35 12 SLT 1F36 15 ISZERO 1F37 61 PUSH2 0x1f3f 1F3A 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1F2A stack[0] = 0x00 // @1F2C stack[1] = 0x00 // @1F2D stack[2] = 0x00 // @1F2F stack[3] = 0x00 // } // Block ends with conditional jump to 0x1f3f, if !(stack[-2] - stack[-1] i< 0x80) label_1F3B: // Incoming jump from 0x1F3A, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1F3E memory[0x00:0x00] } 1F3B 60 PUSH1 0x00 1F3D 80 DUP1 1F3E FD *REVERT // Stack delta = +0 // Outputs[1] { @1F3E revert(memory[0x00:0x00]); } // Block terminates label_1F3F: // Incoming jump from 0x1F3A, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1F43 stack[-5] } 1F3F 5B JUMPDEST 1F40 61 PUSH2 0x1f48 1F43 85 DUP6 1F44 61 PUSH2 0x1cfc 1F47 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F40 stack[0] = 0x1f48 // @1F43 stack[1] = stack[-5] // } // Block ends with call to 0x1cfc, returns to 0x1F48 label_1F48: // Incoming return from call to 0x1CFC at 0x1F47 // Inputs[3] // { // @1F49 stack[-5] // @1F49 stack[-1] // @1F50 stack[-6] // } 1F48 5B JUMPDEST 1F49 93 SWAP4 1F4A 50 POP 1F4B 61 PUSH2 0x1f56 1F4E 60 PUSH1 0x20 1F50 86 DUP7 1F51 01 ADD 1F52 61 PUSH2 0x1cfc 1F55 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1F49 stack[-5] = stack[-1] // @1F4B stack[-1] = 0x1f56 // @1F51 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x1cfc, returns to 0x1F56 label_1F56: // Incoming return from call to 0x1CFC at 0x1F55 // Inputs[6] // { // @1F57 stack[-1] // @1F57 stack[-4] // @1F5B stack[-6] // @1F5D msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1F5E stack[-3] // @1F64 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 1F56 5B JUMPDEST 1F57 92 SWAP3 1F58 50 POP 1F59 60 PUSH1 0x40 1F5B 85 DUP6 1F5C 01 ADD 1F5D 35 CALLDATALOAD 1F5E 91 SWAP2 1F5F 50 POP 1F60 60 PUSH1 0x60 1F62 85 DUP6 1F63 01 ADD 1F64 35 CALLDATALOAD 1F65 67 PUSH8 0xffffffffffffffff 1F6E 81 DUP2 1F6F 11 GT 1F70 15 ISZERO 1F71 61 PUSH2 0x1f79 1F74 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1F57 stack[-4] = stack[-1] // @1F5E stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1F64 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x1f79, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_1F75: // Incoming jump from 0x1F74, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1F78 memory[0x00:0x00] } 1F75 60 PUSH1 0x00 1F77 80 DUP1 1F78 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F78 revert(memory[0x00:0x00]); } // Block terminates label_1F79: // Incoming jump from 0x1F74, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1F7A stack[-6] // @1F7B stack[-1] // @1F80 stack[-7] // } 1F79 5B JUMPDEST 1F7A 85 DUP6 1F7B 01 ADD 1F7C 60 PUSH1 0x1f 1F7E 81 DUP2 1F7F 01 ADD 1F80 87 DUP8 1F81 13 SGT 1F82 61 PUSH2 0x1f8a 1F85 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1F7B stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x1f8a, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_1F86: // Incoming jump from 0x1F85, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @1F89 memory[0x00:0x00] } 1F86 60 PUSH1 0x00 1F88 80 DUP1 1F89 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F89 revert(memory[0x00:0x00]); } // Block terminates label_1F8A: // Incoming jump from 0x1F85, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @1F8E stack[-7] // @1F8F stack[-1] // @1F90 msg.data[stack[-1]:stack[-1] + 0x20] // } 1F8A 5B JUMPDEST 1F8B 61 PUSH2 0x1f99 1F8E 87 DUP8 1F8F 82 DUP3 1F90 35 CALLDATALOAD 1F91 60 PUSH1 0x20 1F93 84 DUP5 1F94 01 ADD 1F95 61 PUSH2 0x1daf 1F98 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F8B stack[0] = 0x1f99 // @1F8E stack[1] = stack[-7] // @1F90 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1F94 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1daf, returns to 0x1F99 label_1F99: // Incoming return from call to 0x1DAF at 0x1F98 // Inputs[8] // { // @1F9A stack[-3] // @1F9A stack[-1] // @1F9D stack[-6] // @1F9E stack[-9] // @1F9F stack[-5] // @1FA0 stack[-8] // @1FA2 stack[-7] // @1FA2 stack[-4] // } 1F99 5B JUMPDEST 1F9A 91 SWAP2 1F9B 50 POP 1F9C 50 POP 1F9D 92 SWAP3 1F9E 95 SWAP6 1F9F 91 SWAP2 1FA0 94 SWAP5 1FA1 50 POP 1FA2 92 SWAP3 1FA3 50 POP 1FA4 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @1F9D stack[-6] = stack[-1] // @1F9E stack[-9] = stack[-6] // @1FA0 stack[-8] = stack[-5] // @1FA2 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_1FA5: // Incoming call from 0x0644, returns to 0x0645 // Inputs[2] // { // @1FAB stack[-1] // @1FAC stack[-2] // } 1FA5 5B JUMPDEST 1FA6 60 PUSH1 0x00 1FA8 80 DUP1 1FA9 60 PUSH1 0x40 1FAB 83 DUP4 1FAC 85 DUP6 1FAD 03 SUB 1FAE 12 SLT 1FAF 15 ISZERO 1FB0 61 PUSH2 0x1fb8 1FB3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1FA6 stack[0] = 0x00 // @1FA8 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1fb8, if !(stack[-2] - stack[-1] i< 0x40) label_1FB4: // Incoming jump from 0x1FB3, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1FB7 memory[0x00:0x00] } 1FB4 60 PUSH1 0x00 1FB6 80 DUP1 1FB7 FD *REVERT // Stack delta = +0 // Outputs[1] { @1FB7 revert(memory[0x00:0x00]); } // Block terminates label_1FB8: // Incoming jump from 0x1FB3, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1FBC stack[-3] } 1FB8 5B JUMPDEST 1FB9 61 PUSH2 0x1fc1 1FBC 83 DUP4 1FBD 61 PUSH2 0x1cfc 1FC0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1FB9 stack[0] = 0x1fc1 // @1FBC stack[1] = stack[-3] // } // Block ends with call to 0x1cfc, returns to 0x1FC1 label_1FC1: // Incoming return from call to 0x1CFC at 0x1FC0 // Inputs[3] // { // @1FC2 stack[-1] // @1FC2 stack[-3] // @1FC9 stack[-4] // } 1FC1 5B JUMPDEST 1FC2 91 SWAP2 1FC3 50 POP 1FC4 61 PUSH2 0x1fcf 1FC7 60 PUSH1 0x20 1FC9 84 DUP5 1FCA 01 ADD 1FCB 61 PUSH2 0x1cfc 1FCE 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1FC2 stack[-3] = stack[-1] // @1FC4 stack[-1] = 0x1fcf // @1FCA stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1cfc, returns to 0x1FCF label_1FCF: // Incoming return from call to 0x1CFC at 0x1FCE // Inputs[6] // { // @1FD0 stack[-1] // @1FD0 stack[-2] // @1FD2 stack[-5] // @1FD4 stack[-3] // @1FD4 stack[-6] // @1FD5 stack[-4] // } 1FCF 5B JUMPDEST 1FD0 90 SWAP1 1FD1 50 POP 1FD2 92 SWAP3 1FD3 50 POP 1FD4 92 SWAP3 1FD5 90 SWAP1 1FD6 50 POP 1FD7 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1FD2 stack[-5] = stack[-1] // @1FD4 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1FD8: // Incoming call from 0x0855, returns to 0x0856 // Incoming call from 0x1177, returns to 0x1178 // Incoming call from 0x06F3, returns to 0x06F4 // Incoming call from 0x0881, returns to 0x0882 // Incoming call from 0x1BB0, returns to 0x1BB1 // Incoming call from 0x114B, returns to 0x114C // Incoming call from 0x071F, returns to 0x0720 // Incoming call from 0x0DB8, returns to 0x06F4 // Inputs[1] { @1FDB stack[-1] } 1FD8 5B JUMPDEST 1FD9 60 PUSH1 0x01 1FDB 81 DUP2 1FDC 81 DUP2 1FDD 1C SHR 1FDE 90 SWAP1 1FDF 82 DUP3 1FE0 16 AND 1FE1 80 DUP1 1FE2 61 PUSH2 0x1fec 1FE5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1FDE stack[0] = stack[-1] >> 0x01 // @1FE0 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x1fec, if stack[-1] & 0x01 label_1FE6: // Incoming jump from 0x1FE5, if not stack[-1] & 0x01 // Inputs[2] // { // @1FE8 stack[-2] // @1FF1 stack[-1] // } 1FE6 60 PUSH1 0x7f 1FE8 82 DUP3 1FE9 16 AND 1FEA 91 SWAP2 1FEB 50 POP 1FEC 5B JUMPDEST 1FED 60 PUSH1 0x20 1FEF 82 DUP3 1FF0 10 LT 1FF1 81 DUP2 1FF2 14 EQ 1FF3 15 ISZERO 1FF4 61 PUSH2 0x200d 1FF7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1FEA stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x200d, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_1FF8: // Incoming jump from 0x1FF7, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x1FF7, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @200C memory[0x00:0x24] } 1FF8 63 PUSH4 0x4e487b71 1FFD 60 PUSH1 0xe0 1FFF 1B SHL 2000 60 PUSH1 0x00 2002 52 MSTORE 2003 60 PUSH1 0x22 2005 60 PUSH1 0x04 2007 52 MSTORE 2008 60 PUSH1 0x24 200A 60 PUSH1 0x00 200C FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2002 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2007 memory[0x04:0x24] = 0x22 // @200C revert(memory[0x00:0x24]); // } // Block terminates label_200D: // Incoming jump from 0x1FF7, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x1FF7, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @200F stack[-2] // @200F stack[-4] // @2010 stack[-3] // } 200D 5B JUMPDEST 200E 50 POP 200F 91 SWAP2 2010 90 SWAP1 2011 50 POP 2012 56 *JUMP // Stack delta = -3 // Outputs[1] { @200F stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2013: // Incoming call from 0x0CC4, returns to 0x090C // Incoming call from 0x0988, returns to 0x090C // Incoming call from 0x0D41, returns to 0x090C // Incoming call from 0x1238, returns to 0x090C // Incoming call from 0x0DA4, returns to 0x090C // Incoming call from 0x0CFA, returns to 0x090C // Incoming call from 0x09C9, returns to 0x090C // Incoming call from 0x11FA, returns to 0x090C // Incoming call from 0x090B, returns to 0x090C // Incoming call from 0x0D75, returns to 0x090C // Inputs[2] // { // @2017 stack[-1] // @2046 stack[-2] // } 2013 5B JUMPDEST 2014 60 PUSH1 0x20 2016 80 DUP1 2017 82 DUP3 2018 52 MSTORE 2019 81 DUP2 201A 81 DUP2 201B 01 ADD 201C 52 MSTORE 201D 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 203E 60 PUSH1 0x40 2040 82 DUP3 2041 01 ADD 2042 52 MSTORE 2043 60 PUSH1 0x60 2045 01 ADD 2046 90 SWAP1 2047 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2018 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @201C memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @2042 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @2046 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2048: // Incoming jump from 0x20A6 // Incoming jump from 0x21E6 // Incoming jump from 0x2087 // Incoming jump from 0x2070 // Inputs[1] { @205D memory[0x00:0x24] } 2048 5B JUMPDEST 2049 63 PUSH4 0x4e487b71 204E 60 PUSH1 0xe0 2050 1B SHL 2051 60 PUSH1 0x00 2053 52 MSTORE 2054 60 PUSH1 0x11 2056 60 PUSH1 0x04 2058 52 MSTORE 2059 60 PUSH1 0x24 205B 60 PUSH1 0x00 205D FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2053 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2058 memory[0x04:0x24] = 0x11 // @205D revert(memory[0x00:0x24]); // } // Block terminates label_205E: // Incoming call from 0x0AB8, returns to 0x0AB9 // Incoming call from 0x18FE, returns to 0x18FF // Incoming call from 0x0C35, returns to 0x0C36 // Incoming call from 0x0E79, returns to 0x0E7A // Incoming call from 0x0F9E, returns to 0x0F9F // Inputs[2] // { // @2061 stack[-2] // @2063 stack[-1] // } 205E 5B JUMPDEST 205F 60 PUSH1 0x00 2061 82 DUP3 2062 19 NOT 2063 82 DUP3 2064 11 GT 2065 15 ISZERO 2066 61 PUSH2 0x2071 2069 57 *JUMPI // Stack delta = +1 // Outputs[1] { @205F stack[0] = 0x00 } // Block ends with conditional jump to 0x2071, if !(stack[-1] > ~stack[-2]) label_206A: // Incoming jump from 0x2069, if not !(stack[-1] > ~stack[-2]) 206A 61 PUSH2 0x2071 206D 61 PUSH2 0x2048 2070 56 *JUMP // Stack delta = +1 // Outputs[1] { @206A stack[0] = 0x2071 } // Block ends with unconditional jump to 0x2048 label_2071: // Incoming jump from 0x2069, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @2073 stack[-2] // @2073 stack[-3] // @2074 stack[-4] // } 2071 5B JUMPDEST 2072 50 POP 2073 01 ADD 2074 90 SWAP1 2075 56 *JUMP // Stack delta = -3 // Outputs[1] { @2074 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_2076: // Incoming call from 0x0ED9, returns to 0x0EDA // Incoming call from 0x18E6, returns to 0x18E7 // Incoming call from 0x0B21, returns to 0x0B22 // Inputs[2] // { // @2079 stack[-2] // @207A stack[-1] // } 2076 5B JUMPDEST 2077 60 PUSH1 0x00 2079 82 DUP3 207A 82 DUP3 207B 10 LT 207C 15 ISZERO 207D 61 PUSH2 0x2088 2080 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2077 stack[0] = 0x00 } // Block ends with conditional jump to 0x2088, if !(stack[-1] < stack[-2]) label_2081: // Incoming jump from 0x2080, if not !(stack[-1] < stack[-2]) 2081 61 PUSH2 0x2088 2084 61 PUSH2 0x2048 2087 56 *JUMP // Stack delta = +1 // Outputs[1] { @2081 stack[0] = 0x2088 } // Block ends with unconditional jump to 0x2048 label_2088: // Incoming jump from 0x2080, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @208A stack[-3] // @208A stack[-2] // @208B stack[-4] // } 2088 5B JUMPDEST 2089 50 POP 208A 03 SUB 208B 90 SWAP1 208C 56 *JUMP // Stack delta = -3 // Outputs[1] { @208B stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_208D: // Incoming call from 0x0F30, returns to 0x0F31 // Incoming call from 0x0BBF, returns to 0x0BC0 // Inputs[2] // { // @2090 stack[-1] // @2095 stack[-2] // } 208D 5B JUMPDEST 208E 60 PUSH1 0x00 2090 81 DUP2 2091 60 PUSH1 0x00 2093 19 NOT 2094 04 DIV 2095 83 DUP4 2096 11 GT 2097 82 DUP3 2098 15 ISZERO 2099 15 ISZERO 209A 16 AND 209B 15 ISZERO 209C 61 PUSH2 0x20a7 209F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @208E stack[0] = 0x00 } // Block ends with conditional jump to 0x20a7, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_20A0: // Incoming jump from 0x209F, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 20A0 61 PUSH2 0x20a7 20A3 61 PUSH2 0x2048 20A6 56 *JUMP // Stack delta = +1 // Outputs[1] { @20A0 stack[0] = 0x20a7 } // Block ends with unconditional jump to 0x2048 label_20A7: // Incoming jump from 0x209F, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @20A9 stack[-2] // @20A9 stack[-3] // @20AA stack[-4] // } 20A7 5B JUMPDEST 20A8 50 POP 20A9 02 MUL 20AA 90 SWAP1 20AB 56 *JUMP // Stack delta = -3 // Outputs[1] { @20AA stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_20AC: // Incoming call from 0x2151, returns to 0x2152 // Incoming call from 0x216D, returns to 0x216E // Inputs[2] // { // @20AD stack[-1] // @20AE storage[stack[-1]] // } 20AC 5B JUMPDEST 20AD 80 DUP1 20AE 54 SLOAD 20AF 60 PUSH1 0x00 20B1 90 SWAP1 20B2 60 PUSH1 0x01 20B4 81 DUP2 20B5 81 DUP2 20B6 1C SHR 20B7 90 SWAP1 20B8 80 DUP1 20B9 83 DUP4 20BA 16 AND 20BB 80 DUP1 20BC 61 PUSH2 0x20c6 20BF 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @20B1 stack[0] = 0x00 // @20B1 stack[1] = storage[stack[-1]] // @20B7 stack[2] = storage[stack[-1]] >> 0x01 // @20B7 stack[3] = 0x01 // @20BA stack[4] = storage[stack[-1]] & 0x01 // } // Block ends with conditional jump to 0x20c6, if storage[stack[-1]] & 0x01 label_20C0: // Incoming jump from 0x20BF, if not storage[stack[-1]] & 0x01 // Inputs[2] // { // @20C2 stack[-3] // @20CC stack[-1] // } 20C0 60 PUSH1 0x7f 20C2 83 DUP4 20C3 16 AND 20C4 92 SWAP3 20C5 50 POP 20C6 5B JUMPDEST 20C7 60 PUSH1 0x20 20C9 80 DUP1 20CA 84 DUP5 20CB 10 LT 20CC 82 DUP3 20CD 14 EQ 20CE 15 ISZERO 20CF 61 PUSH2 0x20e8 20D2 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @20C4 stack[-3] = stack[-3] & 0x7f // @20C7 stack[0] = 0x20 // } // Block ends with conditional jump to 0x20e8, if !(stack[-1] == (stack[-3] & 0x7f < 0x20)) label_20D3: // Incoming jump from 0x20D2, if not !(stack[-1] == (stack[-3] & 0x7f < 0x20)) // Incoming jump from 0x20D2, if not !(stack[-1] == (stack[-3] < 0x20)) // Inputs[1] { @20E7 memory[0x00:0x24] } 20D3 63 PUSH4 0x4e487b71 20D8 60 PUSH1 0xe0 20DA 1B SHL 20DB 60 PUSH1 0x00 20DD 52 MSTORE 20DE 60 PUSH1 0x22 20E0 60 PUSH1 0x04 20E2 52 MSTORE 20E3 60 PUSH1 0x24 20E5 60 PUSH1 0x00 20E7 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @20DD memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @20E2 memory[0x04:0x24] = 0x22 // @20E7 revert(memory[0x00:0x24]); // } // Block terminates label_20E8: // Incoming jump from 0x20D2, if !(stack[-1] == (stack[-3] & 0x7f < 0x20)) // Incoming jump from 0x20D2, if !(stack[-1] == (stack[-3] < 0x20)) // Inputs[1] { @20E9 stack[-2] } 20E8 5B JUMPDEST 20E9 81 DUP2 20EA 80 DUP1 20EB 15 ISZERO 20EC 61 PUSH2 0x20fc 20EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20E9 stack[0] = stack[-2] } // Block ends with conditional jump to 0x20fc, if !stack[-2] label_20F0: // Incoming jump from 0x20EF, if not !stack[-2] // Inputs[1] { @20F2 stack[-1] } 20F0 60 PUSH1 0x01 20F2 81 DUP2 20F3 14 EQ 20F4 61 PUSH2 0x210d 20F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x210d, if stack[-1] == 0x01 label_20F8: // Incoming jump from 0x20F7, if not stack[-1] == 0x01 20F8 61 PUSH2 0x213a 20FB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x213a label_20FC: // Incoming jump from 0x20EF, if !stack[-2] // Inputs[4] // { // @2100 stack[-6] // @2102 stack[-9] // @2104 stack[-5] // @2107 stack[-7] // } 20FC 5B JUMPDEST 20FD 60 PUSH1 0xff 20FF 19 NOT 2100 86 DUP7 2101 16 AND 2102 89 DUP10 2103 52 MSTORE 2104 84 DUP5 2105 89 DUP10 2106 01 ADD 2107 96 SWAP7 2108 50 POP 2109 61 PUSH2 0x213a 210C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2103 memory[stack[-9]:stack[-9] + 0x20] = stack[-6] & ~0xff // @2107 stack[-7] = stack[-9] + stack[-5] // } // Block ends with unconditional jump to 0x213a label_210D: // Incoming jump from 0x20F7, if stack[-1] == 0x01 // Inputs[3] // { // @2110 stack[-8] // @2116 memory[0x00:0x20] // @211A stack[-5] // } 210D 5B JUMPDEST 210E 60 PUSH1 0x00 2110 88 DUP9 2111 81 DUP2 2112 52 MSTORE 2113 60 PUSH1 0x20 2115 90 SWAP1 2116 20 SHA3 2117 60 PUSH1 0x00 2119 5B JUMPDEST 211A 86 DUP7 211B 81 DUP2 211C 10 LT 211D 15 ISZERO 211E 61 PUSH2 0x2132 2121 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2112 memory[0x00:0x20] = stack[-8] // @2116 stack[0] = keccak256(memory[0x00:0x20]) // @2117 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2132, if !(0x00 < stack[-5]) label_2122: // Incoming jump from 0x2121, if not !(0x00 < stack[-5]) // Incoming jump from 0x2121, if not !(stack[-1] < stack[-7]) // Inputs[6] // { // @2122 stack[-2] // @2123 storage[stack[-2]] // @2124 stack[-11] // @2125 stack[-1] // @2129 stack[-6] // @212C stack[-4] // } 2122 81 DUP2 2123 54 SLOAD 2124 8B DUP12 2125 82 DUP3 2126 01 ADD 2127 52 MSTORE 2128 90 SWAP1 2129 85 DUP6 212A 01 ADD 212B 90 SWAP1 212C 83 DUP4 212D 01 ADD 212E 61 PUSH2 0x2119 2131 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2127 memory[stack[-1] + stack[-11]:stack[-1] + stack[-11] + 0x20] = storage[stack[-2]] // @212B stack[-2] = stack[-6] + stack[-2] // @212D stack[-1] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x2119 label_2132: // Incoming jump from 0x2121, if !(0x00 < stack[-5]) // Incoming jump from 0x2121, if !(stack[-1] < stack[-7]) // Inputs[3] // { // @2135 stack[-7] // @2136 stack[-11] // @2138 stack[-9] // } 2132 5B JUMPDEST 2133 50 POP 2134 50 POP 2135 84 DUP5 2136 89 DUP10 2137 01 ADD 2138 96 SWAP7 2139 50 POP // Stack delta = -2 // Outputs[1] { @2138 stack[-9] = stack[-11] + stack[-7] } // Block continues label_213A: // Incoming jump from 0x210C // Incoming jump from 0x20FB // Incoming jump from 0x2139 // Inputs[3] // { // @2141 stack[-10] // @2141 stack[-7] // @2142 stack[-9] // } 213A 5B JUMPDEST 213B 50 POP 213C 50 POP 213D 50 POP 213E 50 POP 213F 50 POP 2140 50 POP 2141 92 SWAP3 2142 91 SWAP2 2143 50 POP 2144 50 POP 2145 56 *JUMP // Stack delta = -9 // Outputs[1] { @2141 stack[-10] = stack[-7] } // Block ends with unconditional jump to stack[-10] label_2146: // Incoming call from 0x1128, returns to 0x1129 // Inputs[2] // { // @214C stack[-1] // @214D stack[-4] // } 2146 5B JUMPDEST 2147 60 PUSH1 0x00 2149 61 PUSH2 0x2152 214C 82 DUP3 214D 86 DUP7 214E 61 PUSH2 0x20ac 2151 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2147 stack[0] = 0x00 // @2149 stack[1] = 0x2152 // @214C stack[2] = stack[-1] // @214D stack[3] = stack[-4] // } // Block ends with call to 0x20ac, returns to 0x2152 label_2152: // Incoming return from call to 0x20AC at 0x2151 // Inputs[3] // { // @2153 stack[-5] // @2154 memory[stack[-5]:stack[-5] + 0x20] // @2159 stack[-1] // } 2152 5B JUMPDEST 2153 84 DUP5 2154 51 MLOAD 2155 61 PUSH2 0x2162 2158 81 DUP2 2159 83 DUP4 215A 60 PUSH1 0x20 215C 89 DUP10 215D 01 ADD 215E 61 PUSH2 0x1c78 2161 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2154 stack[0] = memory[stack[-5]:stack[-5] + 0x20] // @2155 stack[1] = 0x2162 // @2158 stack[2] = memory[stack[-5]:stack[-5] + 0x20] // @2159 stack[3] = stack[-1] // @215D stack[4] = stack[-5] + 0x20 // } // Block ends with call to 0x1c78, returns to 0x2162 label_2162: // Incoming return from call to 0x1C78 at 0x2161 // Inputs[3] // { // @2166 stack[-1] // @2167 stack[-2] // @2169 stack[-5] // } 2162 5B JUMPDEST 2163 61 PUSH2 0x216e 2166 81 DUP2 2167 83 DUP4 2168 01 ADD 2169 86 DUP7 216A 61 PUSH2 0x20ac 216D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2163 stack[0] = 0x216e // @2168 stack[1] = stack[-2] + stack[-1] // @2169 stack[2] = stack[-5] // } // Block ends with call to 0x20ac, returns to 0x216E label_216E: // Incoming return from call to 0x20AC at 0x216D // Inputs[3] // { // @216F stack[-1] // @216F stack[-9] // @2170 stack[-8] // } 216E 5B JUMPDEST 216F 97 SWAP8 2170 96 SWAP7 2171 50 POP 2172 50 POP 2173 50 POP 2174 50 POP 2175 50 POP 2176 50 POP 2177 50 POP 2178 56 *JUMP // Stack delta = -8 // Outputs[1] { @216F stack[-9] = stack[-1] } // Block ends with unconditional jump to stack[-9] label_2179: // Incoming call from 0x177B, returns to 0x177C // Inputs[5] // { // @2182 stack[-5] // @2185 stack[-1] // @2187 stack[-4] // @2192 stack[-3] // @21A7 stack[-2] // } 2179 5B JUMPDEST 217A 60 PUSH1 0x01 217C 60 PUSH1 0x01 217E 60 PUSH1 0xa0 2180 1B SHL 2181 03 SUB 2182 85 DUP6 2183 81 DUP2 2184 16 AND 2185 82 DUP3 2186 52 MSTORE 2187 84 DUP5 2188 16 AND 2189 60 PUSH1 0x20 218B 82 DUP3 218C 01 ADD 218D 52 MSTORE 218E 60 PUSH1 0x40 2190 81 DUP2 2191 01 ADD 2192 83 DUP4 2193 90 SWAP1 2194 52 MSTORE 2195 60 PUSH1 0x80 2197 60 PUSH1 0x60 2199 82 DUP3 219A 01 ADD 219B 81 DUP2 219C 90 SWAP1 219D 52 MSTORE 219E 60 PUSH1 0x00 21A0 90 SWAP1 21A1 61 PUSH2 0x21ac 21A4 90 SWAP1 21A5 83 DUP4 21A6 01 ADD 21A7 84 DUP5 21A8 61 PUSH2 0x1ca4 21AB 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @2186 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @218D memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2194 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @219D memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @21A0 stack[0] = 0x00 // @21A4 stack[1] = 0x21ac // @21A6 stack[2] = stack[-1] + 0x80 // @21A7 stack[3] = stack[-2] // } // Block ends with call to 0x1ca4, returns to 0x21AC label_21AC: // Incoming return from call to 0x1CA4 at 0x21AB // Inputs[3] // { // @21AD stack[-8] // @21AD stack[-1] // @21AE stack[-7] // } 21AC 5B JUMPDEST 21AD 96 SWAP7 21AE 95 SWAP6 21AF 50 POP 21B0 50 POP 21B1 50 POP 21B2 50 POP 21B3 50 POP 21B4 50 POP 21B5 56 *JUMP // Stack delta = -7 // Outputs[1] { @21AD stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_21B6: // Incoming jump from 0x17C2 // Inputs[2] // { // @21BB stack[-1] // @21BC stack[-2] // } 21B6 5B JUMPDEST 21B7 60 PUSH1 0x00 21B9 60 PUSH1 0x20 21BB 82 DUP3 21BC 84 DUP5 21BD 03 SUB 21BE 12 SLT 21BF 15 ISZERO 21C0 61 PUSH2 0x21c8 21C3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @21B7 stack[0] = 0x00 } // Block ends with conditional jump to 0x21c8, if !(stack[-2] - stack[-1] i< 0x20) label_21C4: // Incoming jump from 0x21C3, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @21C7 memory[0x00:0x00] } 21C4 60 PUSH1 0x00 21C6 80 DUP1 21C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @21C7 revert(memory[0x00:0x00]); } // Block terminates label_21C8: // Incoming jump from 0x21C3, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @21C9 stack[-2] // @21CA memory[stack[-2]:stack[-2] + 0x20] // } 21C8 5B JUMPDEST 21C9 81 DUP2 21CA 51 MLOAD 21CB 61 PUSH2 0x1c71 21CE 81 DUP2 21CF 61 PUSH2 0x1c3e 21D2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @21CA stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @21CB stack[1] = 0x1c71 // @21CE stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1c3e, returns to 0x1C71 label_21D3: // Incoming call from 0x1876, returns to 0x1877 // Incoming call from 0x19C3, returns to 0x19C4 // Incoming call from 0x19C3, returns to 0x19C4 // Inputs[1] { @21D9 stack[-1] } 21D3 5B JUMPDEST 21D4 60 PUSH1 0x00 21D6 60 PUSH1 0x00 21D8 19 NOT 21D9 82 DUP3 21DA 14 EQ 21DB 15 ISZERO 21DC 61 PUSH2 0x21e7 21DF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @21D4 stack[0] = 0x00 } // Block ends with conditional jump to 0x21e7, if !(stack[-1] == ~0x00) label_21E0: // Incoming jump from 0x21DF, if not !(stack[-1] == ~0x00) 21E0 61 PUSH2 0x21e7 21E3 61 PUSH2 0x2048 21E6 56 *JUMP // Stack delta = +1 // Outputs[1] { @21E0 stack[0] = 0x21e7 } // Block ends with unconditional jump to 0x2048 label_21E7: // Incoming jump from 0x21DF, if !(stack[-1] == ~0x00) // Inputs[2] // { // @21EB stack[-2] // @21EC stack[-3] // } 21E7 5B JUMPDEST 21E8 50 POP 21E9 60 PUSH1 0x01 21EB 01 ADD 21EC 90 SWAP1 21ED 56 *JUMP // Stack delta = -2 // Outputs[1] { @21EC stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_21EE: // Incoming jump from 0x2212 // Incoming jump from 0x2226 // Inputs[1] { @2203 memory[0x00:0x24] } 21EE 5B JUMPDEST 21EF 63 PUSH4 0x4e487b71 21F4 60 PUSH1 0xe0 21F6 1B SHL 21F7 60 PUSH1 0x00 21F9 52 MSTORE 21FA 60 PUSH1 0x12 21FC 60 PUSH1 0x04 21FE 52 MSTORE 21FF 60 PUSH1 0x24 2201 60 PUSH1 0x00 2203 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @21F9 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @21FE memory[0x04:0x24] = 0x12 // @2203 revert(memory[0x00:0x24]); // } // Block terminates label_2204: // Incoming call from 0x1885, returns to 0x1886 // Incoming call from 0x1935, returns to 0x1936 // Inputs[1] { @2207 stack[-2] } 2204 5B JUMPDEST 2205 60 PUSH1 0x00 2207 82 DUP3 2208 61 PUSH2 0x2213 220B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2205 stack[0] = 0x00 } // Block ends with conditional jump to 0x2213, if stack[-2] label_220C: // Incoming jump from 0x220B, if not stack[-2] 220C 61 PUSH2 0x2213 220F 61 PUSH2 0x21ee 2212 56 *JUMP // Stack delta = +1 // Outputs[1] { @220C stack[0] = 0x2213 } // Block ends with unconditional jump to 0x21ee label_2213: // Incoming jump from 0x220B, if stack[-2] // Inputs[3] // { // @2215 stack[-3] // @2215 stack[-2] // @2216 stack[-4] // } 2213 5B JUMPDEST 2214 50 POP 2215 04 DIV 2216 90 SWAP1 2217 56 *JUMP // Stack delta = -3 // Outputs[1] { @2216 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_2218: // Incoming call from 0x18F3, returns to 0x18F4 // Inputs[1] { @221B stack[-2] } 2218 5B JUMPDEST 2219 60 PUSH1 0x00 221B 82 DUP3 221C 61 PUSH2 0x2227 221F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2219 stack[0] = 0x00 } // Block ends with conditional jump to 0x2227, if stack[-2] label_2220: // Incoming jump from 0x221F, if not stack[-2] 2220 61 PUSH2 0x2227 2223 61 PUSH2 0x21ee 2226 56 *JUMP // Stack delta = +1 // Outputs[1] { @2220 stack[0] = 0x2227 } // Block ends with unconditional jump to 0x21ee label_2227: // Incoming jump from 0x221F, if stack[-2] // Inputs[3] // { // @2229 stack[-2] // @2229 stack[-3] // @222A stack[-4] // } 2227 5B JUMPDEST 2228 50 POP 2229 06 MOD 222A 90 SWAP1 222B 56 *JUMP // Stack delta = -3 // Outputs[1] { @222A stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_222C: // Incoming jump from 0x1913 // Incoming jump from 0x1981 // Inputs[1] { @2241 memory[0x00:0x24] } 222C 5B JUMPDEST 222D 63 PUSH4 0x4e487b71 2232 60 PUSH1 0xe0 2234 1B SHL 2235 60 PUSH1 0x00 2237 52 MSTORE 2238 60 PUSH1 0x32 223A 60 PUSH1 0x04 223C 52 MSTORE 223D 60 PUSH1 0x24 223F 60 PUSH1 0x00 2241 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2237 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @223C memory[0x04:0x24] = 0x32 // @2241 revert(memory[0x00:0x24]); // } // Block terminates 2242 FE *ASSERT 2243 A2 LOG2 2244 64 PUSH5 0x6970667358 224A 22 22 224B 12 SLT 224C 20 SHA3 224D B9 B9 224E B5 B5 224F 7D PUSH30 0x0a5cd86cd45b9e22c88d135929ee9fd47e078832e30bd0df40bfd3efed64 226E 73 PUSH20 0x6f6c63430008090033