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 0x01ed 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x01ed, 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 0x6352211e 0019 11 GT 001A 61 PUSH2 0x010d 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x010d, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x6352211e > 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 0xc87b56dd 002F 11 GT 0030 61 PUSH2 0x006f 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xc87b56dd > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xc87b56dd > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xc87b56dd 003A 14 EQ 003B 61 PUSH2 0x0574 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0574, if 0xc87b56dd == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xc87b56dd == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe8a3d485 0045 14 EQ 0046 61 PUSH2 0x0594 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0594, if 0xe8a3d485 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe8a3d485 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe985e9c5 0050 14 EQ 0051 61 PUSH2 0x05a9 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a9, if 0xe985e9c5 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x05f2 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f2, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xff580055 0066 14 EQ 0067 61 PUSH2 0x0612 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0612, if 0xff580055 == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xff580055 == stack[-1] 006B 61 PUSH2 0x01ed 006E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01ed label_006F: // Incoming jump from 0x0033, if 0xc87b56dd > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0x95d89b41 0076 14 EQ 0077 61 PUSH2 0x0509 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0509, 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 0x9b6860c8 0081 14 EQ 0082 61 PUSH2 0x051e 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x051e, if 0x9b6860c8 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0x9b6860c8 == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xa22cb465 008C 14 EQ 008D 61 PUSH2 0x0534 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0534, if 0xa22cb465 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xb88d4fde 0097 14 EQ 0098 61 PUSH2 0x0554 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0554, if 0xb88d4fde == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xb88d4fde == stack[-1] 009C 61 PUSH2 0x01ed 009F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01ed label_00A0: // Incoming jump from 0x0028, if 0x95d89b41 > stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A0 5B JUMPDEST 00A1 80 DUP1 00A2 63 PUSH4 0x82c3cd9c 00A7 11 GT 00A8 61 PUSH2 0x00dc 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00dc, if 0x82c3cd9c > stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x82c3cd9c > stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x82c3cd9c 00B2 14 EQ 00B3 61 PUSH2 0x0475 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0475, if 0x82c3cd9c == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x82c3cd9c == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x85352058 00BD 14 EQ 00BE 61 PUSH2 0x04ab 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ab, if 0x85352058 == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x85352058 == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x8da5cb5b 00C8 14 EQ 00C9 61 PUSH2 0x04cb 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04cb, if 0x8da5cb5b == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0x938e3d7b 00D3 14 EQ 00D4 61 PUSH2 0x04e9 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e9, if 0x938e3d7b == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0x938e3d7b == stack[-1] 00D8 61 PUSH2 0x01ed 00DB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01ed label_00DC: // Incoming jump from 0x00AB, if 0x82c3cd9c > stack[-1] // Inputs[1] { @00DD stack[-1] } 00DC 5B JUMPDEST 00DD 80 DUP1 00DE 63 PUSH4 0x6352211e 00E3 14 EQ 00E4 61 PUSH2 0x040b 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x040b, if 0x6352211e == stack[-1] label_00E8: // Incoming jump from 0x00E7, if not 0x6352211e == stack[-1] // Inputs[1] { @00E8 stack[-1] } 00E8 80 DUP1 00E9 63 PUSH4 0x6c0360eb 00EE 14 EQ 00EF 61 PUSH2 0x042b 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x042b, if 0x6c0360eb == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x6c0360eb == stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F3 80 DUP1 00F4 63 PUSH4 0x70a08231 00F9 14 EQ 00FA 61 PUSH2 0x0440 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0440, if 0x70a08231 == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x70a08231 == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0x715018a6 0104 14 EQ 0105 61 PUSH2 0x0460 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0460, if 0x715018a6 == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x715018a6 == stack[-1] 0109 61 PUSH2 0x01ed 010C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01ed label_010D: // Incoming jump from 0x001D, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @010E stack[-1] } 010D 5B JUMPDEST 010E 80 DUP1 010F 63 PUSH4 0x2f745c59 0114 11 GT 0115 61 PUSH2 0x0185 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0185, if 0x2f745c59 > stack[-1] label_0119: // Incoming jump from 0x0118, if not 0x2f745c59 > stack[-1] // Inputs[1] { @0119 stack[-1] } 0119 80 DUP1 011A 63 PUSH4 0x55f804b3 011F 11 GT 0120 61 PUSH2 0x0154 0123 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0154, if 0x55f804b3 > stack[-1] label_0124: // Incoming jump from 0x0123, if not 0x55f804b3 > stack[-1] // Inputs[1] { @0124 stack[-1] } 0124 80 DUP1 0125 63 PUSH4 0x55f804b3 012A 14 EQ 012B 61 PUSH2 0x0391 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0391, if 0x55f804b3 == stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x55f804b3 == stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x5a67de07 0135 14 EQ 0136 61 PUSH2 0x03b1 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b1, if 0x5a67de07 == stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x5a67de07 == stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x5daa01b9 0140 14 EQ 0141 61 PUSH2 0x03d1 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d1, if 0x5daa01b9 == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x5daa01b9 == stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x603f4d52 014B 14 EQ 014C 61 PUSH2 0x03e4 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e4, if 0x603f4d52 == stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x603f4d52 == stack[-1] 0150 61 PUSH2 0x01ed 0153 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01ed label_0154: // Incoming jump from 0x0123, if 0x55f804b3 > stack[-1] // Inputs[1] { @0155 stack[-1] } 0154 5B JUMPDEST 0155 80 DUP1 0156 63 PUSH4 0x2f745c59 015B 14 EQ 015C 61 PUSH2 0x0311 015F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0311, if 0x2f745c59 == stack[-1] label_0160: // Incoming jump from 0x015F, if not 0x2f745c59 == stack[-1] // Inputs[1] { @0160 stack[-1] } 0160 80 DUP1 0161 63 PUSH4 0x38af3eed 0166 14 EQ 0167 61 PUSH2 0x0331 016A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0331, if 0x38af3eed == stack[-1] label_016B: // Incoming jump from 0x016A, if not 0x38af3eed == stack[-1] // Inputs[1] { @016B stack[-1] } 016B 80 DUP1 016C 63 PUSH4 0x42842e0e 0171 14 EQ 0172 61 PUSH2 0x0351 0175 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0351, if 0x42842e0e == stack[-1] label_0176: // Incoming jump from 0x0175, if not 0x42842e0e == stack[-1] // Inputs[1] { @0176 stack[-1] } 0176 80 DUP1 0177 63 PUSH4 0x4f6ccce7 017C 14 EQ 017D 61 PUSH2 0x0371 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0371, if 0x4f6ccce7 == stack[-1] label_0181: // Incoming jump from 0x0180, if not 0x4f6ccce7 == stack[-1] 0181 61 PUSH2 0x01ed 0184 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01ed label_0185: // Incoming jump from 0x0118, if 0x2f745c59 > stack[-1] // Inputs[1] { @0186 stack[-1] } 0185 5B JUMPDEST 0186 80 DUP1 0187 63 PUSH4 0x095ea7b3 018C 11 GT 018D 61 PUSH2 0x01c1 0190 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c1, if 0x095ea7b3 > stack[-1] label_0191: // Incoming jump from 0x0190, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @0191 stack[-1] } 0191 80 DUP1 0192 63 PUSH4 0x095ea7b3 0197 14 EQ 0198 61 PUSH2 0x029a 019B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x029a, if 0x095ea7b3 == stack[-1] label_019C: // Incoming jump from 0x019B, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @019C stack[-1] } 019C 80 DUP1 019D 63 PUSH4 0x18160ddd 01A2 14 EQ 01A3 61 PUSH2 0x02bc 01A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02bc, if 0x18160ddd == stack[-1] label_01A7: // Incoming jump from 0x01A6, if not 0x18160ddd == stack[-1] // Inputs[1] { @01A7 stack[-1] } 01A7 80 DUP1 01A8 63 PUSH4 0x1c31f710 01AD 14 EQ 01AE 61 PUSH2 0x02d1 01B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d1, if 0x1c31f710 == stack[-1] label_01B2: // Incoming jump from 0x01B1, if not 0x1c31f710 == stack[-1] // Inputs[1] { @01B2 stack[-1] } 01B2 80 DUP1 01B3 63 PUSH4 0x23b872dd 01B8 14 EQ 01B9 61 PUSH2 0x02f1 01BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f1, if 0x23b872dd == stack[-1] label_01BD: // Incoming jump from 0x01BC, if not 0x23b872dd == stack[-1] 01BD 61 PUSH2 0x01ed 01C0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01ed label_01C1: // Incoming jump from 0x0190, if 0x095ea7b3 > stack[-1] // Inputs[1] { @01C2 stack[-1] } 01C1 5B JUMPDEST 01C2 80 DUP1 01C3 62 PUSH3 0x0e7fa8 01C7 14 EQ 01C8 61 PUSH2 0x01f2 01CB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f2, if 0x0e7fa8 == stack[-1] label_01CC: // Incoming jump from 0x01CB, if not 0x0e7fa8 == stack[-1] // Inputs[1] { @01CC stack[-1] } 01CC 80 DUP1 01CD 63 PUSH4 0x01ffc9a7 01D2 14 EQ 01D3 61 PUSH2 0x021e 01D6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x021e, if 0x01ffc9a7 == stack[-1] label_01D7: // Incoming jump from 0x01D6, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01D7 stack[-1] } 01D7 80 DUP1 01D8 63 PUSH4 0x06fdde03 01DD 14 EQ 01DE 61 PUSH2 0x024b 01E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024b, if 0x06fdde03 == stack[-1] label_01E2: // Incoming jump from 0x01E1, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01E2 stack[-1] } 01E2 80 DUP1 01E3 63 PUSH4 0x081812fc 01E8 14 EQ 01E9 61 PUSH2 0x026d 01EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026d, if 0x081812fc == stack[-1] label_01ED: // Incoming jump from 0x00DB // Incoming jump from 0x009F // Incoming jump from 0x0153 // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x01C0 // Incoming jump from 0x010C // Incoming jump from 0x01EC, if not 0x081812fc == stack[-1] // Incoming jump from 0x006E // Incoming jump from 0x0184 // Inputs[1] { @01F1 memory[0x00:0x00] } 01ED 5B JUMPDEST 01EE 60 PUSH1 0x00 01F0 80 DUP1 01F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F1 revert(memory[0x00:0x00]); } // Block terminates label_01F2: // Incoming jump from 0x01CB, if 0x0e7fa8 == stack[-1] // Inputs[1] { @01F3 msg.value } 01F2 5B JUMPDEST 01F3 34 CALLVALUE 01F4 80 DUP1 01F5 15 ISZERO 01F6 61 PUSH2 0x01fe 01F9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01F3 stack[0] = msg.value } // Block ends with conditional jump to 0x01fe, if !msg.value label_01FA: // Incoming jump from 0x01F9, if not !msg.value // Inputs[1] { @01FD memory[0x00:0x00] } 01FA 60 PUSH1 0x00 01FC 80 DUP1 01FD FD *REVERT // Stack delta = +0 // Outputs[1] { @01FD revert(memory[0x00:0x00]); } // Block terminates label_01FE: // Incoming jump from 0x01F9, if !msg.value // Inputs[1] { @0205 storage[0x0e] } 01FE 5B JUMPDEST 01FF 50 POP 0200 61 PUSH2 0x0208 0203 60 PUSH1 0x0e 0205 54 SLOAD 0206 81 DUP2 0207 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0200 stack[-1] = 0x0208 // @0205 stack[0] = storage[0x0e] // } // Block ends with unconditional jump to 0x0208 label_0208: // Incoming jump from 0x02D0 // Incoming return from call to 0x038C at 0x038B // Incoming jump from 0x0533 // Incoming jump from 0x0207 // Inputs[2] // { // @020B memory[0x40:0x60] // @020F stack[-1] // } 0208 5B JUMPDEST 0209 60 PUSH1 0x40 020B 51 MLOAD 020C 61 PUSH2 0x0215 020F 91 SWAP2 0210 90 SWAP1 0211 61 PUSH2 0x261b 0214 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @020F stack[-1] = 0x0215 // @0210 stack[1] = memory[0x40:0x60] // @0210 stack[0] = stack[-1] // } // Block ends with call to 0x261b, returns to 0x0215 label_0215: // Incoming return from call to 0x261B at 0x0214 // Incoming return from call to 0x247A at 0x026C // Inputs[3] // { // @0218 memory[0x40:0x60] // @021A stack[-1] // @021D memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0215 5B JUMPDEST 0216 60 PUSH1 0x40 0218 51 MLOAD 0219 80 DUP1 021A 91 SWAP2 021B 03 SUB 021C 90 SWAP1 021D F3 *RETURN // Stack delta = -1 // Outputs[1] { @021D return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_021E: // Incoming jump from 0x01D6, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @021F msg.value } 021E 5B JUMPDEST 021F 34 CALLVALUE 0220 80 DUP1 0221 15 ISZERO 0222 61 PUSH2 0x022a 0225 57 *JUMPI // Stack delta = +1 // Outputs[1] { @021F stack[0] = msg.value } // Block ends with conditional jump to 0x022a, if !msg.value label_0226: // Incoming jump from 0x0225, if not !msg.value // Inputs[1] { @0229 memory[0x00:0x00] } 0226 60 PUSH1 0x00 0228 80 DUP1 0229 FD *REVERT // Stack delta = +0 // Outputs[1] { @0229 revert(memory[0x00:0x00]); } // Block terminates label_022A: // Incoming jump from 0x0225, if !msg.value // Inputs[1] { @0232 msg.data.length } 022A 5B JUMPDEST 022B 50 POP 022C 61 PUSH2 0x023e 022F 61 PUSH2 0x0239 0232 36 CALLDATASIZE 0233 60 PUSH1 0x04 0235 61 PUSH2 0x1c9e 0238 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @022C stack[-1] = 0x023e // @022F stack[0] = 0x0239 // @0232 stack[1] = msg.data.length // @0233 stack[2] = 0x04 // } // Block ends with call to 0x1c9e, returns to 0x0239 label_0239: // Incoming return from call to 0x1C9E at 0x0238 0239 5B JUMPDEST 023A 61 PUSH2 0x0625 023D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0625 023E 5B JUMPDEST 023F 60 PUSH1 0x40 0241 51 MLOAD 0242 61 PUSH2 0x0215 0245 91 SWAP2 0246 90 SWAP1 0247 61 PUSH2 0x245e 024A 56 *JUMP label_024B: // Incoming jump from 0x01E1, if 0x06fdde03 == stack[-1] // Inputs[1] { @024C msg.value } 024B 5B JUMPDEST 024C 34 CALLVALUE 024D 80 DUP1 024E 15 ISZERO 024F 61 PUSH2 0x0257 0252 57 *JUMPI // Stack delta = +1 // Outputs[1] { @024C stack[0] = msg.value } // Block ends with conditional jump to 0x0257, if !msg.value label_0253: // Incoming jump from 0x0252, if not !msg.value // Inputs[1] { @0256 memory[0x00:0x00] } 0253 60 PUSH1 0x00 0255 80 DUP1 0256 FD *REVERT // Stack delta = +0 // Outputs[1] { @0256 revert(memory[0x00:0x00]); } // Block terminates label_0257: // Incoming jump from 0x0252, if !msg.value 0257 5B JUMPDEST 0258 50 POP 0259 61 PUSH2 0x0260 025C 61 PUSH2 0x0638 025F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0259 stack[-1] = 0x0260 } // Block ends with call to 0x0638, returns to 0x0260 label_0260: // Incoming return from call to 0x0A9B at 0x043F // Incoming return from call to 0x0638 at 0x025F // Incoming return from call to 0x0D5F at 0x05A8 // Incoming return from call to 0x0C7A at 0x051D // Inputs[2] // { // @0263 memory[0x40:0x60] // @0267 stack[-1] // } 0260 5B JUMPDEST 0261 60 PUSH1 0x40 0263 51 MLOAD 0264 61 PUSH2 0x0215 0267 91 SWAP2 0268 90 SWAP1 0269 61 PUSH2 0x247a 026C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0267 stack[-1] = 0x0215 // @0268 stack[1] = memory[0x40:0x60] // @0268 stack[0] = stack[-1] // } // Block ends with call to 0x247a, returns to 0x0215 label_026D: // Incoming jump from 0x01EC, if 0x081812fc == stack[-1] // Inputs[1] { @026E msg.value } 026D 5B JUMPDEST 026E 34 CALLVALUE 026F 80 DUP1 0270 15 ISZERO 0271 61 PUSH2 0x0279 0274 57 *JUMPI // Stack delta = +1 // Outputs[1] { @026E stack[0] = msg.value } // Block ends with conditional jump to 0x0279, if !msg.value label_0275: // Incoming jump from 0x0274, if not !msg.value // Inputs[1] { @0278 memory[0x00:0x00] } 0275 60 PUSH1 0x00 0277 80 DUP1 0278 FD *REVERT // Stack delta = +0 // Outputs[1] { @0278 revert(memory[0x00:0x00]); } // Block terminates label_0279: // Incoming jump from 0x0274, if !msg.value // Inputs[1] { @0281 msg.data.length } 0279 5B JUMPDEST 027A 50 POP 027B 61 PUSH2 0x028d 027E 61 PUSH2 0x0288 0281 36 CALLDATASIZE 0282 60 PUSH1 0x04 0284 61 PUSH2 0x1d2d 0287 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @027B stack[-1] = 0x028d // @027E stack[0] = 0x0288 // @0281 stack[1] = msg.data.length // @0282 stack[2] = 0x04 // } // Block ends with call to 0x1d2d, returns to 0x0288 label_0288: // Incoming return from call to 0x1D2D at 0x0287 0288 5B JUMPDEST 0289 61 PUSH2 0x06ca 028C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06ca label_028D: // Incoming jump from 0x0350 // Incoming return from call to 0x0288 at 0x0287 // Incoming return from call to 0x0426 at 0x0425 // Incoming jump from 0x04E8 // Inputs[2] // { // @0290 memory[0x40:0x60] // @0294 stack[-1] // } 028D 5B JUMPDEST 028E 60 PUSH1 0x40 0290 51 MLOAD 0291 61 PUSH2 0x0215 0294 91 SWAP2 0295 90 SWAP1 0296 61 PUSH2 0x240c 0299 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0294 stack[-1] = 0x0215 // @0295 stack[1] = memory[0x40:0x60] // @0295 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x240c label_029A: // Incoming jump from 0x019B, if 0x095ea7b3 == stack[-1] // Inputs[1] { @029B msg.value } 029A 5B JUMPDEST 029B 34 CALLVALUE 029C 80 DUP1 029D 15 ISZERO 029E 61 PUSH2 0x02a6 02A1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @029B stack[0] = msg.value } // Block ends with conditional jump to 0x02a6, if !msg.value label_02A2: // Incoming jump from 0x02A1, if not !msg.value // Inputs[1] { @02A5 memory[0x00:0x00] } 02A2 60 PUSH1 0x00 02A4 80 DUP1 02A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @02A5 revert(memory[0x00:0x00]); } // Block terminates label_02A6: // Incoming jump from 0x02A1, if !msg.value // Inputs[1] { @02AE msg.data.length } 02A6 5B JUMPDEST 02A7 50 POP 02A8 61 PUSH2 0x02ba 02AB 61 PUSH2 0x02b5 02AE 36 CALLDATASIZE 02AF 60 PUSH1 0x04 02B1 61 PUSH2 0x1c38 02B4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02A8 stack[-1] = 0x02ba // @02AB stack[0] = 0x02b5 // @02AE stack[1] = msg.data.length // @02AF stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1c38 02B5 5B JUMPDEST 02B6 61 PUSH2 0x0723 02B9 56 *JUMP label_02BA: // Incoming return from call to 0x03DF at 0x03DE // Incoming return from call to 0x0B6D at 0x0474 // Incoming return from call to 0x03CC at 0x03CB // Incoming return from call to 0x0620 at 0x061F 02BA 5B JUMPDEST 02BB 00 *STOP // Stack delta = +0 // Outputs[1] { @02BB stop(); } // Block terminates label_02BC: // Incoming jump from 0x01A6, if 0x18160ddd == stack[-1] // Inputs[1] { @02BD msg.value } 02BC 5B JUMPDEST 02BD 34 CALLVALUE 02BE 80 DUP1 02BF 15 ISZERO 02C0 61 PUSH2 0x02c8 02C3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02BD stack[0] = msg.value } // Block ends with conditional jump to 0x02c8, if !msg.value label_02C4: // Incoming jump from 0x02C3, if not !msg.value // Inputs[1] { @02C7 memory[0x00:0x00] } 02C4 60 PUSH1 0x00 02C6 80 DUP1 02C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @02C7 revert(memory[0x00:0x00]); } // Block terminates label_02C8: // Incoming jump from 0x02C3, if !msg.value // Inputs[1] { @02CC storage[0x08] } 02C8 5B JUMPDEST 02C9 50 POP 02CA 60 PUSH1 0x08 02CC 54 SLOAD 02CD 61 PUSH2 0x0208 02D0 56 *JUMP // Stack delta = +0 // Outputs[1] { @02CC stack[-1] = storage[0x08] } // Block ends with unconditional jump to 0x0208 label_02D1: // Incoming jump from 0x01B1, if 0x1c31f710 == stack[-1] // Inputs[1] { @02D2 msg.value } 02D1 5B JUMPDEST 02D2 34 CALLVALUE 02D3 80 DUP1 02D4 15 ISZERO 02D5 61 PUSH2 0x02dd 02D8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02D2 stack[0] = msg.value } // Block ends with conditional jump to 0x02dd, if !msg.value label_02D9: // Incoming jump from 0x02D8, if not !msg.value // Inputs[1] { @02DC memory[0x00:0x00] } 02D9 60 PUSH1 0x00 02DB 80 DUP1 02DC FD *REVERT // Stack delta = +0 // Outputs[1] { @02DC revert(memory[0x00:0x00]); } // Block terminates label_02DD: // Incoming jump from 0x02D8, if !msg.value // Inputs[1] { @02E5 msg.data.length } 02DD 5B JUMPDEST 02DE 50 POP 02DF 61 PUSH2 0x02ba 02E2 61 PUSH2 0x02ec 02E5 36 CALLDATASIZE 02E6 60 PUSH1 0x04 02E8 61 PUSH2 0x1aea 02EB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02DF stack[-1] = 0x02ba // @02E2 stack[0] = 0x02ec // @02E5 stack[1] = msg.data.length // @02E6 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1aea 02EC 5B JUMPDEST 02ED 61 PUSH2 0x07a9 02F0 56 *JUMP label_02F1: // Incoming jump from 0x01BC, if 0x23b872dd == stack[-1] // Inputs[1] { @02F2 msg.value } 02F1 5B JUMPDEST 02F2 34 CALLVALUE 02F3 80 DUP1 02F4 15 ISZERO 02F5 61 PUSH2 0x02fd 02F8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F2 stack[0] = msg.value } // Block ends with conditional jump to 0x02fd, if !msg.value label_02F9: // Incoming jump from 0x02F8, if not !msg.value // Inputs[1] { @02FC memory[0x00:0x00] } 02F9 60 PUSH1 0x00 02FB 80 DUP1 02FC FD *REVERT // Stack delta = +0 // Outputs[1] { @02FC revert(memory[0x00:0x00]); } // Block terminates label_02FD: // Incoming jump from 0x02F8, if !msg.value // Inputs[1] { @0305 msg.data.length } 02FD 5B JUMPDEST 02FE 50 POP 02FF 61 PUSH2 0x02ba 0302 61 PUSH2 0x030c 0305 36 CALLDATASIZE 0306 60 PUSH1 0x04 0308 61 PUSH2 0x1b42 030B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02FF stack[-1] = 0x02ba // @0302 stack[0] = 0x030c // @0305 stack[1] = msg.data.length // @0306 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1b42 030C 5B JUMPDEST 030D 61 PUSH2 0x07f5 0310 56 *JUMP label_0311: // Incoming jump from 0x015F, if 0x2f745c59 == stack[-1] // Inputs[1] { @0312 msg.value } 0311 5B JUMPDEST 0312 34 CALLVALUE 0313 80 DUP1 0314 15 ISZERO 0315 61 PUSH2 0x031d 0318 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0312 stack[0] = msg.value } // Block ends with conditional jump to 0x031d, if !msg.value label_0319: // Incoming jump from 0x0318, if not !msg.value // Inputs[1] { @031C memory[0x00:0x00] } 0319 60 PUSH1 0x00 031B 80 DUP1 031C FD *REVERT // Stack delta = +0 // Outputs[1] { @031C revert(memory[0x00:0x00]); } // Block terminates label_031D: // Incoming jump from 0x0318, if !msg.value // Inputs[1] { @0325 msg.data.length } 031D 5B JUMPDEST 031E 50 POP 031F 61 PUSH2 0x0208 0322 61 PUSH2 0x032c 0325 36 CALLDATASIZE 0326 60 PUSH1 0x04 0328 61 PUSH2 0x1c38 032B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @031F stack[-1] = 0x0208 // @0322 stack[0] = 0x032c // @0325 stack[1] = msg.data.length // @0326 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1c38 032C 5B JUMPDEST 032D 61 PUSH2 0x0826 0330 56 *JUMP label_0331: // Incoming jump from 0x016A, if 0x38af3eed == stack[-1] // Inputs[1] { @0332 msg.value } 0331 5B JUMPDEST 0332 34 CALLVALUE 0333 80 DUP1 0334 15 ISZERO 0335 61 PUSH2 0x033d 0338 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0332 stack[0] = msg.value } // Block ends with conditional jump to 0x033d, if !msg.value label_0339: // Incoming jump from 0x0338, if not !msg.value // Inputs[1] { @033C memory[0x00:0x00] } 0339 60 PUSH1 0x00 033B 80 DUP1 033C FD *REVERT // Stack delta = +0 // Outputs[1] { @033C revert(memory[0x00:0x00]); } // Block terminates label_033D: // Incoming jump from 0x0338, if !msg.value // Inputs[1] { @0341 storage[0x11] } 033D 5B JUMPDEST 033E 50 POP 033F 60 PUSH1 0x11 0341 54 SLOAD 0342 61 PUSH2 0x028d 0345 90 SWAP1 0346 60 PUSH1 0x01 0348 60 PUSH1 0x01 034A 60 PUSH1 0xa0 034C 1B SHL 034D 03 SUB 034E 16 AND 034F 81 DUP2 0350 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0345 stack[-1] = 0x028d // @034E stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x11] // } // Block ends with unconditional jump to 0x028d label_0351: // Incoming jump from 0x0175, if 0x42842e0e == stack[-1] // Inputs[1] { @0352 msg.value } 0351 5B JUMPDEST 0352 34 CALLVALUE 0353 80 DUP1 0354 15 ISZERO 0355 61 PUSH2 0x035d 0358 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0352 stack[0] = msg.value } // Block ends with conditional jump to 0x035d, if !msg.value label_0359: // Incoming jump from 0x0358, if not !msg.value // Inputs[1] { @035C memory[0x00:0x00] } 0359 60 PUSH1 0x00 035B 80 DUP1 035C FD *REVERT // Stack delta = +0 // Outputs[1] { @035C revert(memory[0x00:0x00]); } // Block terminates label_035D: // Incoming jump from 0x0358, if !msg.value // Inputs[1] { @0365 msg.data.length } 035D 5B JUMPDEST 035E 50 POP 035F 61 PUSH2 0x02ba 0362 61 PUSH2 0x036c 0365 36 CALLDATASIZE 0366 60 PUSH1 0x04 0368 61 PUSH2 0x1b42 036B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @035F stack[-1] = 0x02ba // @0362 stack[0] = 0x036c // @0365 stack[1] = msg.data.length // @0366 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1b42 036C 5B JUMPDEST 036D 61 PUSH2 0x087b 0370 56 *JUMP label_0371: // Incoming jump from 0x0180, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @0372 msg.value } 0371 5B JUMPDEST 0372 34 CALLVALUE 0373 80 DUP1 0374 15 ISZERO 0375 61 PUSH2 0x037d 0378 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0372 stack[0] = msg.value } // Block ends with conditional jump to 0x037d, if !msg.value label_0379: // Incoming jump from 0x0378, if not !msg.value // Inputs[1] { @037C memory[0x00:0x00] } 0379 60 PUSH1 0x00 037B 80 DUP1 037C FD *REVERT // Stack delta = +0 // Outputs[1] { @037C revert(memory[0x00:0x00]); } // Block terminates label_037D: // Incoming jump from 0x0378, if !msg.value // Inputs[1] { @0385 msg.data.length } 037D 5B JUMPDEST 037E 50 POP 037F 61 PUSH2 0x0208 0382 61 PUSH2 0x038c 0385 36 CALLDATASIZE 0386 60 PUSH1 0x04 0388 61 PUSH2 0x1d2d 038B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @037F stack[-1] = 0x0208 // @0382 stack[0] = 0x038c // @0385 stack[1] = msg.data.length // @0386 stack[2] = 0x04 // } // Block ends with call to 0x1d2d, returns to 0x038C label_038C: // Incoming return from call to 0x1D2D at 0x038B 038C 5B JUMPDEST 038D 61 PUSH2 0x0896 0390 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0896 label_0391: // Incoming jump from 0x012E, if 0x55f804b3 == stack[-1] // Inputs[1] { @0392 msg.value } 0391 5B JUMPDEST 0392 34 CALLVALUE 0393 80 DUP1 0394 15 ISZERO 0395 61 PUSH2 0x039d 0398 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0392 stack[0] = msg.value } // Block ends with conditional jump to 0x039d, if !msg.value label_0399: // Incoming jump from 0x0398, if not !msg.value // Inputs[1] { @039C memory[0x00:0x00] } 0399 60 PUSH1 0x00 039B 80 DUP1 039C FD *REVERT // Stack delta = +0 // Outputs[1] { @039C revert(memory[0x00:0x00]); } // Block terminates label_039D: // Incoming jump from 0x0398, if !msg.value // Inputs[1] { @03A5 msg.data.length } 039D 5B JUMPDEST 039E 50 POP 039F 61 PUSH2 0x02ba 03A2 61 PUSH2 0x03ac 03A5 36 CALLDATASIZE 03A6 60 PUSH1 0x04 03A8 61 PUSH2 0x1cf8 03AB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @039F stack[-1] = 0x02ba // @03A2 stack[0] = 0x03ac // @03A5 stack[1] = msg.data.length // @03A6 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1cf8 03AC 5B JUMPDEST 03AD 61 PUSH2 0x08f2 03B0 56 *JUMP label_03B1: // Incoming jump from 0x0139, if 0x5a67de07 == stack[-1] // Inputs[1] { @03B2 msg.value } 03B1 5B JUMPDEST 03B2 34 CALLVALUE 03B3 80 DUP1 03B4 15 ISZERO 03B5 61 PUSH2 0x03bd 03B8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03B2 stack[0] = msg.value } // Block ends with conditional jump to 0x03bd, if !msg.value label_03B9: // Incoming jump from 0x03B8, if not !msg.value // Inputs[1] { @03BC memory[0x00:0x00] } 03B9 60 PUSH1 0x00 03BB 80 DUP1 03BC FD *REVERT // Stack delta = +0 // Outputs[1] { @03BC revert(memory[0x00:0x00]); } // Block terminates label_03BD: // Incoming jump from 0x03B8, if !msg.value // Inputs[1] { @03C5 msg.data.length } 03BD 5B JUMPDEST 03BE 50 POP 03BF 61 PUSH2 0x02ba 03C2 61 PUSH2 0x03cc 03C5 36 CALLDATASIZE 03C6 60 PUSH1 0x04 03C8 61 PUSH2 0x1cda 03CB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03BF stack[-1] = 0x02ba // @03C2 stack[0] = 0x03cc // @03C5 stack[1] = msg.data.length // @03C6 stack[2] = 0x04 // } // Block ends with call to 0x1cda, returns to 0x03CC label_03CC: // Incoming return from call to 0x1CDA at 0x03CB 03CC 5B JUMPDEST 03CD 61 PUSH2 0x0933 03D0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0933 label_03D1: // Incoming jump from 0x0144, if 0x5daa01b9 == stack[-1] // Inputs[1] { @03D8 msg.data.length } 03D1 5B JUMPDEST 03D2 61 PUSH2 0x02ba 03D5 61 PUSH2 0x03df 03D8 36 CALLDATASIZE 03D9 60 PUSH1 0x04 03DB 61 PUSH2 0x1d2d 03DE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03D2 stack[0] = 0x02ba // @03D5 stack[1] = 0x03df // @03D8 stack[2] = msg.data.length // @03D9 stack[3] = 0x04 // } // Block ends with call to 0x1d2d, returns to 0x03DF label_03DF: // Incoming return from call to 0x1D2D at 0x03DE 03DF 5B JUMPDEST 03E0 61 PUSH2 0x0992 03E3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0992 label_03E4: // Incoming jump from 0x014F, if 0x603f4d52 == stack[-1] // Inputs[1] { @03E5 msg.value } 03E4 5B JUMPDEST 03E5 34 CALLVALUE 03E6 80 DUP1 03E7 15 ISZERO 03E8 61 PUSH2 0x03f0 03EB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E5 stack[0] = msg.value } // Block ends with conditional jump to 0x03f0, if !msg.value label_03EC: // Incoming jump from 0x03EB, if not !msg.value // Inputs[1] { @03EF memory[0x00:0x00] } 03EC 60 PUSH1 0x00 03EE 80 DUP1 03EF FD *REVERT // Stack delta = +0 // Outputs[1] { @03EF revert(memory[0x00:0x00]); } // Block terminates label_03F0: // Incoming jump from 0x03EB, if !msg.value // Inputs[1] { @03F4 storage[0x0d] } 03F0 5B JUMPDEST 03F1 50 POP 03F2 60 PUSH1 0x0d 03F4 54 SLOAD 03F5 61 PUSH2 0x03fe 03F8 90 SWAP1 03F9 60 PUSH1 0xff 03FB 16 AND 03FC 81 DUP2 03FD 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03F8 stack[-1] = 0x03fe // @03FB stack[0] = 0xff & storage[0x0d] // } // Block ends with unconditional jump to 0x03fe label_03FE: // Incoming jump from 0x03FD // Inputs[2] // { // @0401 memory[0x40:0x60] // @0405 stack[-1] // } 03FE 5B JUMPDEST 03FF 60 PUSH1 0x40 0401 51 MLOAD 0402 61 PUSH2 0x0215 0405 91 SWAP2 0406 90 SWAP1 0407 61 PUSH2 0x246c 040A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0405 stack[-1] = 0x0215 // @0406 stack[1] = memory[0x40:0x60] // @0406 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x246c label_040B: // Incoming jump from 0x00E7, if 0x6352211e == stack[-1] // Inputs[1] { @040C msg.value } 040B 5B JUMPDEST 040C 34 CALLVALUE 040D 80 DUP1 040E 15 ISZERO 040F 61 PUSH2 0x0417 0412 57 *JUMPI // Stack delta = +1 // Outputs[1] { @040C stack[0] = msg.value } // Block ends with conditional jump to 0x0417, if !msg.value label_0413: // Incoming jump from 0x0412, if not !msg.value // Inputs[1] { @0416 memory[0x00:0x00] } 0413 60 PUSH1 0x00 0415 80 DUP1 0416 FD *REVERT // Stack delta = +0 // Outputs[1] { @0416 revert(memory[0x00:0x00]); } // Block terminates label_0417: // Incoming jump from 0x0412, if !msg.value // Inputs[1] { @041F msg.data.length } 0417 5B JUMPDEST 0418 50 POP 0419 61 PUSH2 0x028d 041C 61 PUSH2 0x0426 041F 36 CALLDATASIZE 0420 60 PUSH1 0x04 0422 61 PUSH2 0x1d2d 0425 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0419 stack[-1] = 0x028d // @041C stack[0] = 0x0426 // @041F stack[1] = msg.data.length // @0420 stack[2] = 0x04 // } // Block ends with call to 0x1d2d, returns to 0x0426 label_0426: // Incoming return from call to 0x1D2D at 0x0425 0426 5B JUMPDEST 0427 61 PUSH2 0x0a66 042A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a66 label_042B: // Incoming jump from 0x00F2, if 0x6c0360eb == stack[-1] // Inputs[1] { @042C msg.value } 042B 5B JUMPDEST 042C 34 CALLVALUE 042D 80 DUP1 042E 15 ISZERO 042F 61 PUSH2 0x0437 0432 57 *JUMPI // Stack delta = +1 // Outputs[1] { @042C stack[0] = msg.value } // Block ends with conditional jump to 0x0437, if !msg.value label_0433: // Incoming jump from 0x0432, if not !msg.value // Inputs[1] { @0436 memory[0x00:0x00] } 0433 60 PUSH1 0x00 0435 80 DUP1 0436 FD *REVERT // Stack delta = +0 // Outputs[1] { @0436 revert(memory[0x00:0x00]); } // Block terminates label_0437: // Incoming jump from 0x0432, if !msg.value 0437 5B JUMPDEST 0438 50 POP 0439 61 PUSH2 0x0260 043C 61 PUSH2 0x0a9b 043F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0439 stack[-1] = 0x0260 } // Block ends with call to 0x0a9b, returns to 0x0260 label_0440: // Incoming jump from 0x00FD, if 0x70a08231 == stack[-1] // Inputs[1] { @0441 msg.value } 0440 5B JUMPDEST 0441 34 CALLVALUE 0442 80 DUP1 0443 15 ISZERO 0444 61 PUSH2 0x044c 0447 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0441 stack[0] = msg.value } // Block ends with conditional jump to 0x044c, if !msg.value label_0448: // Incoming jump from 0x0447, if not !msg.value // Inputs[1] { @044B memory[0x00:0x00] } 0448 60 PUSH1 0x00 044A 80 DUP1 044B FD *REVERT // Stack delta = +0 // Outputs[1] { @044B revert(memory[0x00:0x00]); } // Block terminates label_044C: // Incoming jump from 0x0447, if !msg.value // Inputs[1] { @0454 msg.data.length } 044C 5B JUMPDEST 044D 50 POP 044E 61 PUSH2 0x0208 0451 61 PUSH2 0x045b 0454 36 CALLDATASIZE 0455 60 PUSH1 0x04 0457 61 PUSH2 0x1aea 045A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @044E stack[-1] = 0x0208 // @0451 stack[0] = 0x045b // @0454 stack[1] = msg.data.length // @0455 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1aea 045B 5B JUMPDEST 045C 61 PUSH2 0x0b29 045F 56 *JUMP label_0460: // Incoming jump from 0x0108, if 0x715018a6 == stack[-1] // Inputs[1] { @0461 msg.value } 0460 5B JUMPDEST 0461 34 CALLVALUE 0462 80 DUP1 0463 15 ISZERO 0464 61 PUSH2 0x046c 0467 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0461 stack[0] = msg.value } // Block ends with conditional jump to 0x046c, if !msg.value label_0468: // Incoming jump from 0x0467, if not !msg.value // Inputs[1] { @046B memory[0x00:0x00] } 0468 60 PUSH1 0x00 046A 80 DUP1 046B FD *REVERT // Stack delta = +0 // Outputs[1] { @046B revert(memory[0x00:0x00]); } // Block terminates label_046C: // Incoming jump from 0x0467, if !msg.value 046C 5B JUMPDEST 046D 50 POP 046E 61 PUSH2 0x02ba 0471 61 PUSH2 0x0b6d 0474 56 *JUMP // Stack delta = +0 // Outputs[1] { @046E stack[-1] = 0x02ba } // Block ends with call to 0x0b6d, returns to 0x02BA label_0475: // Incoming jump from 0x00B6, if 0x82c3cd9c == stack[-1] // Inputs[1] { @0476 msg.value } 0475 5B JUMPDEST 0476 34 CALLVALUE 0477 80 DUP1 0478 15 ISZERO 0479 61 PUSH2 0x0481 047C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0476 stack[0] = msg.value } // Block ends with conditional jump to 0x0481, if !msg.value label_047D: // Incoming jump from 0x047C, if not !msg.value // Inputs[1] { @0480 memory[0x00:0x00] } 047D 60 PUSH1 0x00 047F 80 DUP1 0480 FD *REVERT // Stack delta = +0 // Outputs[1] { @0480 revert(memory[0x00:0x00]); } // Block terminates label_0481: // Incoming jump from 0x047C, if !msg.value // Inputs[1] { @0489 msg.data.length } 0481 5B JUMPDEST 0482 50 POP 0483 61 PUSH2 0x0208 0486 61 PUSH2 0x0490 0489 36 CALLDATASIZE 048A 60 PUSH1 0x04 048C 61 PUSH2 0x1aea 048F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0483 stack[-1] = 0x0208 // @0486 stack[0] = 0x0490 // @0489 stack[1] = msg.data.length // @048A stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1aea 0490 5B JUMPDEST 0491 60 PUSH1 0x01 0493 60 PUSH1 0x01 0495 60 PUSH1 0xa0 0497 1B SHL 0498 03 SUB 0499 16 AND 049A 60 PUSH1 0x00 049C 90 SWAP1 049D 81 DUP2 049E 52 MSTORE 049F 60 PUSH1 0x10 04A1 60 PUSH1 0x20 04A3 52 MSTORE 04A4 60 PUSH1 0x40 04A6 90 SWAP1 04A7 20 SHA3 04A8 54 SLOAD 04A9 90 SWAP1 04AA 56 *JUMP label_04AB: // Incoming jump from 0x00C1, if 0x85352058 == stack[-1] // Inputs[1] { @04AC msg.value } 04AB 5B JUMPDEST 04AC 34 CALLVALUE 04AD 80 DUP1 04AE 15 ISZERO 04AF 61 PUSH2 0x04b7 04B2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04AC stack[0] = msg.value } // Block ends with conditional jump to 0x04b7, if !msg.value label_04B3: // Incoming jump from 0x04B2, if not !msg.value // Inputs[1] { @04B6 memory[0x00:0x00] } 04B3 60 PUSH1 0x00 04B5 80 DUP1 04B6 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B6 revert(memory[0x00:0x00]); } // Block terminates label_04B7: // Incoming jump from 0x04B2, if !msg.value // Inputs[1] { @04BF msg.data.length } 04B7 5B JUMPDEST 04B8 50 POP 04B9 61 PUSH2 0x02ba 04BC 61 PUSH2 0x04c6 04BF 36 CALLDATASIZE 04C0 60 PUSH1 0x04 04C2 61 PUSH2 0x1c68 04C5 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04B9 stack[-1] = 0x02ba // @04BC stack[0] = 0x04c6 // @04BF stack[1] = msg.data.length // @04C0 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1c68 04C6 5B JUMPDEST 04C7 61 PUSH2 0x0ba3 04CA 56 *JUMP label_04CB: // Incoming jump from 0x00CC, if 0x8da5cb5b == stack[-1] // Inputs[1] { @04CC msg.value } 04CB 5B JUMPDEST 04CC 34 CALLVALUE 04CD 80 DUP1 04CE 15 ISZERO 04CF 61 PUSH2 0x04d7 04D2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04CC stack[0] = msg.value } // Block ends with conditional jump to 0x04d7, if !msg.value label_04D3: // Incoming jump from 0x04D2, if not !msg.value // Inputs[1] { @04D6 memory[0x00:0x00] } 04D3 60 PUSH1 0x00 04D5 80 DUP1 04D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D6 revert(memory[0x00:0x00]); } // Block terminates label_04D7: // Incoming jump from 0x04D2, if !msg.value // Inputs[1] { @04DB storage[0x0a] } 04D7 5B JUMPDEST 04D8 50 POP 04D9 60 PUSH1 0x0a 04DB 54 SLOAD 04DC 60 PUSH1 0x01 04DE 60 PUSH1 0x01 04E0 60 PUSH1 0xa0 04E2 1B SHL 04E3 03 SUB 04E4 16 AND 04E5 61 PUSH2 0x028d 04E8 56 *JUMP // Stack delta = +0 // Outputs[1] { @04E4 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x0a] } // Block ends with unconditional jump to 0x028d label_04E9: // Incoming jump from 0x00D7, if 0x938e3d7b == stack[-1] // Inputs[1] { @04EA msg.value } 04E9 5B JUMPDEST 04EA 34 CALLVALUE 04EB 80 DUP1 04EC 15 ISZERO 04ED 61 PUSH2 0x04f5 04F0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04EA stack[0] = msg.value } // Block ends with conditional jump to 0x04f5, if !msg.value label_04F1: // Incoming jump from 0x04F0, if not !msg.value // Inputs[1] { @04F4 memory[0x00:0x00] } 04F1 60 PUSH1 0x00 04F3 80 DUP1 04F4 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F4 revert(memory[0x00:0x00]); } // Block terminates label_04F5: // Incoming jump from 0x04F0, if !msg.value // Inputs[1] { @04FD msg.data.length } 04F5 5B JUMPDEST 04F6 50 POP 04F7 61 PUSH2 0x02ba 04FA 61 PUSH2 0x0504 04FD 36 CALLDATASIZE 04FE 60 PUSH1 0x04 0500 61 PUSH2 0x1cf8 0503 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04F7 stack[-1] = 0x02ba // @04FA stack[0] = 0x0504 // @04FD stack[1] = msg.data.length // @04FE stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1cf8 0504 5B JUMPDEST 0505 61 PUSH2 0x0c3d 0508 56 *JUMP label_0509: // Incoming jump from 0x007A, if 0x95d89b41 == stack[-1] // Inputs[1] { @050A msg.value } 0509 5B JUMPDEST 050A 34 CALLVALUE 050B 80 DUP1 050C 15 ISZERO 050D 61 PUSH2 0x0515 0510 57 *JUMPI // Stack delta = +1 // Outputs[1] { @050A stack[0] = msg.value } // Block ends with conditional jump to 0x0515, if !msg.value label_0511: // Incoming jump from 0x0510, if not !msg.value // Inputs[1] { @0514 memory[0x00:0x00] } 0511 60 PUSH1 0x00 0513 80 DUP1 0514 FD *REVERT // Stack delta = +0 // Outputs[1] { @0514 revert(memory[0x00:0x00]); } // Block terminates label_0515: // Incoming jump from 0x0510, if !msg.value 0515 5B JUMPDEST 0516 50 POP 0517 61 PUSH2 0x0260 051A 61 PUSH2 0x0c7a 051D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0517 stack[-1] = 0x0260 } // Block ends with call to 0x0c7a, returns to 0x0260 label_051E: // Incoming jump from 0x0085, if 0x9b6860c8 == stack[-1] // Inputs[1] { @051F msg.value } 051E 5B JUMPDEST 051F 34 CALLVALUE 0520 80 DUP1 0521 15 ISZERO 0522 61 PUSH2 0x052a 0525 57 *JUMPI // Stack delta = +1 // Outputs[1] { @051F stack[0] = msg.value } // Block ends with conditional jump to 0x052a, if !msg.value label_0526: // Incoming jump from 0x0525, if not !msg.value // Inputs[1] { @0529 memory[0x00:0x00] } 0526 60 PUSH1 0x00 0528 80 DUP1 0529 FD *REVERT // Stack delta = +0 // Outputs[1] { @0529 revert(memory[0x00:0x00]); } // Block terminates label_052A: // Incoming jump from 0x0525, if !msg.value // Inputs[1] { @0531 storage[0x0f] } 052A 5B JUMPDEST 052B 50 POP 052C 61 PUSH2 0x0208 052F 60 PUSH1 0x0f 0531 54 SLOAD 0532 81 DUP2 0533 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @052C stack[-1] = 0x0208 // @0531 stack[0] = storage[0x0f] // } // Block ends with unconditional jump to 0x0208 label_0534: // Incoming jump from 0x0090, if 0xa22cb465 == stack[-1] // Inputs[1] { @0535 msg.value } 0534 5B JUMPDEST 0535 34 CALLVALUE 0536 80 DUP1 0537 15 ISZERO 0538 61 PUSH2 0x0540 053B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0535 stack[0] = msg.value } // Block ends with conditional jump to 0x0540, if !msg.value label_053C: // Incoming jump from 0x053B, if not !msg.value // Inputs[1] { @053F memory[0x00:0x00] } 053C 60 PUSH1 0x00 053E 80 DUP1 053F FD *REVERT // Stack delta = +0 // Outputs[1] { @053F revert(memory[0x00:0x00]); } // Block terminates label_0540: // Incoming jump from 0x053B, if !msg.value // Inputs[1] { @0548 msg.data.length } 0540 5B JUMPDEST 0541 50 POP 0542 61 PUSH2 0x02ba 0545 61 PUSH2 0x054f 0548 36 CALLDATASIZE 0549 60 PUSH1 0x04 054B 61 PUSH2 0x1c08 054E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0542 stack[-1] = 0x02ba // @0545 stack[0] = 0x054f // @0548 stack[1] = msg.data.length // @0549 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1c08 054F 5B JUMPDEST 0550 61 PUSH2 0x0c89 0553 56 *JUMP label_0554: // Incoming jump from 0x009B, if 0xb88d4fde == stack[-1] // Inputs[1] { @0555 msg.value } 0554 5B JUMPDEST 0555 34 CALLVALUE 0556 80 DUP1 0557 15 ISZERO 0558 61 PUSH2 0x0560 055B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0555 stack[0] = msg.value } // Block ends with conditional jump to 0x0560, if !msg.value label_055C: // Incoming jump from 0x055B, if not !msg.value // Inputs[1] { @055F memory[0x00:0x00] } 055C 60 PUSH1 0x00 055E 80 DUP1 055F FD *REVERT // Stack delta = +0 // Outputs[1] { @055F revert(memory[0x00:0x00]); } // Block terminates label_0560: // Incoming jump from 0x055B, if !msg.value // Inputs[1] { @0568 msg.data.length } 0560 5B JUMPDEST 0561 50 POP 0562 61 PUSH2 0x02ba 0565 61 PUSH2 0x056f 0568 36 CALLDATASIZE 0569 60 PUSH1 0x04 056B 61 PUSH2 0x1b8f 056E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0562 stack[-1] = 0x02ba // @0565 stack[0] = 0x056f // @0568 stack[1] = msg.data.length // @0569 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1b8f 056F 5B JUMPDEST 0570 61 PUSH2 0x0c94 0573 56 *JUMP label_0574: // Incoming jump from 0x003E, if 0xc87b56dd == stack[-1] // Inputs[1] { @0575 msg.value } 0574 5B JUMPDEST 0575 34 CALLVALUE 0576 80 DUP1 0577 15 ISZERO 0578 61 PUSH2 0x0580 057B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0575 stack[0] = msg.value } // Block ends with conditional jump to 0x0580, if !msg.value label_057C: // Incoming jump from 0x057B, if not !msg.value // Inputs[1] { @057F memory[0x00:0x00] } 057C 60 PUSH1 0x00 057E 80 DUP1 057F FD *REVERT // Stack delta = +0 // Outputs[1] { @057F revert(memory[0x00:0x00]); } // Block terminates label_0580: // Incoming jump from 0x057B, if !msg.value // Inputs[1] { @0588 msg.data.length } 0580 5B JUMPDEST 0581 50 POP 0582 61 PUSH2 0x0260 0585 61 PUSH2 0x058f 0588 36 CALLDATASIZE 0589 60 PUSH1 0x04 058B 61 PUSH2 0x1d2d 058E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0582 stack[-1] = 0x0260 // @0585 stack[0] = 0x058f // @0588 stack[1] = msg.data.length // @0589 stack[2] = 0x04 // } // Block ends with call to 0x1d2d, returns to 0x058F label_058F: // Incoming return from call to 0x1D2D at 0x058E 058F 5B JUMPDEST 0590 61 PUSH2 0x0ccc 0593 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ccc label_0594: // Incoming jump from 0x0049, if 0xe8a3d485 == stack[-1] // Inputs[1] { @0595 msg.value } 0594 5B JUMPDEST 0595 34 CALLVALUE 0596 80 DUP1 0597 15 ISZERO 0598 61 PUSH2 0x05a0 059B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0595 stack[0] = msg.value } // Block ends with conditional jump to 0x05a0, if !msg.value label_059C: // Incoming jump from 0x059B, if not !msg.value // Inputs[1] { @059F memory[0x00:0x00] } 059C 60 PUSH1 0x00 059E 80 DUP1 059F FD *REVERT // Stack delta = +0 // Outputs[1] { @059F revert(memory[0x00:0x00]); } // Block terminates label_05A0: // Incoming jump from 0x059B, if !msg.value 05A0 5B JUMPDEST 05A1 50 POP 05A2 61 PUSH2 0x0260 05A5 61 PUSH2 0x0d5f 05A8 56 *JUMP // Stack delta = +0 // Outputs[1] { @05A2 stack[-1] = 0x0260 } // Block ends with call to 0x0d5f, returns to 0x0260 label_05A9: // Incoming jump from 0x0054, if 0xe985e9c5 == stack[-1] // Inputs[1] { @05AA msg.value } 05A9 5B JUMPDEST 05AA 34 CALLVALUE 05AB 80 DUP1 05AC 15 ISZERO 05AD 61 PUSH2 0x05b5 05B0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05AA stack[0] = msg.value } // Block ends with conditional jump to 0x05b5, if !msg.value label_05B1: // Incoming jump from 0x05B0, if not !msg.value // Inputs[1] { @05B4 memory[0x00:0x00] } 05B1 60 PUSH1 0x00 05B3 80 DUP1 05B4 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B4 revert(memory[0x00:0x00]); } // Block terminates label_05B5: // Incoming jump from 0x05B0, if !msg.value // Inputs[1] { @05BD msg.data.length } 05B5 5B JUMPDEST 05B6 50 POP 05B7 61 PUSH2 0x023e 05BA 61 PUSH2 0x05c4 05BD 36 CALLDATASIZE 05BE 60 PUSH1 0x04 05C0 61 PUSH2 0x1b08 05C3 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05B7 stack[-1] = 0x023e // @05BA stack[0] = 0x05c4 // @05BD stack[1] = msg.data.length // @05BE stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1b08 05C4 5B JUMPDEST 05C5 60 PUSH1 0x01 05C7 60 PUSH1 0x01 05C9 60 PUSH1 0xa0 05CB 1B SHL 05CC 03 SUB 05CD 91 SWAP2 05CE 82 DUP3 05CF 16 AND 05D0 60 PUSH1 0x00 05D2 90 SWAP1 05D3 81 DUP2 05D4 52 MSTORE 05D5 60 PUSH1 0x05 05D7 60 PUSH1 0x20 05D9 90 SWAP1 05DA 81 DUP2 05DB 52 MSTORE 05DC 60 PUSH1 0x40 05DE 80 DUP1 05DF 83 DUP4 05E0 20 SHA3 05E1 93 SWAP4 05E2 90 SWAP1 05E3 94 SWAP5 05E4 16 AND 05E5 82 DUP3 05E6 52 MSTORE 05E7 91 SWAP2 05E8 90 SWAP1 05E9 91 SWAP2 05EA 52 MSTORE 05EB 20 SHA3 05EC 54 SLOAD 05ED 60 PUSH1 0xff 05EF 16 AND 05F0 90 SWAP1 05F1 56 *JUMP label_05F2: // Incoming jump from 0x005F, if 0xf2fde38b == stack[-1] // Inputs[1] { @05F3 msg.value } 05F2 5B JUMPDEST 05F3 34 CALLVALUE 05F4 80 DUP1 05F5 15 ISZERO 05F6 61 PUSH2 0x05fe 05F9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05F3 stack[0] = msg.value } // Block ends with conditional jump to 0x05fe, if !msg.value label_05FA: // Incoming jump from 0x05F9, if not !msg.value // Inputs[1] { @05FD memory[0x00:0x00] } 05FA 60 PUSH1 0x00 05FC 80 DUP1 05FD FD *REVERT // Stack delta = +0 // Outputs[1] { @05FD revert(memory[0x00:0x00]); } // Block terminates label_05FE: // Incoming jump from 0x05F9, if !msg.value // Inputs[1] { @0606 msg.data.length } 05FE 5B JUMPDEST 05FF 50 POP 0600 61 PUSH2 0x02ba 0603 61 PUSH2 0x060d 0606 36 CALLDATASIZE 0607 60 PUSH1 0x04 0609 61 PUSH2 0x1aea 060C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0600 stack[-1] = 0x02ba // @0603 stack[0] = 0x060d // @0606 stack[1] = msg.data.length // @0607 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1aea 060D 5B JUMPDEST 060E 61 PUSH2 0x0d6e 0611 56 *JUMP label_0612: // Incoming jump from 0x006A, if 0xff580055 == stack[-1] // Inputs[1] { @0619 msg.data.length } 0612 5B JUMPDEST 0613 61 PUSH2 0x02ba 0616 61 PUSH2 0x0620 0619 36 CALLDATASIZE 061A 60 PUSH1 0x04 061C 61 PUSH2 0x1d2d 061F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0613 stack[0] = 0x02ba // @0616 stack[1] = 0x0620 // @0619 stack[2] = msg.data.length // @061A stack[3] = 0x04 // } // Block ends with call to 0x1d2d, returns to 0x0620 label_0620: // Incoming return from call to 0x1D2D at 0x061F 0620 5B JUMPDEST 0621 61 PUSH2 0x0dca 0624 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dca label_0625: // Incoming jump from 0x023D // Inputs[1] { @062B stack[-1] } 0625 5B JUMPDEST 0626 60 PUSH1 0x00 0628 61 PUSH2 0x0630 062B 82 DUP3 062C 61 PUSH2 0x0ee7 062F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0626 stack[0] = 0x00 // @0628 stack[1] = 0x0630 // @062B stack[2] = stack[-1] // } // Block ends with call to 0x0ee7, returns to 0x0630 label_0630: // Incoming jump from 0x1448, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x2160 at 0x258A // Incoming return from call to 0x1F09 at 0x24EA // Incoming return from call to 0x1F3D at 0x24FA // Incoming jump from 0x0A83, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Incoming return from call to 0x1412 at 0x0F0B // Incoming return from call to 0x2702 at 0x2716 // Incoming jump from 0x0F02, if 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x2701 // Incoming return from call to 0x1F71 at 0x250A // Incoming return from call to 0x200E at 0x253A // Incoming return from call to 0x2119 at 0x257A // Incoming return from call to 0x0EE7 at 0x062F // Incoming return from call to 0x1E77 at 0x24CA // Incoming return from call to 0x23A5 at 0x261A // Incoming return from call to 0x2255 at 0x25CA // Incoming return from call to 0x1DEE at 0x24AA // Incoming return from call to 0x220C at 0x25BA // Incoming return from call to 0x2042 at 0x254A // Incoming jump from 0x1461 // Incoming return from call to 0x21A6 at 0x259A // Incoming return from call to 0x22CD at 0x25EA // Incoming return from call to 0x21D8 at 0x25AA // Incoming return from call to 0x1DBF at 0x249A // Incoming jump from 0x1448, if stack[-1] // Inputs[4] // { // @0631 stack[-2] // @0631 stack[-1] // @0634 stack[-4] // @0635 stack[-3] // } 0630 5B JUMPDEST 0631 90 SWAP1 0632 50 POP 0633 5B JUMPDEST 0634 91 SWAP2 0635 90 SWAP1 0636 50 POP 0637 56 *JUMP // Stack delta = -3 // Outputs[1] { @0634 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0638: // Incoming call from 0x025F, returns to 0x0260 // Inputs[1] { @063E storage[0x00] } 0638 5B JUMPDEST 0639 60 PUSH1 0x60 063B 60 PUSH1 0x00 063D 80 DUP1 063E 54 SLOAD 063F 61 PUSH2 0x0647 0642 90 SWAP1 0643 61 PUSH2 0x274f 0646 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0639 stack[0] = 0x60 // @063B stack[1] = 0x00 // @0642 stack[2] = 0x0647 // @0642 stack[3] = storage[0x00] // } // Block ends with call to 0x274f, returns to 0x0647 label_0647: // Incoming return from call to 0x274F at 0x0646 // Incoming return from call to 0x274F at 0x0D6D // Incoming return from call to 0x274F at 0x12F6 // Incoming return from call to 0x274F at 0x0C88 // Inputs[4] // { // @0648 stack[-1] // @0657 memory[0x40:0x60] // @065F stack[-2] // @066A storage[stack[-2]] // } 0647 5B JUMPDEST 0648 80 DUP1 0649 60 PUSH1 0x1f 064B 01 ADD 064C 60 PUSH1 0x20 064E 80 DUP1 064F 91 SWAP2 0650 04 DIV 0651 02 MUL 0652 60 PUSH1 0x20 0654 01 ADD 0655 60 PUSH1 0x40 0657 51 MLOAD 0658 90 SWAP1 0659 81 DUP2 065A 01 ADD 065B 60 PUSH1 0x40 065D 52 MSTORE 065E 80 DUP1 065F 92 SWAP3 0660 91 SWAP2 0661 90 SWAP1 0662 81 DUP2 0663 81 DUP2 0664 52 MSTORE 0665 60 PUSH1 0x20 0667 01 ADD 0668 82 DUP3 0669 80 DUP1 066A 54 SLOAD 066B 61 PUSH2 0x0673 066E 90 SWAP1 066F 61 PUSH2 0x274f 0672 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @065D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @065F stack[-2] = memory[0x40:0x60] // @0660 stack[-1] = stack[-2] // @0661 stack[0] = stack[-1] // @0664 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0667 stack[1] = 0x20 + memory[0x40:0x60] // @0668 stack[2] = stack[-2] // @066E stack[4] = storage[stack[-2]] // @066E stack[3] = 0x0673 // } // Block ends with call to 0x274f, returns to 0x0673 label_0673: // Incoming return from call to 0x274F at 0x0672 // Inputs[1] { @0674 stack[-1] } 0673 5B JUMPDEST 0674 80 DUP1 0675 15 ISZERO 0676 61 PUSH2 0x06c0 0679 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06c0, if !stack[-1] label_067A: // Incoming jump from 0x0679, if not !stack[-1] // Inputs[1] { @067A stack[-1] } 067A 80 DUP1 067B 60 PUSH1 0x1f 067D 10 LT 067E 61 PUSH2 0x0695 0681 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0695, if 0x1f < stack[-1] label_0682: // Incoming jump from 0x0681, if not 0x1f < stack[-1] // Inputs[4] // { // @0686 stack[-2] // @0687 storage[stack[-2]] // @068A stack[-3] // @068C stack[-1] // } 0682 61 PUSH2 0x0100 0685 80 DUP1 0686 83 DUP4 0687 54 SLOAD 0688 04 DIV 0689 02 MUL 068A 83 DUP4 068B 52 MSTORE 068C 91 SWAP2 068D 60 PUSH1 0x20 068F 01 ADD 0690 91 SWAP2 0691 61 PUSH2 0x06c0 0694 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @068B memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0690 stack[-1] = stack[-1] // @0690 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x06c0 label_0695: // Incoming jump from 0x0681, if 0x1f < stack[-1] // Inputs[5] // { // @0696 stack[-3] // @0697 stack[-1] // @0699 stack[-2] // @06A1 memory[0x00:0x20] // @06A5 storage[keccak256(memory[0x00:0x20])] // } 0695 5B JUMPDEST 0696 82 DUP3 0697 01 ADD 0698 91 SWAP2 0699 90 SWAP1 069A 60 PUSH1 0x00 069C 52 MSTORE 069D 60 PUSH1 0x20 069F 60 PUSH1 0x00 06A1 20 SHA3 06A2 90 SWAP1 06A3 5B JUMPDEST 06A4 81 DUP2 06A5 54 SLOAD 06A6 81 DUP2 06A7 52 MSTORE 06A8 90 SWAP1 06A9 60 PUSH1 0x01 06AB 01 ADD 06AC 90 SWAP1 06AD 60 PUSH1 0x20 06AF 01 ADD 06B0 80 DUP1 06B1 83 DUP4 06B2 11 GT 06B3 61 PUSH2 0x06a3 06B6 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0698 stack[-3] = stack[-3] + stack[-1] // @069C memory[0x00:0x20] = stack[-2] // @06A7 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @06AC stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @06AF stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x06a3, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_06B7: // Incoming jump from 0x06B6, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x06B6, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @06B7 stack[-3] // @06B8 stack[-1] // } 06B7 82 DUP3 06B8 90 SWAP1 06B9 03 SUB 06BA 60 PUSH1 0x1f 06BC 16 AND 06BD 82 DUP3 06BE 01 ADD 06BF 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @06BF stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @06BF stack[-1] = stack[-3] // } // Block continues label_06C0: // Incoming jump from 0x0694 // Incoming jump from 0x06BF // Incoming jump from 0x0679, if !stack[-1] // Inputs[3] // { // @06C6 stack[-7] // @06C6 stack[-6] // @06C8 stack[-8] // } 06C0 5B JUMPDEST 06C1 50 POP 06C2 50 POP 06C3 50 POP 06C4 50 POP 06C5 50 POP 06C6 90 SWAP1 06C7 50 POP 06C8 90 SWAP1 06C9 56 *JUMP // Stack delta = -7 // Outputs[1] { @06C8 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_06CA: // Incoming jump from 0x028C // Inputs[3] // { // @06CD stack[-1] // @06D8 memory[0x00:0x40] // @06D9 storage[keccak256(memory[0x00:0x40])] // } 06CA 5B JUMPDEST 06CB 60 PUSH1 0x00 06CD 81 DUP2 06CE 81 DUP2 06CF 52 MSTORE 06D0 60 PUSH1 0x02 06D2 60 PUSH1 0x20 06D4 52 MSTORE 06D5 60 PUSH1 0x40 06D7 81 DUP2 06D8 20 SHA3 06D9 54 SLOAD 06DA 60 PUSH1 0x01 06DC 60 PUSH1 0x01 06DE 60 PUSH1 0xa0 06E0 1B SHL 06E1 03 SUB 06E2 16 AND 06E3 61 PUSH2 0x0707 06E6 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @06CB stack[0] = 0x00 // @06CF memory[0x00:0x20] = stack[-1] // @06D4 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x0707, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_06E7: // Incoming jump from 0x06E6, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @06E9 memory[0x40:0x60] } 06E7 60 PUSH1 0x40 06E9 51 MLOAD 06EA 62 PUSH3 0x461bcd 06EE 60 PUSH1 0xe5 06F0 1B SHL 06F1 81 DUP2 06F2 52 MSTORE 06F3 60 PUSH1 0x04 06F5 01 ADD 06F6 61 PUSH2 0x06fe 06F9 90 SWAP1 06FA 61 PUSH2 0x25ab 06FD 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @06F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @06F9 stack[0] = 0x06fe // @06F9 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x25ab label_06FE: // Incoming return from call to 0x25BB at 0x095C // Incoming return from call to 0x25BB at 0x0B96 // Inputs[3] // { // @0701 memory[0x40:0x60] // @0703 stack[-1] // @0706 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 06FE 5B JUMPDEST 06FF 60 PUSH1 0x40 0701 51 MLOAD 0702 80 DUP1 0703 91 SWAP2 0704 03 SUB 0705 90 SWAP1 0706 FD *REVERT // Stack delta = -1 // Outputs[1] { @0706 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0707: // Incoming jump from 0x06E6, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @070B stack[-2] // @0716 memory[0x00:0x40] // @0717 storage[keccak256(memory[0x00:0x40])] // @0721 stack[-3] // } 0707 5B JUMPDEST 0708 50 POP 0709 60 PUSH1 0x00 070B 90 SWAP1 070C 81 DUP2 070D 52 MSTORE 070E 60 PUSH1 0x04 0710 60 PUSH1 0x20 0712 52 MSTORE 0713 60 PUSH1 0x40 0715 90 SWAP1 0716 20 SHA3 0717 54 SLOAD 0718 60 PUSH1 0x01 071A 60 PUSH1 0x01 071C 60 PUSH1 0xa0 071E 1B SHL 071F 03 SUB 0720 16 AND 0721 90 SWAP1 0722 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @070D memory[0x00:0x20] = stack[-2] // @0712 memory[0x20:0x40] = 0x04 // @0721 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] 0723 5B JUMPDEST 0724 60 PUSH1 0x00 0726 61 PUSH2 0x072e 0729 82 DUP3 072A 61 PUSH2 0x0a66 072D 56 *JUMP 072E 5B JUMPDEST 072F 90 SWAP1 0730 50 POP 0731 80 DUP1 0732 60 PUSH1 0x01 0734 60 PUSH1 0x01 0736 60 PUSH1 0xa0 0738 1B SHL 0739 03 SUB 073A 16 AND 073B 83 DUP4 073C 60 PUSH1 0x01 073E 60 PUSH1 0x01 0740 60 PUSH1 0xa0 0742 1B SHL 0743 03 SUB 0744 16 AND 0745 14 EQ 0746 15 ISZERO 0747 61 PUSH2 0x0762 074A 57 *JUMPI 074B 60 PUSH1 0x40 074D 51 MLOAD 074E 62 PUSH3 0x461bcd 0752 60 PUSH1 0xe5 0754 1B SHL 0755 81 DUP2 0756 52 MSTORE 0757 60 PUSH1 0x04 0759 01 ADD 075A 61 PUSH2 0x06fe 075D 90 SWAP1 075E 61 PUSH2 0x25eb 0761 56 *JUMP 0762 5B JUMPDEST 0763 33 CALLER 0764 60 PUSH1 0x01 0766 60 PUSH1 0x01 0768 60 PUSH1 0xa0 076A 1B SHL 076B 03 SUB 076C 82 DUP3 076D 16 AND 076E 14 EQ 076F 80 DUP1 0770 61 PUSH2 0x077e 0773 57 *JUMPI 0774 50 POP 0775 61 PUSH2 0x077e 0778 81 DUP2 0779 33 CALLER 077A 61 PUSH2 0x05c4 077D 56 *JUMP 077E 5B JUMPDEST 077F 61 PUSH2 0x079a 0782 57 *JUMPI 0783 60 PUSH1 0x40 0785 51 MLOAD 0786 62 PUSH3 0x461bcd 078A 60 PUSH1 0xe5 078C 1B SHL 078D 81 DUP2 078E 52 MSTORE 078F 60 PUSH1 0x04 0791 01 ADD 0792 61 PUSH2 0x06fe 0795 90 SWAP1 0796 61 PUSH2 0x255b 0799 56 *JUMP 079A 5B JUMPDEST 079B 61 PUSH2 0x07a4 079E 83 DUP4 079F 83 DUP4 07A0 61 PUSH2 0x0f0c 07A3 56 *JUMP label_07A4: // Incoming return from call to 0x17FA at 0x1650 // Incoming jump from 0x1647, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] // Incoming return from call to 0x1594 at 0x146C // Incoming jump from 0x166C, if stack[-1] // Incoming jump from 0x0EDD, if !!address(storage[0x11] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !msg.value).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Incoming jump from 0x162D // Inputs[1] { @07A8 stack[-4] } 07A4 5B JUMPDEST 07A5 50 POP 07A6 50 POP 07A7 50 POP 07A8 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] 07A9 5B JUMPDEST 07AA 60 PUSH1 0x0a 07AC 54 SLOAD 07AD 60 PUSH1 0x01 07AF 60 PUSH1 0x01 07B1 60 PUSH1 0xa0 07B3 1B SHL 07B4 03 SUB 07B5 16 AND 07B6 33 CALLER 07B7 14 EQ 07B8 61 PUSH2 0x07d3 07BB 57 *JUMPI 07BC 60 PUSH1 0x40 07BE 51 MLOAD 07BF 62 PUSH3 0x461bcd 07C3 60 PUSH1 0xe5 07C5 1B SHL 07C6 81 DUP2 07C7 52 MSTORE 07C8 60 PUSH1 0x04 07CA 01 ADD 07CB 61 PUSH2 0x06fe 07CE 90 SWAP1 07CF 61 PUSH2 0x25bb 07D2 56 *JUMP 07D3 5B JUMPDEST 07D4 60 PUSH1 0x11 07D6 80 DUP1 07D7 54 SLOAD 07D8 60 PUSH1 0x01 07DA 60 PUSH1 0x01 07DC 60 PUSH1 0xa0 07DE 1B SHL 07DF 03 SUB 07E0 19 NOT 07E1 16 AND 07E2 60 PUSH1 0x01 07E4 60 PUSH1 0x01 07E6 60 PUSH1 0xa0 07E8 1B SHL 07E9 03 SUB 07EA 92 SWAP3 07EB 90 SWAP1 07EC 92 SWAP3 07ED 16 AND 07EE 91 SWAP2 07EF 90 SWAP1 07F0 91 SWAP2 07F1 17 OR 07F2 90 SWAP1 07F3 55 SSTORE 07F4 56 *JUMP 07F5 5B JUMPDEST 07F6 61 PUSH2 0x07ff 07F9 33 CALLER 07FA 82 DUP3 07FB 61 PUSH2 0x0f7a 07FE 56 *JUMP 07FF 5B JUMPDEST 0800 61 PUSH2 0x081b 0803 57 *JUMPI 0804 60 PUSH1 0x40 0806 51 MLOAD 0807 62 PUSH3 0x461bcd 080B 60 PUSH1 0xe5 080D 1B SHL 080E 81 DUP2 080F 52 MSTORE 0810 60 PUSH1 0x04 0812 01 ADD 0813 61 PUSH2 0x06fe 0816 90 SWAP1 0817 61 PUSH2 0x25fb 081A 56 *JUMP 081B 5B JUMPDEST 081C 61 PUSH2 0x07a4 081F 83 DUP4 0820 83 DUP4 0821 83 DUP4 0822 61 PUSH2 0x102c 0825 56 *JUMP 0826 5B JUMPDEST 0827 60 PUSH1 0x00 0829 61 PUSH2 0x0831 082C 83 DUP4 082D 61 PUSH2 0x0b29 0830 56 *JUMP 0831 5B JUMPDEST 0832 82 DUP3 0833 10 LT 0834 61 PUSH2 0x084f 0837 57 *JUMPI 0838 60 PUSH1 0x40 083A 51 MLOAD 083B 62 PUSH3 0x461bcd 083F 60 PUSH1 0xe5 0841 1B SHL 0842 81 DUP2 0843 52 MSTORE 0844 60 PUSH1 0x04 0846 01 ADD 0847 61 PUSH2 0x06fe 084A 90 SWAP1 084B 61 PUSH2 0x24ab 084E 56 *JUMP 084F 5B JUMPDEST 0850 50 POP 0851 60 PUSH1 0x01 0853 60 PUSH1 0x01 0855 60 PUSH1 0xa0 0857 1B SHL 0858 03 SUB 0859 82 DUP3 085A 16 AND 085B 60 PUSH1 0x00 085D 90 SWAP1 085E 81 DUP2 085F 52 MSTORE 0860 60 PUSH1 0x06 0862 60 PUSH1 0x20 0864 90 SWAP1 0865 81 DUP2 0866 52 MSTORE 0867 60 PUSH1 0x40 0869 80 DUP1 086A 83 DUP4 086B 20 SHA3 086C 84 DUP5 086D 84 DUP5 086E 52 MSTORE 086F 90 SWAP1 0870 91 SWAP2 0871 52 MSTORE 0872 90 SWAP1 0873 20 SHA3 0874 54 SLOAD label_0875: // Incoming return from call to 0x2882 at 0x1ADE // Incoming return from call to 0x2872 at 0x1AA7 // Incoming return from call to 0x288F at 0x1AE9 // Incoming return from call to 0x23EE at 0x2628 // Inputs[3] // { // @0876 stack[-4] // @0876 stack[-1] // @0877 stack[-3] // } 0875 5B JUMPDEST 0876 92 SWAP3 0877 91 SWAP2 0878 50 POP 0879 50 POP 087A 56 *JUMP // Stack delta = -3 // Outputs[1] { @0876 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] 087B 5B JUMPDEST 087C 61 PUSH2 0x07a4 087F 83 DUP4 0880 83 DUP4 0881 83 DUP4 0882 60 PUSH1 0x40 0884 51 MLOAD 0885 80 DUP1 0886 60 PUSH1 0x20 0888 01 ADD 0889 60 PUSH1 0x40 088B 52 MSTORE 088C 80 DUP1 088D 60 PUSH1 0x00 088F 81 DUP2 0890 52 MSTORE 0891 50 POP 0892 61 PUSH2 0x0c94 0895 56 *JUMP label_0896: // Incoming jump from 0x0390 // Inputs[1] { @089E storage[0x08] } 0896 5B JUMPDEST 0897 60 PUSH1 0x00 0899 61 PUSH2 0x08a1 089C 60 PUSH1 0x08 089E 54 SLOAD 089F 90 SWAP1 08A0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0897 stack[0] = 0x00 // @089F stack[1] = storage[0x08] // } // Block ends with unconditional jump to 0x08a1 label_08A1: // Incoming jump from 0x08A0 // Inputs[2] // { // @08A2 stack[-3] // @08A3 stack[-1] // } 08A1 5B JUMPDEST 08A2 82 DUP3 08A3 10 LT 08A4 61 PUSH2 0x08bf 08A7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x08bf, if stack[-3] < stack[-1] label_08A8: // Incoming jump from 0x08A7, if not stack[-3] < stack[-1] // Inputs[1] { @08AA memory[0x40:0x60] } 08A8 60 PUSH1 0x40 08AA 51 MLOAD 08AB 62 PUSH3 0x461bcd 08AF 60 PUSH1 0xe5 08B1 1B SHL 08B2 81 DUP2 08B3 52 MSTORE 08B4 60 PUSH1 0x04 08B6 01 ADD 08B7 61 PUSH2 0x06fe 08BA 90 SWAP1 08BB 61 PUSH2 0x260b 08BE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @08B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08BA stack[0] = 0x06fe // @08BA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x260b label_08BF: // Incoming jump from 0x08A7, if stack[-3] < stack[-1] // Inputs[2] // { // @08C2 stack[-2] // @08C4 storage[0x08] // } 08BF 5B JUMPDEST 08C0 60 PUSH1 0x08 08C2 82 DUP3 08C3 81 DUP2 08C4 54 SLOAD 08C5 81 DUP2 08C6 10 LT 08C7 61 PUSH2 0x08e0 08CA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @08C0 stack[0] = 0x08 // @08C2 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x08e0, if stack[-2] < storage[0x08] label_08CB: // Incoming jump from 0x08CA, if not stack[-2] < storage[0x08] // Inputs[1] { @08DF memory[0x00:0x24] } 08CB 63 PUSH4 0x4e487b71 08D0 60 PUSH1 0xe0 08D2 1B SHL 08D3 60 PUSH1 0x00 08D5 52 MSTORE 08D6 60 PUSH1 0x32 08D8 60 PUSH1 0x04 08DA 52 MSTORE 08DB 60 PUSH1 0x24 08DD 60 PUSH1 0x00 08DF FD *REVERT // Stack delta = +0 // Outputs[3] // { // @08D5 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @08DA memory[0x04:0x24] = 0x32 // @08DF revert(memory[0x00:0x24]); // } // Block terminates label_08E0: // Incoming jump from 0x08CA, if stack[-2] < storage[0x08] // Inputs[7] // { // @08E1 stack[-1] // @08E1 stack[-2] // @08E9 memory[0x00:0x20] // @08EB storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @08EC stack[-3] // @08EE stack[-5] // @08EF stack[-4] // } 08E0 5B JUMPDEST 08E1 90 SWAP1 08E2 60 PUSH1 0x00 08E4 52 MSTORE 08E5 60 PUSH1 0x20 08E7 60 PUSH1 0x00 08E9 20 SHA3 08EA 01 ADD 08EB 54 SLOAD 08EC 90 SWAP1 08ED 50 POP 08EE 91 SWAP2 08EF 90 SWAP1 08F0 50 POP 08F1 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @08E4 memory[0x00:0x20] = stack[-2] // @08EE stack[-5] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-5] 08F2 5B JUMPDEST 08F3 60 PUSH1 0x0a 08F5 54 SLOAD 08F6 60 PUSH1 0x01 08F8 60 PUSH1 0x01 08FA 60 PUSH1 0xa0 08FC 1B SHL 08FD 03 SUB 08FE 16 AND 08FF 33 CALLER 0900 14 EQ 0901 61 PUSH2 0x091c 0904 57 *JUMPI 0905 60 PUSH1 0x40 0907 51 MLOAD 0908 62 PUSH3 0x461bcd 090C 60 PUSH1 0xe5 090E 1B SHL 090F 81 DUP2 0910 52 MSTORE 0911 60 PUSH1 0x04 0913 01 ADD 0914 61 PUSH2 0x06fe 0917 90 SWAP1 0918 61 PUSH2 0x25bb 091B 56 *JUMP 091C 5B JUMPDEST 091D 80 DUP1 091E 51 MLOAD 091F 61 PUSH2 0x092f 0922 90 SWAP1 0923 60 PUSH1 0x0b 0925 90 SWAP1 0926 60 PUSH1 0x20 0928 84 DUP5 0929 01 ADD 092A 90 SWAP1 092B 61 PUSH2 0x192c 092E 56 *JUMP label_092F: // Incoming jump from 0x0A5C, if !!address(storage[0x11] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !msg.value).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Incoming return from call to 0x1651 at 0x1486 // Inputs[1] { @0932 stack[-3] } 092F 5B JUMPDEST 0930 50 POP 0931 50 POP 0932 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0933: // Incoming jump from 0x03D0 // Inputs[2] // { // @0936 storage[0x0a] // @0940 msg.sender // } 0933 5B JUMPDEST 0934 60 PUSH1 0x0a 0936 54 SLOAD 0937 60 PUSH1 0x01 0939 60 PUSH1 0x01 093B 60 PUSH1 0xa0 093D 1B SHL 093E 03 SUB 093F 16 AND 0940 33 CALLER 0941 14 EQ 0942 61 PUSH2 0x095d 0945 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x095d, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] label_0946: // Incoming jump from 0x0945, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @0948 memory[0x40:0x60] } 0946 60 PUSH1 0x40 0948 51 MLOAD 0949 62 PUSH3 0x461bcd 094D 60 PUSH1 0xe5 094F 1B SHL 0950 81 DUP2 0951 52 MSTORE 0952 60 PUSH1 0x04 0954 01 ADD 0955 61 PUSH2 0x06fe 0958 90 SWAP1 0959 61 PUSH2 0x25bb 095C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0951 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0958 stack[0] = 0x06fe // @0958 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x25bb, returns to 0x06FE label_095D: // Incoming jump from 0x0945, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[2] // { // @0961 storage[0x0d] // @0962 stack[-1] // } 095D 5B JUMPDEST 095E 60 PUSH1 0x0d 0960 80 DUP1 0961 54 SLOAD 0962 82 DUP3 0963 91 SWAP2 0964 90 SWAP1 0965 60 PUSH1 0xff 0967 19 NOT 0968 16 AND 0969 60 PUSH1 0x01 096B 83 DUP4 096C 60 PUSH1 0x02 096E 81 DUP2 096F 11 GT 0970 15 ISZERO 0971 61 PUSH2 0x098a 0974 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @0963 stack[0] = stack[-1] // @0964 stack[1] = 0x0d // @0968 stack[2] = ~0xff & storage[0x0d] // @0969 stack[3] = 0x01 // @096B stack[4] = stack[-1] // } // Block ends with conditional jump to 0x098a, if !(stack[-1] > 0x02) label_0975: // Incoming jump from 0x0974, if not !(stack[-1] > 0x02) // Inputs[1] { @0989 memory[0x00:0x24] } 0975 63 PUSH4 0x4e487b71 097A 60 PUSH1 0xe0 097C 1B SHL 097D 60 PUSH1 0x00 097F 52 MSTORE 0980 60 PUSH1 0x21 0982 60 PUSH1 0x04 0984 52 MSTORE 0985 60 PUSH1 0x24 0987 60 PUSH1 0x00 0989 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @097F memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0984 memory[0x04:0x24] = 0x21 // @0989 revert(memory[0x00:0x24]); // } // Block terminates label_098A: // Incoming jump from 0x0974, if !(stack[-1] > 0x02) // Inputs[5] // { // @098B stack[-2] // @098B stack[-1] // @098C stack[-3] // @098D stack[-4] // @0991 stack[-7] // } 098A 5B JUMPDEST 098B 02 MUL 098C 17 OR 098D 90 SWAP1 098E 55 SSTORE 098F 50 POP 0990 50 POP 0991 56 *JUMP // Stack delta = -7 // Outputs[1] { @098E storage[stack[-4]] = stack[-1] * stack[-2] | stack[-3] } // Block ends with unconditional jump to stack[-7] label_0992: // Incoming jump from 0x03E3 // Inputs[1] { @0997 storage[0x0d] } 0992 5B JUMPDEST 0993 60 PUSH1 0x02 0995 60 PUSH1 0x0d 0997 54 SLOAD 0998 60 PUSH1 0xff 099A 16 AND 099B 60 PUSH1 0x02 099D 81 DUP2 099E 11 GT 099F 15 ISZERO 09A0 61 PUSH2 0x09b9 09A3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0993 stack[0] = 0x02 // @099A stack[1] = 0xff & storage[0x0d] // } // Block ends with conditional jump to 0x09b9, if !(0xff & storage[0x0d] > 0x02) label_09A4: // Incoming jump from 0x09A3, if not !(0xff & storage[0x0d] > 0x02) // Inputs[1] { @09B8 memory[0x00:0x24] } 09A4 63 PUSH4 0x4e487b71 09A9 60 PUSH1 0xe0 09AB 1B SHL 09AC 60 PUSH1 0x00 09AE 52 MSTORE 09AF 60 PUSH1 0x21 09B1 60 PUSH1 0x04 09B3 52 MSTORE 09B4 60 PUSH1 0x24 09B6 60 PUSH1 0x00 09B8 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @09AE memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @09B3 memory[0x04:0x24] = 0x21 // @09B8 revert(memory[0x00:0x24]); // } // Block terminates label_09B9: // Incoming jump from 0x09A3, if !(0xff & storage[0x0d] > 0x02) // Inputs[2] // { // @09BA stack[-2] // @09BA stack[-1] // } 09B9 5B JUMPDEST 09BA 14 EQ 09BB 61 PUSH2 0x09d6 09BE 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x09d6, if stack[-1] == stack[-2] label_09BF: // Incoming jump from 0x09BE, if not stack[-1] == stack[-2] // Inputs[1] { @09C1 memory[0x40:0x60] } 09BF 60 PUSH1 0x40 09C1 51 MLOAD 09C2 62 PUSH3 0x461bcd 09C6 60 PUSH1 0xe5 09C8 1B SHL 09C9 81 DUP2 09CA 52 MSTORE 09CB 60 PUSH1 0x04 09CD 01 ADD 09CE 61 PUSH2 0x06fe 09D1 90 SWAP1 09D2 61 PUSH2 0x248b 09D5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09CA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09D1 stack[0] = 0x06fe // @09D1 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x248b label_09D6: // Incoming jump from 0x09BE, if stack[-1] == stack[-2] // Inputs[1] { @09D9 stack[-1] } 09D6 5B JUMPDEST 09D7 60 PUSH1 0x03 09D9 81 DUP2 09DA 11 GT 09DB 15 ISZERO 09DC 61 PUSH2 0x09f7 09DF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09f7, if !(stack[-1] > 0x03) label_09E0: // Incoming jump from 0x09DF, if not !(stack[-1] > 0x03) // Inputs[1] { @09E2 memory[0x40:0x60] } 09E0 60 PUSH1 0x40 09E2 51 MLOAD 09E3 62 PUSH3 0x461bcd 09E7 60 PUSH1 0xe5 09E9 1B SHL 09EA 81 DUP2 09EB 52 MSTORE 09EC 60 PUSH1 0x04 09EE 01 ADD 09EF 61 PUSH2 0x06fe 09F2 90 SWAP1 09F3 61 PUSH2 0x24db 09F6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09EB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09F2 stack[0] = 0x06fe // @09F2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x24db label_09F7: // Incoming jump from 0x09DF, if !(stack[-1] > 0x03) // Inputs[2] // { // @09F8 stack[-1] // @09FB storage[0x0f] // } 09F7 5B JUMPDEST 09F8 80 DUP1 09F9 60 PUSH1 0x0f 09FB 54 SLOAD 09FC 61 PUSH2 0x0a05 09FF 91 SWAP2 0A00 90 SWAP1 0A01 61 PUSH2 0x26bb 0A04 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09FF stack[0] = 0x0a05 // @0A00 stack[1] = stack[-1] // @0A00 stack[2] = storage[0x0f] // } // Block ends with call to 0x26bb, returns to 0x0A05 label_0A05: // Incoming return from call to 0x26BB at 0x0A04 // Inputs[2] // { // @0A06 msg.value // @0A07 stack[-1] // } 0A05 5B JUMPDEST 0A06 34 CALLVALUE 0A07 14 EQ 0A08 61 PUSH2 0x0a23 0A0B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a23, if msg.value == stack[-1] label_0A0C: // Incoming jump from 0x0A0B, if not msg.value == stack[-1] // Inputs[1] { @0A0E memory[0x40:0x60] } 0A0C 60 PUSH1 0x40 0A0E 51 MLOAD 0A0F 62 PUSH3 0x461bcd 0A13 60 PUSH1 0xe5 0A15 1B SHL 0A16 81 DUP2 0A17 52 MSTORE 0A18 60 PUSH1 0x04 0A1A 01 ADD 0A1B 61 PUSH2 0x06fe 0A1E 90 SWAP1 0A1F 61 PUSH2 0x252b 0A22 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A17 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A1E stack[0] = 0x06fe // @0A1E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x252b label_0A23: // Incoming jump from 0x0A0B, if msg.value == stack[-1] // Inputs[2] // { // @0A27 msg.sender // @0A28 stack[-1] // } 0A23 5B JUMPDEST 0A24 61 PUSH2 0x0a2d 0A27 33 CALLER 0A28 82 DUP3 0A29 61 PUSH2 0x1159 0A2C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A24 stack[0] = 0x0a2d // @0A27 stack[1] = msg.sender // @0A28 stack[2] = stack[-1] // } // Block ends with call to 0x1159, returns to 0x0A2D label_0A2D: // Incoming return from call to 0x1159 at 0x0A2C // Inputs[5] // { // @0A30 storage[0x11] // @0A33 memory[0x40:0x60] // @0A40 msg.value // @0A50 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0A50 address(storage[0x11] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !msg.value).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } 0A2D 5B JUMPDEST 0A2E 60 PUSH1 0x11 0A30 54 SLOAD 0A31 60 PUSH1 0x40 0A33 51 MLOAD 0A34 60 PUSH1 0x01 0A36 60 PUSH1 0x01 0A38 60 PUSH1 0xa0 0A3A 1B SHL 0A3B 03 SUB 0A3C 90 SWAP1 0A3D 91 SWAP2 0A3E 16 AND 0A3F 90 SWAP1 0A40 34 CALLVALUE 0A41 80 DUP1 0A42 15 ISZERO 0A43 61 PUSH2 0x08fc 0A46 02 MUL 0A47 91 SWAP2 0A48 60 PUSH1 0x00 0A4A 81 DUP2 0A4B 81 DUP2 0A4C 81 DUP2 0A4D 85 DUP6 0A4E 88 DUP9 0A4F 88 DUP9 0A50 F1 CALL 0A51 93 SWAP4 0A52 50 POP 0A53 50 POP 0A54 50 POP 0A55 50 POP 0A56 15 ISZERO 0A57 80 DUP1 0A58 15 ISZERO 0A59 61 PUSH2 0x092f 0A5C 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0A50 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(storage[0x11] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !msg.value).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0A56 stack[0] = !address(storage[0x11] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !msg.value).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x092f, if !!address(storage[0x11] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !msg.value).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_0A5D: // Incoming jump from 0x0A5C, if not !!address(storage[0x11] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !msg.value).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @0A5D returndata.length // @0A61 returndata[0x00:0x00 + returndata.length] // @0A62 returndata.length // @0A65 memory[0x00:0x00 + returndata.length] // } 0A5D 3D RETURNDATASIZE 0A5E 60 PUSH1 0x00 0A60 80 DUP1 0A61 3E RETURNDATACOPY 0A62 3D RETURNDATASIZE 0A63 60 PUSH1 0x00 0A65 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A61 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0A65 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0A66: // Incoming jump from 0x042A // Inputs[3] // { // @0A69 stack[-1] // @0A74 memory[0x00:0x40] // @0A75 storage[keccak256(memory[0x00:0x40])] // } 0A66 5B JUMPDEST 0A67 60 PUSH1 0x00 0A69 81 DUP2 0A6A 81 DUP2 0A6B 52 MSTORE 0A6C 60 PUSH1 0x02 0A6E 60 PUSH1 0x20 0A70 52 MSTORE 0A71 60 PUSH1 0x40 0A73 81 DUP2 0A74 20 SHA3 0A75 54 SLOAD 0A76 60 PUSH1 0x01 0A78 60 PUSH1 0x01 0A7A 60 PUSH1 0xa0 0A7C 1B SHL 0A7D 03 SUB 0A7E 16 AND 0A7F 80 DUP1 0A80 61 PUSH2 0x0630 0A83 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0A67 stack[0] = 0x00 // @0A6B memory[0x00:0x20] = stack[-1] // @0A70 memory[0x20:0x40] = 0x02 // @0A7E stack[1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0630, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_0A84: // Incoming jump from 0x0A83, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0A86 memory[0x40:0x60] } 0A84 60 PUSH1 0x40 0A86 51 MLOAD 0A87 62 PUSH3 0x461bcd 0A8B 60 PUSH1 0xe5 0A8D 1B SHL 0A8E 81 DUP2 0A8F 52 MSTORE 0A90 60 PUSH1 0x04 0A92 01 ADD 0A93 61 PUSH2 0x06fe 0A96 90 SWAP1 0A97 61 PUSH2 0x257b 0A9A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A8F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A96 stack[0] = 0x06fe // @0A96 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x257b label_0A9B: // Incoming call from 0x043F, returns to 0x0260 // Inputs[1] { @0A9F storage[0x0b] } 0A9B 5B JUMPDEST 0A9C 60 PUSH1 0x0b 0A9E 80 DUP1 0A9F 54 SLOAD 0AA0 61 PUSH2 0x0aa8 0AA3 90 SWAP1 0AA4 61 PUSH2 0x274f 0AA7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A9C stack[0] = 0x0b // @0AA3 stack[1] = 0x0aa8 // @0AA3 stack[2] = storage[0x0b] // } // Block ends with call to 0x274f, returns to 0x0AA8 label_0AA8: // Incoming return from call to 0x274F at 0x0AA7 // Inputs[4] // { // @0AA9 stack[-1] // @0AB8 memory[0x40:0x60] // @0AC0 stack[-2] // @0ACB storage[stack[-2]] // } 0AA8 5B JUMPDEST 0AA9 80 DUP1 0AAA 60 PUSH1 0x1f 0AAC 01 ADD 0AAD 60 PUSH1 0x20 0AAF 80 DUP1 0AB0 91 SWAP2 0AB1 04 DIV 0AB2 02 MUL 0AB3 60 PUSH1 0x20 0AB5 01 ADD 0AB6 60 PUSH1 0x40 0AB8 51 MLOAD 0AB9 90 SWAP1 0ABA 81 DUP2 0ABB 01 ADD 0ABC 60 PUSH1 0x40 0ABE 52 MSTORE 0ABF 80 DUP1 0AC0 92 SWAP3 0AC1 91 SWAP2 0AC2 90 SWAP1 0AC3 81 DUP2 0AC4 81 DUP2 0AC5 52 MSTORE 0AC6 60 PUSH1 0x20 0AC8 01 ADD 0AC9 82 DUP3 0ACA 80 DUP1 0ACB 54 SLOAD 0ACC 61 PUSH2 0x0ad4 0ACF 90 SWAP1 0AD0 61 PUSH2 0x274f 0AD3 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0ABE memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0AC0 stack[-2] = memory[0x40:0x60] // @0AC1 stack[-1] = stack[-2] // @0AC2 stack[0] = stack[-1] // @0AC5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0AC8 stack[1] = 0x20 + memory[0x40:0x60] // @0AC9 stack[2] = stack[-2] // @0ACF stack[4] = storage[stack[-2]] // @0ACF stack[3] = 0x0ad4 // } // Block ends with call to 0x274f, returns to 0x0AD4 label_0AD4: // Incoming return from call to 0x274F at 0x0AD3 // Inputs[1] { @0AD5 stack[-1] } 0AD4 5B JUMPDEST 0AD5 80 DUP1 0AD6 15 ISZERO 0AD7 61 PUSH2 0x0b21 0ADA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b21, if !stack[-1] label_0ADB: // Incoming jump from 0x0ADA, if not !stack[-1] // Inputs[1] { @0ADB stack[-1] } 0ADB 80 DUP1 0ADC 60 PUSH1 0x1f 0ADE 10 LT 0ADF 61 PUSH2 0x0af6 0AE2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0af6, if 0x1f < stack[-1] label_0AE3: // Incoming jump from 0x0AE2, if not 0x1f < stack[-1] // Inputs[4] // { // @0AE7 stack[-2] // @0AE8 storage[stack[-2]] // @0AEB stack[-3] // @0AED stack[-1] // } 0AE3 61 PUSH2 0x0100 0AE6 80 DUP1 0AE7 83 DUP4 0AE8 54 SLOAD 0AE9 04 DIV 0AEA 02 MUL 0AEB 83 DUP4 0AEC 52 MSTORE 0AED 91 SWAP2 0AEE 60 PUSH1 0x20 0AF0 01 ADD 0AF1 91 SWAP2 0AF2 61 PUSH2 0x0b21 0AF5 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0AEC memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0AF1 stack[-1] = stack[-1] // @0AF1 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0b21 label_0AF6: // Incoming jump from 0x0AE2, if 0x1f < stack[-1] // Inputs[5] // { // @0AF7 stack[-3] // @0AF8 stack[-1] // @0AFA stack[-2] // @0B02 memory[0x00:0x20] // @0B06 storage[keccak256(memory[0x00:0x20])] // } 0AF6 5B JUMPDEST 0AF7 82 DUP3 0AF8 01 ADD 0AF9 91 SWAP2 0AFA 90 SWAP1 0AFB 60 PUSH1 0x00 0AFD 52 MSTORE 0AFE 60 PUSH1 0x20 0B00 60 PUSH1 0x00 0B02 20 SHA3 0B03 90 SWAP1 0B04 5B JUMPDEST 0B05 81 DUP2 0B06 54 SLOAD 0B07 81 DUP2 0B08 52 MSTORE 0B09 90 SWAP1 0B0A 60 PUSH1 0x01 0B0C 01 ADD 0B0D 90 SWAP1 0B0E 60 PUSH1 0x20 0B10 01 ADD 0B11 80 DUP1 0B12 83 DUP4 0B13 11 GT 0B14 61 PUSH2 0x0b04 0B17 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0AF9 stack[-3] = stack[-3] + stack[-1] // @0AFD memory[0x00:0x20] = stack[-2] // @0B08 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0B0D stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0B10 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0b04, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0B18: // Incoming jump from 0x0B17, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0B17, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0B18 stack[-3] // @0B19 stack[-1] // } 0B18 82 DUP3 0B19 90 SWAP1 0B1A 03 SUB 0B1B 60 PUSH1 0x1f 0B1D 16 AND 0B1E 82 DUP3 0B1F 01 ADD 0B20 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0B20 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0B20 stack[-1] = stack[-3] // } // Block continues label_0B21: // Incoming jump from 0x0ADA, if !stack[-1] // Incoming jump from 0x0B20 // Incoming jump from 0x0AF5 // Inputs[1] { @0B27 stack[-7] } 0B21 5B JUMPDEST 0B22 50 POP 0B23 50 POP 0B24 50 POP 0B25 50 POP 0B26 50 POP 0B27 81 DUP2 0B28 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0B29: // Incoming call from 0x1804, returns to 0x1805 // Incoming call from 0x1690, returns to 0x1691 // Inputs[1] { @0B34 stack[-1] } 0B29 5B JUMPDEST 0B2A 60 PUSH1 0x00 0B2C 60 PUSH1 0x01 0B2E 60 PUSH1 0x01 0B30 60 PUSH1 0xa0 0B32 1B SHL 0B33 03 SUB 0B34 82 DUP3 0B35 16 AND 0B36 61 PUSH2 0x0b51 0B39 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B2A stack[0] = 0x00 } // Block ends with conditional jump to 0x0b51, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0B3A: // Incoming jump from 0x0B39, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0B3C memory[0x40:0x60] } 0B3A 60 PUSH1 0x40 0B3C 51 MLOAD 0B3D 62 PUSH3 0x461bcd 0B41 60 PUSH1 0xe5 0B43 1B SHL 0B44 81 DUP2 0B45 52 MSTORE 0B46 60 PUSH1 0x04 0B48 01 ADD 0B49 61 PUSH2 0x06fe 0B4C 90 SWAP1 0B4D 61 PUSH2 0x256b 0B50 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B45 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B4C stack[0] = 0x06fe // @0B4C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x256b label_0B51: // Incoming jump from 0x0B39, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0B5B stack[-2] // @0B69 memory[0x00:0x40] // @0B6A storage[keccak256(memory[0x00:0x40])] // @0B6B stack[-3] // } 0B51 5B JUMPDEST 0B52 50 POP 0B53 60 PUSH1 0x01 0B55 60 PUSH1 0x01 0B57 60 PUSH1 0xa0 0B59 1B SHL 0B5A 03 SUB 0B5B 16 AND 0B5C 60 PUSH1 0x00 0B5E 90 SWAP1 0B5F 81 DUP2 0B60 52 MSTORE 0B61 60 PUSH1 0x03 0B63 60 PUSH1 0x20 0B65 52 MSTORE 0B66 60 PUSH1 0x40 0B68 90 SWAP1 0B69 20 SHA3 0B6A 54 SLOAD 0B6B 90 SWAP1 0B6C 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0B60 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0B65 memory[0x20:0x40] = 0x03 // @0B6B stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0B6D: // Incoming call from 0x0474, returns to 0x02BA // Inputs[2] // { // @0B70 storage[0x0a] // @0B7A msg.sender // } 0B6D 5B JUMPDEST 0B6E 60 PUSH1 0x0a 0B70 54 SLOAD 0B71 60 PUSH1 0x01 0B73 60 PUSH1 0x01 0B75 60 PUSH1 0xa0 0B77 1B SHL 0B78 03 SUB 0B79 16 AND 0B7A 33 CALLER 0B7B 14 EQ 0B7C 61 PUSH2 0x0b97 0B7F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b97, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] label_0B80: // Incoming jump from 0x0B7F, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @0B82 memory[0x40:0x60] } 0B80 60 PUSH1 0x40 0B82 51 MLOAD 0B83 62 PUSH3 0x461bcd 0B87 60 PUSH1 0xe5 0B89 1B SHL 0B8A 81 DUP2 0B8B 52 MSTORE 0B8C 60 PUSH1 0x04 0B8E 01 ADD 0B8F 61 PUSH2 0x06fe 0B92 90 SWAP1 0B93 61 PUSH2 0x25bb 0B96 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B8B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B92 stack[0] = 0x06fe // @0B92 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x25bb, returns to 0x06FE label_0B97: // Incoming jump from 0x0B7F, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] 0B97 5B JUMPDEST 0B98 61 PUSH2 0x0ba1 0B9B 60 PUSH1 0x00 0B9D 61 PUSH2 0x11c0 0BA0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B98 stack[0] = 0x0ba1 // @0B9B stack[1] = 0x00 // } // Block ends with call to 0x11c0, returns to 0x0BA1 label_0BA1: // Incoming return from call to 0x11C0 at 0x0BA0 // Inputs[1] { @0BA2 stack[-1] } 0BA1 5B JUMPDEST 0BA2 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] 0BA3 5B JUMPDEST 0BA4 60 PUSH1 0x0a 0BA6 54 SLOAD 0BA7 60 PUSH1 0x01 0BA9 60 PUSH1 0x01 0BAB 60 PUSH1 0xa0 0BAD 1B SHL 0BAE 03 SUB 0BAF 16 AND 0BB0 33 CALLER 0BB1 14 EQ 0BB2 61 PUSH2 0x0bcd 0BB5 57 *JUMPI 0BB6 60 PUSH1 0x40 0BB8 51 MLOAD 0BB9 62 PUSH3 0x461bcd 0BBD 60 PUSH1 0xe5 0BBF 1B SHL 0BC0 81 DUP2 0BC1 52 MSTORE 0BC2 60 PUSH1 0x04 0BC4 01 ADD 0BC5 61 PUSH2 0x06fe 0BC8 90 SWAP1 0BC9 61 PUSH2 0x25bb 0BCC 56 *JUMP 0BCD 5B JUMPDEST 0BCE 60 PUSH1 0x00 0BD0 5B JUMPDEST 0BD1 82 DUP3 0BD2 51 MLOAD 0BD3 81 DUP2 0BD4 10 LT 0BD5 15 ISZERO 0BD6 61 PUSH2 0x07a4 0BD9 57 *JUMPI 0BDA 81 DUP2 0BDB 60 PUSH1 0x10 0BDD 60 PUSH1 0x00 0BDF 85 DUP6 0BE0 84 DUP5 0BE1 81 DUP2 0BE2 51 MLOAD 0BE3 81 DUP2 0BE4 10 LT 0BE5 61 PUSH2 0x0bfe 0BE8 57 *JUMPI 0BE9 63 PUSH4 0x4e487b71 0BEE 60 PUSH1 0xe0 0BF0 1B SHL 0BF1 60 PUSH1 0x00 0BF3 52 MSTORE 0BF4 60 PUSH1 0x32 0BF6 60 PUSH1 0x04 0BF8 52 MSTORE 0BF9 60 PUSH1 0x24 0BFB 60 PUSH1 0x00 0BFD FD *REVERT 0BFE 5B JUMPDEST 0BFF 60 PUSH1 0x20 0C01 02 MUL 0C02 60 PUSH1 0x20 0C04 01 ADD 0C05 01 ADD 0C06 51 MLOAD 0C07 60 PUSH1 0x01 0C09 60 PUSH1 0x01 0C0B 60 PUSH1 0xa0 0C0D 1B SHL 0C0E 03 SUB 0C0F 16 AND 0C10 60 PUSH1 0x01 0C12 60 PUSH1 0x01 0C14 60 PUSH1 0xa0 0C16 1B SHL 0C17 03 SUB 0C18 16 AND 0C19 81 DUP2 0C1A 52 MSTORE 0C1B 60 PUSH1 0x20 0C1D 01 ADD 0C1E 90 SWAP1 0C1F 81 DUP2 0C20 52 MSTORE 0C21 60 PUSH1 0x20 0C23 01 ADD 0C24 60 PUSH1 0x00 0C26 20 SHA3 0C27 81 DUP2 0C28 90 SWAP1 0C29 55 SSTORE 0C2A 50 POP 0C2B 80 DUP1 0C2C 80 DUP1 0C2D 61 PUSH2 0x0c35 0C30 90 SWAP1 0C31 61 PUSH2 0x27a9 0C34 56 *JUMP 0C35 5B JUMPDEST 0C36 91 SWAP2 0C37 50 POP 0C38 50 POP 0C39 61 PUSH2 0x0bd0 0C3C 56 *JUMP 0C3D 5B JUMPDEST 0C3E 60 PUSH1 0x0a 0C40 54 SLOAD 0C41 60 PUSH1 0x01 0C43 60 PUSH1 0x01 0C45 60 PUSH1 0xa0 0C47 1B SHL 0C48 03 SUB 0C49 16 AND 0C4A 33 CALLER 0C4B 14 EQ 0C4C 61 PUSH2 0x0c67 0C4F 57 *JUMPI 0C50 60 PUSH1 0x40 0C52 51 MLOAD 0C53 62 PUSH3 0x461bcd 0C57 60 PUSH1 0xe5 0C59 1B SHL 0C5A 81 DUP2 0C5B 52 MSTORE 0C5C 60 PUSH1 0x04 0C5E 01 ADD 0C5F 61 PUSH2 0x06fe 0C62 90 SWAP1 0C63 61 PUSH2 0x25bb 0C66 56 *JUMP 0C67 5B JUMPDEST 0C68 80 DUP1 0C69 51 MLOAD 0C6A 61 PUSH2 0x092f 0C6D 90 SWAP1 0C6E 60 PUSH1 0x0c 0C70 90 SWAP1 0C71 60 PUSH1 0x20 0C73 84 DUP5 0C74 01 ADD 0C75 90 SWAP1 0C76 61 PUSH2 0x192c 0C79 56 *JUMP label_0C7A: // Incoming call from 0x051D, returns to 0x0260 // Inputs[1] { @0C80 storage[0x01] } 0C7A 5B JUMPDEST 0C7B 60 PUSH1 0x60 0C7D 60 PUSH1 0x01 0C7F 80 DUP1 0C80 54 SLOAD 0C81 61 PUSH2 0x0647 0C84 90 SWAP1 0C85 61 PUSH2 0x274f 0C88 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0C7B stack[0] = 0x60 // @0C7D stack[1] = 0x01 // @0C84 stack[2] = 0x0647 // @0C84 stack[3] = storage[0x01] // } // Block ends with call to 0x274f, returns to 0x0647 0C89 5B JUMPDEST 0C8A 61 PUSH2 0x092f 0C8D 33 CALLER 0C8E 83 DUP4 0C8F 83 DUP4 0C90 61 PUSH2 0x1212 0C93 56 *JUMP 0C94 5B JUMPDEST 0C95 61 PUSH2 0x0c9e 0C98 33 CALLER 0C99 83 DUP4 0C9A 61 PUSH2 0x0f7a 0C9D 56 *JUMP 0C9E 5B JUMPDEST 0C9F 61 PUSH2 0x0cba 0CA2 57 *JUMPI 0CA3 60 PUSH1 0x40 0CA5 51 MLOAD 0CA6 62 PUSH3 0x461bcd 0CAA 60 PUSH1 0xe5 0CAC 1B SHL 0CAD 81 DUP2 0CAE 52 MSTORE 0CAF 60 PUSH1 0x04 0CB1 01 ADD 0CB2 61 PUSH2 0x06fe 0CB5 90 SWAP1 0CB6 61 PUSH2 0x25fb 0CB9 56 *JUMP 0CBA 5B JUMPDEST 0CBB 61 PUSH2 0x0cc6 0CBE 84 DUP5 0CBF 84 DUP5 0CC0 84 DUP5 0CC1 84 DUP5 0CC2 61 PUSH2 0x12b5 0CC5 56 *JUMP label_0CC6: // Incoming jump from 0x119B, if 0x01 > stack[-2] // Incoming jump from 0x2746, if !(stack[-1] > stack[-4]) // Inputs[1] { @0CCB stack[-5] } 0CC6 5B JUMPDEST 0CC7 50 POP 0CC8 50 POP 0CC9 50 POP 0CCA 50 POP 0CCB 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0CCC: // Incoming jump from 0x0593 // Inputs[3] // { // @0CCF stack[-1] // @0CDA memory[0x00:0x40] // @0CDB storage[keccak256(memory[0x00:0x40])] // } 0CCC 5B JUMPDEST 0CCD 60 PUSH1 0x00 0CCF 81 DUP2 0CD0 81 DUP2 0CD1 52 MSTORE 0CD2 60 PUSH1 0x02 0CD4 60 PUSH1 0x20 0CD6 52 MSTORE 0CD7 60 PUSH1 0x40 0CD9 90 SWAP1 0CDA 20 SHA3 0CDB 54 SLOAD 0CDC 60 PUSH1 0x60 0CDE 90 SWAP1 0CDF 60 PUSH1 0x01 0CE1 60 PUSH1 0x01 0CE3 60 PUSH1 0xa0 0CE5 1B SHL 0CE6 03 SUB 0CE7 16 AND 0CE8 61 PUSH2 0x0d03 0CEB 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0CD1 memory[0x00:0x20] = stack[-1] // @0CD6 memory[0x20:0x40] = 0x02 // @0CDE stack[0] = 0x60 // } // Block ends with conditional jump to 0x0d03, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_0CEC: // Incoming jump from 0x0CEB, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0CEE memory[0x40:0x60] } 0CEC 60 PUSH1 0x40 0CEE 51 MLOAD 0CEF 62 PUSH3 0x461bcd 0CF3 60 PUSH1 0xe5 0CF5 1B SHL 0CF6 81 DUP2 0CF7 52 MSTORE 0CF8 60 PUSH1 0x04 0CFA 01 ADD 0CFB 61 PUSH2 0x06fe 0CFE 90 SWAP1 0CFF 61 PUSH2 0x25db 0D02 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0CF7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CFE stack[0] = 0x06fe // @0CFE stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x25db label_0D03: // Incoming jump from 0x0CEB, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] 0D03 5B JUMPDEST 0D04 60 PUSH1 0x00 0D06 61 PUSH2 0x0d0d 0D09 61 PUSH2 0x12e8 0D0C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D04 stack[0] = 0x00 // @0D06 stack[1] = 0x0d0d // } // Block ends with unconditional jump to 0x12e8 0D0D 5B JUMPDEST 0D0E 90 SWAP1 0D0F 50 POP 0D10 60 PUSH1 0x00 0D12 81 DUP2 0D13 51 MLOAD 0D14 11 GT 0D15 61 PUSH2 0x0d2d 0D18 57 *JUMPI 0D19 60 PUSH1 0x40 0D1B 51 MLOAD 0D1C 80 DUP1 0D1D 60 PUSH1 0x20 0D1F 01 ADD 0D20 60 PUSH1 0x40 0D22 52 MSTORE 0D23 80 DUP1 0D24 60 PUSH1 0x00 0D26 81 DUP2 0D27 52 MSTORE 0D28 50 POP 0D29 61 PUSH2 0x0d58 0D2C 56 *JUMP 0D2D 5B JUMPDEST 0D2E 80 DUP1 0D2F 61 PUSH2 0x0d37 0D32 84 DUP5 0D33 61 PUSH2 0x12f7 0D36 56 *JUMP 0D37 5B JUMPDEST 0D38 60 PUSH1 0x40 0D3A 51 MLOAD 0D3B 60 PUSH1 0x20 0D3D 01 ADD 0D3E 61 PUSH2 0x0d48 0D41 92 SWAP3 0D42 91 SWAP2 0D43 90 SWAP1 0D44 61 PUSH2 0x23f4 0D47 56 *JUMP 0D48 5B JUMPDEST 0D49 60 PUSH1 0x40 0D4B 51 MLOAD 0D4C 60 PUSH1 0x20 0D4E 81 DUP2 0D4F 83 DUP4 0D50 03 SUB 0D51 03 SUB 0D52 81 DUP2 0D53 52 MSTORE 0D54 90 SWAP1 0D55 60 PUSH1 0x40 0D57 52 MSTORE label_0D58: // Incoming return from call to 0x1D62 at 0x248A // Inputs[3] // { // @0D59 stack[-5] // @0D59 stack[-1] // @0D5A stack[-4] // } 0D58 5B JUMPDEST 0D59 93 SWAP4 0D5A 92 SWAP3 0D5B 50 POP 0D5C 50 POP 0D5D 50 POP 0D5E 56 *JUMP // Stack delta = -4 // Outputs[1] { @0D59 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0D5F: // Incoming call from 0x05A8, returns to 0x0260 // Inputs[1] { @0D65 storage[0x0c] } 0D5F 5B JUMPDEST 0D60 60 PUSH1 0x60 0D62 60 PUSH1 0x0c 0D64 80 DUP1 0D65 54 SLOAD 0D66 61 PUSH2 0x0647 0D69 90 SWAP1 0D6A 61 PUSH2 0x274f 0D6D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D60 stack[0] = 0x60 // @0D62 stack[1] = 0x0c // @0D69 stack[2] = 0x0647 // @0D69 stack[3] = storage[0x0c] // } // Block ends with call to 0x274f, returns to 0x0647 0D6E 5B JUMPDEST 0D6F 60 PUSH1 0x0a 0D71 54 SLOAD 0D72 60 PUSH1 0x01 0D74 60 PUSH1 0x01 0D76 60 PUSH1 0xa0 0D78 1B SHL 0D79 03 SUB 0D7A 16 AND 0D7B 33 CALLER 0D7C 14 EQ 0D7D 61 PUSH2 0x0d98 0D80 57 *JUMPI 0D81 60 PUSH1 0x40 0D83 51 MLOAD 0D84 62 PUSH3 0x461bcd 0D88 60 PUSH1 0xe5 0D8A 1B SHL 0D8B 81 DUP2 0D8C 52 MSTORE 0D8D 60 PUSH1 0x04 0D8F 01 ADD 0D90 61 PUSH2 0x06fe 0D93 90 SWAP1 0D94 61 PUSH2 0x25bb 0D97 56 *JUMP 0D98 5B JUMPDEST 0D99 60 PUSH1 0x01 0D9B 60 PUSH1 0x01 0D9D 60 PUSH1 0xa0 0D9F 1B SHL 0DA0 03 SUB 0DA1 81 DUP2 0DA2 16 AND 0DA3 61 PUSH2 0x0dbe 0DA6 57 *JUMPI 0DA7 60 PUSH1 0x40 0DA9 51 MLOAD 0DAA 62 PUSH3 0x461bcd 0DAE 60 PUSH1 0xe5 0DB0 1B SHL 0DB1 81 DUP2 0DB2 52 MSTORE 0DB3 60 PUSH1 0x04 0DB5 01 ADD 0DB6 61 PUSH2 0x06fe 0DB9 90 SWAP1 0DBA 61 PUSH2 0x24cb 0DBD 56 *JUMP 0DBE 5B JUMPDEST 0DBF 61 PUSH2 0x0dc7 0DC2 81 DUP2 0DC3 61 PUSH2 0x11c0 0DC6 56 *JUMP label_0DC7: // Incoming jump from 0x2865, if stack[-2] == stack[-1] // Incoming jump from 0x284E, if stack[-1] < 0x03 // Incoming jump from 0x288A, if stack[-1] < 0x03 // Inputs[1] { @0DC9 stack[-2] } 0DC7 5B JUMPDEST 0DC8 50 POP 0DC9 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0DCA: // Incoming jump from 0x0624 // Inputs[1] { @0DCF storage[0x0d] } 0DCA 5B JUMPDEST 0DCB 60 PUSH1 0x01 0DCD 60 PUSH1 0x0d 0DCF 54 SLOAD 0DD0 60 PUSH1 0xff 0DD2 16 AND 0DD3 60 PUSH1 0x02 0DD5 81 DUP2 0DD6 11 GT 0DD7 15 ISZERO 0DD8 61 PUSH2 0x0df1 0DDB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0DCB stack[0] = 0x01 // @0DD2 stack[1] = 0xff & storage[0x0d] // } // Block ends with conditional jump to 0x0df1, if !(0xff & storage[0x0d] > 0x02) label_0DDC: // Incoming jump from 0x0DDB, if not !(0xff & storage[0x0d] > 0x02) // Inputs[1] { @0DF0 memory[0x00:0x24] } 0DDC 63 PUSH4 0x4e487b71 0DE1 60 PUSH1 0xe0 0DE3 1B SHL 0DE4 60 PUSH1 0x00 0DE6 52 MSTORE 0DE7 60 PUSH1 0x21 0DE9 60 PUSH1 0x04 0DEB 52 MSTORE 0DEC 60 PUSH1 0x24 0DEE 60 PUSH1 0x00 0DF0 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0DE6 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0DEB memory[0x04:0x24] = 0x21 // @0DF0 revert(memory[0x00:0x24]); // } // Block terminates label_0DF1: // Incoming jump from 0x0DDB, if !(0xff & storage[0x0d] > 0x02) // Inputs[2] // { // @0DF2 stack[-2] // @0DF2 stack[-1] // } 0DF1 5B JUMPDEST 0DF2 14 EQ 0DF3 61 PUSH2 0x0e0e 0DF6 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0e0e, if stack[-1] == stack[-2] label_0DF7: // Incoming jump from 0x0DF6, if not stack[-1] == stack[-2] // Inputs[1] { @0DF9 memory[0x40:0x60] } 0DF7 60 PUSH1 0x40 0DF9 51 MLOAD 0DFA 62 PUSH3 0x461bcd 0DFE 60 PUSH1 0xe5 0E00 1B SHL 0E01 81 DUP2 0E02 52 MSTORE 0E03 60 PUSH1 0x04 0E05 01 ADD 0E06 61 PUSH2 0x06fe 0E09 90 SWAP1 0E0A 61 PUSH2 0x24fb 0E0D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E02 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E09 stack[0] = 0x06fe // @0E09 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x24fb label_0E0E: // Incoming jump from 0x0DF6, if stack[-1] == stack[-2] // Inputs[3] // { // @0E0F msg.sender // @0E1D memory[0x00:0x40] // @0E1E storage[keccak256(memory[0x00:0x40])] // } 0E0E 5B JUMPDEST 0E0F 33 CALLER 0E10 60 PUSH1 0x00 0E12 90 SWAP1 0E13 81 DUP2 0E14 52 MSTORE 0E15 60 PUSH1 0x10 0E17 60 PUSH1 0x20 0E19 52 MSTORE 0E1A 60 PUSH1 0x40 0E1C 90 SWAP1 0E1D 20 SHA3 0E1E 54 SLOAD 0E1F 80 DUP1 0E20 61 PUSH2 0x0e3b 0E23 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0E14 memory[0x00:0x20] = msg.sender // @0E19 memory[0x20:0x40] = 0x10 // @0E1E stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0e3b, if storage[keccak256(memory[0x00:0x40])] label_0E24: // Incoming jump from 0x0E23, if not storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0E26 memory[0x40:0x60] } 0E24 60 PUSH1 0x40 0E26 51 MLOAD 0E27 62 PUSH3 0x461bcd 0E2B 60 PUSH1 0xe5 0E2D 1B SHL 0E2E 81 DUP2 0E2F 52 MSTORE 0E30 60 PUSH1 0x04 0E32 01 ADD 0E33 61 PUSH2 0x06fe 0E36 90 SWAP1 0E37 61 PUSH2 0x253b 0E3A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E2F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E36 stack[0] = 0x06fe // @0E36 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x253b label_0E3B: // Incoming jump from 0x0E23, if storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @0E3C stack[-1] // @0E3D stack[-2] // } 0E3B 5B JUMPDEST 0E3C 80 DUP1 0E3D 82 DUP3 0E3E 11 GT 0E3F 15 ISZERO 0E40 61 PUSH2 0x0e5b 0E43 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e5b, if !(stack[-2] > stack[-1]) label_0E44: // Incoming jump from 0x0E43, if not !(stack[-2] > stack[-1]) // Inputs[1] { @0E46 memory[0x40:0x60] } 0E44 60 PUSH1 0x40 0E46 51 MLOAD 0E47 62 PUSH3 0x461bcd 0E4B 60 PUSH1 0xe5 0E4D 1B SHL 0E4E 81 DUP2 0E4F 52 MSTORE 0E50 60 PUSH1 0x04 0E52 01 ADD 0E53 61 PUSH2 0x06fe 0E56 90 SWAP1 0E57 61 PUSH2 0x249b 0E5A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E4F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E56 stack[0] = 0x06fe // @0E56 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x249b label_0E5B: // Incoming jump from 0x0E43, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @0E5C stack[-2] // @0E5F storage[0x0e] // } 0E5B 5B JUMPDEST 0E5C 81 DUP2 0E5D 60 PUSH1 0x0e 0E5F 54 SLOAD 0E60 61 PUSH2 0x0e69 0E63 91 SWAP2 0E64 90 SWAP1 0E65 61 PUSH2 0x26bb 0E68 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E63 stack[0] = 0x0e69 // @0E64 stack[1] = stack[-2] // @0E64 stack[2] = storage[0x0e] // } // Block ends with call to 0x26bb, returns to 0x0E69 label_0E69: // Incoming return from call to 0x26BB at 0x0E68 // Inputs[2] // { // @0E6A msg.value // @0E6B stack[-1] // } 0E69 5B JUMPDEST 0E6A 34 CALLVALUE 0E6B 14 EQ 0E6C 61 PUSH2 0x0e87 0E6F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e87, if msg.value == stack[-1] label_0E70: // Incoming jump from 0x0E6F, if not msg.value == stack[-1] // Inputs[1] { @0E72 memory[0x40:0x60] } 0E70 60 PUSH1 0x40 0E72 51 MLOAD 0E73 62 PUSH3 0x461bcd 0E77 60 PUSH1 0xe5 0E79 1B SHL 0E7A 81 DUP2 0E7B 52 MSTORE 0E7C 60 PUSH1 0x04 0E7E 01 ADD 0E7F 61 PUSH2 0x06fe 0E82 90 SWAP1 0E83 61 PUSH2 0x252b 0E86 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E7B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E82 stack[0] = 0x06fe // @0E82 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x252b label_0E87: // Incoming jump from 0x0E6F, if msg.value == stack[-1] // Inputs[2] // { // @0E8B stack[-2] // @0E8C stack[-1] // } 0E87 5B JUMPDEST 0E88 61 PUSH2 0x0e91 0E8B 82 DUP3 0E8C 82 DUP3 0E8D 61 PUSH2 0x26da 0E90 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E88 stack[0] = 0x0e91 // @0E8B stack[1] = stack[-2] // @0E8C stack[2] = stack[-1] // } // Block ends with call to 0x26da, returns to 0x0E91 label_0E91: // Incoming return from call to 0x26DA at 0x0E90 // Inputs[4] // { // @0E92 msg.sender // @0EA0 memory[0x00:0x40] // @0EA1 stack[-1] // @0EA9 stack[-3] // } 0E91 5B JUMPDEST 0E92 33 CALLER 0E93 60 PUSH1 0x00 0E95 81 DUP2 0E96 81 DUP2 0E97 52 MSTORE 0E98 60 PUSH1 0x10 0E9A 60 PUSH1 0x20 0E9C 52 MSTORE 0E9D 60 PUSH1 0x40 0E9F 90 SWAP1 0EA0 20 SHA3 0EA1 91 SWAP2 0EA2 90 SWAP1 0EA3 91 SWAP2 0EA4 55 SSTORE 0EA5 61 PUSH2 0x0eae 0EA8 90 SWAP1 0EA9 83 DUP4 0EAA 61 PUSH2 0x1159 0EAD 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @0E97 memory[0x00:0x20] = msg.sender // @0E9C memory[0x20:0x40] = 0x10 // @0EA4 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0EA8 stack[0] = msg.sender // @0EA8 stack[-1] = 0x0eae // @0EA9 stack[1] = stack[-3] // } // Block ends with call to 0x1159, returns to 0x0EAE label_0EAE: // Incoming return from call to 0x1159 at 0x0EAD // Inputs[5] // { // @0EB1 storage[0x11] // @0EB4 memory[0x40:0x60] // @0EC1 msg.value // @0ED1 address(storage[0x11] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !msg.value).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0ED1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // } 0EAE 5B JUMPDEST 0EAF 60 PUSH1 0x11 0EB1 54 SLOAD 0EB2 60 PUSH1 0x40 0EB4 51 MLOAD 0EB5 60 PUSH1 0x01 0EB7 60 PUSH1 0x01 0EB9 60 PUSH1 0xa0 0EBB 1B SHL 0EBC 03 SUB 0EBD 90 SWAP1 0EBE 91 SWAP2 0EBF 16 AND 0EC0 90 SWAP1 0EC1 34 CALLVALUE 0EC2 80 DUP1 0EC3 15 ISZERO 0EC4 61 PUSH2 0x08fc 0EC7 02 MUL 0EC8 91 SWAP2 0EC9 60 PUSH1 0x00 0ECB 81 DUP2 0ECC 81 DUP2 0ECD 81 DUP2 0ECE 85 DUP6 0ECF 88 DUP9 0ED0 88 DUP9 0ED1 F1 CALL 0ED2 93 SWAP4 0ED3 50 POP 0ED4 50 POP 0ED5 50 POP 0ED6 50 POP 0ED7 15 ISZERO 0ED8 80 DUP1 0ED9 15 ISZERO 0EDA 61 PUSH2 0x07a4 0EDD 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0ED1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(storage[0x11] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !msg.value).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0ED7 stack[0] = !address(storage[0x11] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !msg.value).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x07a4, if !!address(storage[0x11] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !msg.value).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_0EDE: // Incoming jump from 0x0EDD, if not !!address(storage[0x11] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !msg.value).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @0EDE returndata.length // @0EE2 returndata[0x00:0x00 + returndata.length] // @0EE3 returndata.length // @0EE6 memory[0x00:0x00 + returndata.length] // } 0EDE 3D RETURNDATASIZE 0EDF 60 PUSH1 0x00 0EE1 80 DUP1 0EE2 3E RETURNDATACOPY 0EE3 3D RETURNDATASIZE 0EE4 60 PUSH1 0x00 0EE6 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0EE2 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0EE6 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0EE7: // Incoming call from 0x062F, returns to 0x0630 // Inputs[1] { @0EF3 stack[-1] } 0EE7 5B JUMPDEST 0EE8 60 PUSH1 0x00 0EEA 60 PUSH1 0x01 0EEC 60 PUSH1 0x01 0EEE 60 PUSH1 0xe0 0EF0 1B SHL 0EF1 03 SUB 0EF2 19 NOT 0EF3 82 DUP3 0EF4 16 AND 0EF5 63 PUSH4 0x780e9d63 0EFA 60 PUSH1 0xe0 0EFC 1B SHL 0EFD 14 EQ 0EFE 80 DUP1 0EFF 61 PUSH2 0x0630 0F02 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0EE8 stack[0] = 0x00 // @0EFD stack[1] = 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0630, if 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_0F03: // Incoming jump from 0x0F02, if not 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0F07 stack[-3] } 0F03 50 POP 0F04 61 PUSH2 0x0630 0F07 82 DUP3 0F08 61 PUSH2 0x1412 0F0B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0F04 stack[-1] = 0x0630 // @0F07 stack[0] = stack[-3] // } // Block ends with call to 0x1412, returns to 0x0630 0F0C 5B JUMPDEST 0F0D 60 PUSH1 0x00 0F0F 81 DUP2 0F10 81 DUP2 0F11 52 MSTORE 0F12 60 PUSH1 0x04 0F14 60 PUSH1 0x20 0F16 52 MSTORE 0F17 60 PUSH1 0x40 0F19 90 SWAP1 0F1A 20 SHA3 0F1B 80 DUP1 0F1C 54 SLOAD 0F1D 60 PUSH1 0x01 0F1F 60 PUSH1 0x01 0F21 60 PUSH1 0xa0 0F23 1B SHL 0F24 03 SUB 0F25 19 NOT 0F26 16 AND 0F27 60 PUSH1 0x01 0F29 60 PUSH1 0x01 0F2B 60 PUSH1 0xa0 0F2D 1B SHL 0F2E 03 SUB 0F2F 84 DUP5 0F30 16 AND 0F31 90 SWAP1 0F32 81 DUP2 0F33 17 OR 0F34 90 SWAP1 0F35 91 SWAP2 0F36 55 SSTORE 0F37 81 DUP2 0F38 90 SWAP1 0F39 61 PUSH2 0x0f41 0F3C 82 DUP3 0F3D 61 PUSH2 0x0a66 0F40 56 *JUMP 0F41 5B JUMPDEST 0F42 60 PUSH1 0x01 0F44 60 PUSH1 0x01 0F46 60 PUSH1 0xa0 0F48 1B SHL 0F49 03 SUB 0F4A 16 AND 0F4B 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0F6C 60 PUSH1 0x40 0F6E 51 MLOAD 0F6F 60 PUSH1 0x40 0F71 51 MLOAD 0F72 80 DUP1 0F73 91 SWAP2 0F74 03 SUB 0F75 90 SWAP1 0F76 A4 LOG4 0F77 50 POP 0F78 50 POP 0F79 56 *JUMP 0F7A 5B JUMPDEST 0F7B 60 PUSH1 0x00 0F7D 81 DUP2 0F7E 81 DUP2 0F7F 52 MSTORE 0F80 60 PUSH1 0x02 0F82 60 PUSH1 0x20 0F84 52 MSTORE 0F85 60 PUSH1 0x40 0F87 81 DUP2 0F88 20 SHA3 0F89 54 SLOAD 0F8A 60 PUSH1 0x01 0F8C 60 PUSH1 0x01 0F8E 60 PUSH1 0xa0 0F90 1B SHL 0F91 03 SUB 0F92 16 AND 0F93 61 PUSH2 0x0fae 0F96 57 *JUMPI 0F97 60 PUSH1 0x40 0F99 51 MLOAD 0F9A 62 PUSH3 0x461bcd 0F9E 60 PUSH1 0xe5 0FA0 1B SHL 0FA1 81 DUP2 0FA2 52 MSTORE 0FA3 60 PUSH1 0x04 0FA5 01 ADD 0FA6 61 PUSH2 0x06fe 0FA9 90 SWAP1 0FAA 61 PUSH2 0x254b 0FAD 56 *JUMP 0FAE 5B JUMPDEST 0FAF 60 PUSH1 0x00 0FB1 61 PUSH2 0x0fb9 0FB4 83 DUP4 0FB5 61 PUSH2 0x0a66 0FB8 56 *JUMP 0FB9 5B JUMPDEST 0FBA 90 SWAP1 0FBB 50 POP 0FBC 80 DUP1 0FBD 60 PUSH1 0x01 0FBF 60 PUSH1 0x01 0FC1 60 PUSH1 0xa0 0FC3 1B SHL 0FC4 03 SUB 0FC5 16 AND 0FC6 84 DUP5 0FC7 60 PUSH1 0x01 0FC9 60 PUSH1 0x01 0FCB 60 PUSH1 0xa0 0FCD 1B SHL 0FCE 03 SUB 0FCF 16 AND 0FD0 14 EQ 0FD1 80 DUP1 0FD2 61 PUSH2 0x0ff4 0FD5 57 *JUMPI 0FD6 50 POP 0FD7 83 DUP4 0FD8 60 PUSH1 0x01 0FDA 60 PUSH1 0x01 0FDC 60 PUSH1 0xa0 0FDE 1B SHL 0FDF 03 SUB 0FE0 16 AND 0FE1 61 PUSH2 0x0fe9 0FE4 84 DUP5 0FE5 61 PUSH2 0x06ca 0FE8 56 *JUMP 0FE9 5B JUMPDEST 0FEA 60 PUSH1 0x01 0FEC 60 PUSH1 0x01 0FEE 60 PUSH1 0xa0 0FF0 1B SHL 0FF1 03 SUB 0FF2 16 AND 0FF3 14 EQ 0FF4 5B JUMPDEST 0FF5 80 DUP1 0FF6 61 PUSH2 0x1024 0FF9 57 *JUMPI 0FFA 50 POP 0FFB 60 PUSH1 0x01 0FFD 60 PUSH1 0x01 0FFF 60 PUSH1 0xa0 1001 1B SHL 1002 03 SUB 1003 80 DUP1 1004 82 DUP3 1005 16 AND 1006 60 PUSH1 0x00 1008 90 SWAP1 1009 81 DUP2 100A 52 MSTORE 100B 60 PUSH1 0x05 100D 60 PUSH1 0x20 100F 90 SWAP1 1010 81 DUP2 1011 52 MSTORE 1012 60 PUSH1 0x40 1014 80 DUP1 1015 83 DUP4 1016 20 SHA3 1017 93 SWAP4 1018 88 DUP9 1019 16 AND 101A 83 DUP4 101B 52 MSTORE 101C 92 SWAP3 101D 90 SWAP1 101E 52 MSTORE 101F 20 SHA3 1020 54 SLOAD 1021 60 PUSH1 0xff 1023 16 AND label_1024: // Incoming return from call to 0x1A9D at 0x1CBB // Incoming return from call to 0x1ADF at 0x1D4A // Incoming return from call to 0x1AD4 at 0x1CF7 // Inputs[3] // { // @1025 stack[-1] // @1025 stack[-6] // @1026 stack[-5] // } 1024 5B JUMPDEST 1025 94 SWAP5 1026 93 SWAP4 1027 50 POP 1028 50 POP 1029 50 POP 102A 50 POP 102B 56 *JUMP // Stack delta = -5 // Outputs[1] { @1025 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] 102C 5B JUMPDEST 102D 82 DUP3 102E 60 PUSH1 0x01 1030 60 PUSH1 0x01 1032 60 PUSH1 0xa0 1034 1B SHL 1035 03 SUB 1036 16 AND 1037 61 PUSH2 0x103f 103A 82 DUP3 103B 61 PUSH2 0x0a66 103E 56 *JUMP 103F 5B JUMPDEST 1040 60 PUSH1 0x01 1042 60 PUSH1 0x01 1044 60 PUSH1 0xa0 1046 1B SHL 1047 03 SUB 1048 16 AND 1049 14 EQ 104A 61 PUSH2 0x1065 104D 57 *JUMPI 104E 60 PUSH1 0x40 1050 51 MLOAD 1051 62 PUSH3 0x461bcd 1055 60 PUSH1 0xe5 1057 1B SHL 1058 81 DUP2 1059 52 MSTORE 105A 60 PUSH1 0x04 105C 01 ADD 105D 61 PUSH2 0x06fe 1060 90 SWAP1 1061 61 PUSH2 0x25cb 1064 56 *JUMP 1065 5B JUMPDEST 1066 60 PUSH1 0x01 1068 60 PUSH1 0x01 106A 60 PUSH1 0xa0 106C 1B SHL 106D 03 SUB 106E 82 DUP3 106F 16 AND 1070 61 PUSH2 0x108b 1073 57 *JUMPI 1074 60 PUSH1 0x40 1076 51 MLOAD 1077 62 PUSH3 0x461bcd 107B 60 PUSH1 0xe5 107D 1B SHL 107E 81 DUP2 107F 52 MSTORE 1080 60 PUSH1 0x04 1082 01 ADD 1083 61 PUSH2 0x06fe 1086 90 SWAP1 1087 61 PUSH2 0x250b 108A 56 *JUMP 108B 5B JUMPDEST 108C 61 PUSH2 0x1096 108F 83 DUP4 1090 83 DUP4 1091 83 DUP4 1092 61 PUSH2 0x1462 1095 56 *JUMP 1096 5B JUMPDEST 1097 61 PUSH2 0x10a1 109A 60 PUSH1 0x00 109C 82 DUP3 109D 61 PUSH2 0x0f0c 10A0 56 *JUMP 10A1 5B JUMPDEST 10A2 60 PUSH1 0x01 10A4 60 PUSH1 0x01 10A6 60 PUSH1 0xa0 10A8 1B SHL 10A9 03 SUB 10AA 83 DUP4 10AB 16 AND 10AC 60 PUSH1 0x00 10AE 90 SWAP1 10AF 81 DUP2 10B0 52 MSTORE 10B1 60 PUSH1 0x03 10B3 60 PUSH1 0x20 10B5 52 MSTORE 10B6 60 PUSH1 0x40 10B8 81 DUP2 10B9 20 SHA3 10BA 80 DUP1 10BB 54 SLOAD 10BC 60 PUSH1 0x01 10BE 92 SWAP3 10BF 90 SWAP1 10C0 61 PUSH2 0x10ca 10C3 90 SWAP1 10C4 84 DUP5 10C5 90 SWAP1 10C6 61 PUSH2 0x26da 10C9 56 *JUMP 10CA 5B JUMPDEST 10CB 90 SWAP1 10CC 91 SWAP2 10CD 55 SSTORE 10CE 50 POP 10CF 50 POP 10D0 60 PUSH1 0x01 10D2 60 PUSH1 0x01 10D4 60 PUSH1 0xa0 10D6 1B SHL 10D7 03 SUB 10D8 82 DUP3 10D9 16 AND 10DA 60 PUSH1 0x00 10DC 90 SWAP1 10DD 81 DUP2 10DE 52 MSTORE 10DF 60 PUSH1 0x03 10E1 60 PUSH1 0x20 10E3 52 MSTORE 10E4 60 PUSH1 0x40 10E6 81 DUP2 10E7 20 SHA3 10E8 80 DUP1 10E9 54 SLOAD 10EA 60 PUSH1 0x01 10EC 92 SWAP3 10ED 90 SWAP1 10EE 61 PUSH2 0x10f8 10F1 90 SWAP1 10F2 84 DUP5 10F3 90 SWAP1 10F4 61 PUSH2 0x268f 10F7 56 *JUMP 10F8 5B JUMPDEST 10F9 90 SWAP1 10FA 91 SWAP2 10FB 55 SSTORE 10FC 50 POP 10FD 50 POP 10FE 60 PUSH1 0x00 1100 81 DUP2 1101 81 DUP2 1102 52 MSTORE 1103 60 PUSH1 0x02 1105 60 PUSH1 0x20 1107 52 MSTORE 1108 60 PUSH1 0x40 110A 80 DUP1 110B 82 DUP3 110C 20 SHA3 110D 80 DUP1 110E 54 SLOAD 110F 60 PUSH1 0x01 1111 60 PUSH1 0x01 1113 60 PUSH1 0xa0 1115 1B SHL 1116 03 SUB 1117 19 NOT 1118 16 AND 1119 60 PUSH1 0x01 111B 60 PUSH1 0x01 111D 60 PUSH1 0xa0 111F 1B SHL 1120 03 SUB 1121 86 DUP7 1122 81 DUP2 1123 16 AND 1124 91 SWAP2 1125 82 DUP3 1126 17 OR 1127 90 SWAP1 1128 92 SWAP3 1129 55 SSTORE 112A 91 SWAP2 112B 51 MLOAD 112C 84 DUP5 112D 93 SWAP4 112E 91 SWAP2 112F 87 DUP8 1130 16 AND 1131 91 SWAP2 1132 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1153 91 SWAP2 1154 A4 LOG4 1155 50 POP 1156 50 POP 1157 50 POP 1158 56 *JUMP label_1159: // Incoming call from 0x0A2C, returns to 0x0A2D // Incoming call from 0x0EAD, returns to 0x0EAE // Inputs[1] { @1161 storage[0x08] } 1159 5B JUMPDEST 115A 60 PUSH1 0x00 115C 61 PUSH2 0x1164 115F 60 PUSH1 0x08 1161 54 SLOAD 1162 90 SWAP1 1163 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @115A stack[0] = 0x00 // @1162 stack[1] = storage[0x08] // } // Block ends with unconditional jump to 0x1164 label_1164: // Incoming jump from 0x1163 // Inputs[3] // { // @1165 stack[-2] // @1165 stack[-1] // @116D stack[-3] // } 1164 5B JUMPDEST 1165 90 SWAP1 1166 50 POP 1167 61 PUSH2 0x1388 116A 61 PUSH2 0x1173 116D 83 DUP4 116E 83 DUP4 116F 61 PUSH2 0x268f 1172 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1165 stack[-2] = stack[-1] // @1167 stack[-1] = 0x1388 // @116A stack[0] = 0x1173 // @116D stack[1] = stack[-3] // @116E stack[2] = stack[-1] // } // Block ends with call to 0x268f, returns to 0x1173 label_1173: // Incoming return from call to 0x268F at 0x1172 // Inputs[2] // { // @1174 stack[-1] // @1174 stack[-2] // } 1173 5B JUMPDEST 1174 11 GT 1175 15 ISZERO 1176 61 PUSH2 0x1191 1179 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1191, if !(stack[-1] > stack[-2]) label_117A: // Incoming jump from 0x1179, if not !(stack[-1] > stack[-2]) // Inputs[1] { @117C memory[0x40:0x60] } 117A 60 PUSH1 0x40 117C 51 MLOAD 117D 62 PUSH3 0x461bcd 1181 60 PUSH1 0xe5 1183 1B SHL 1184 81 DUP2 1185 52 MSTORE 1186 60 PUSH1 0x04 1188 01 ADD 1189 61 PUSH2 0x06fe 118C 90 SWAP1 118D 61 PUSH2 0x259b 1190 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1185 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @118C stack[0] = 0x06fe // @118C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x259b label_1191: // Incoming jump from 0x1179, if !(stack[-1] > stack[-2]) // Inputs[1] { @1195 stack[-2] } 1191 5B JUMPDEST 1192 60 PUSH1 0x01 1194 5B JUMPDEST 1195 82 DUP3 1196 81 DUP2 1197 11 GT 1198 61 PUSH2 0x0cc6 119B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1192 stack[0] = 0x01 } // Block ends with conditional jump to 0x0cc6, if 0x01 > stack[-2] label_119C: // Incoming jump from 0x119B, if not 0x01 > stack[-2] // Inputs[3] // { // @119F stack[-4] // @11A3 stack[-1] // @11A4 stack[-2] // } 119C 61 PUSH2 0x11ae 119F 84 DUP5 11A0 61 PUSH2 0x11a9 11A3 83 DUP4 11A4 85 DUP6 11A5 61 PUSH2 0x268f 11A8 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @119C stack[0] = 0x11ae // @119F stack[1] = stack[-4] // @11A0 stack[2] = 0x11a9 // @11A3 stack[3] = stack[-1] // @11A4 stack[4] = stack[-2] // } // Block ends with call to 0x268f, returns to 0x11A9 label_11A9: // Incoming return from call to 0x268F at 0x11A8 11A9 5B JUMPDEST 11AA 61 PUSH2 0x146d 11AD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x146d 11AE 5B JUMPDEST 11AF 80 DUP1 11B0 61 PUSH2 0x11b8 11B3 81 DUP2 11B4 61 PUSH2 0x27a9 11B7 56 *JUMP 11B8 5B JUMPDEST 11B9 91 SWAP2 11BA 50 POP 11BB 50 POP 11BC 61 PUSH2 0x1194 11BF 56 *JUMP label_11C0: // Incoming call from 0x0BA0, returns to 0x0BA1 // Inputs[5] // { // @11C4 storage[0x0a] // @11CD stack[-1] // @11E2 memory[0x40:0x60] // @120E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1211 stack[-2] // } 11C0 5B JUMPDEST 11C1 60 PUSH1 0x0a 11C3 80 DUP1 11C4 54 SLOAD 11C5 60 PUSH1 0x01 11C7 60 PUSH1 0x01 11C9 60 PUSH1 0xa0 11CB 1B SHL 11CC 03 SUB 11CD 83 DUP4 11CE 81 DUP2 11CF 16 AND 11D0 60 PUSH1 0x01 11D2 60 PUSH1 0x01 11D4 60 PUSH1 0xa0 11D6 1B SHL 11D7 03 SUB 11D8 19 NOT 11D9 83 DUP4 11DA 16 AND 11DB 81 DUP2 11DC 17 OR 11DD 90 SWAP1 11DE 93 SWAP4 11DF 55 SSTORE 11E0 60 PUSH1 0x40 11E2 51 MLOAD 11E3 91 SWAP2 11E4 16 AND 11E5 91 SWAP2 11E6 90 SWAP1 11E7 82 DUP3 11E8 90 SWAP1 11E9 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 120A 90 SWAP1 120B 60 PUSH1 0x00 120D 90 SWAP1 120E A3 LOG3 120F 50 POP 1210 50 POP 1211 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @11DF storage[0x0a] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x0a] & ~((0x01 << 0xa0) - 0x01)) // @120E log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0a] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] 1212 5B JUMPDEST 1213 81 DUP2 1214 60 PUSH1 0x01 1216 60 PUSH1 0x01 1218 60 PUSH1 0xa0 121A 1B SHL 121B 03 SUB 121C 16 AND 121D 83 DUP4 121E 60 PUSH1 0x01 1220 60 PUSH1 0x01 1222 60 PUSH1 0xa0 1224 1B SHL 1225 03 SUB 1226 16 AND 1227 14 EQ 1228 15 ISZERO 1229 61 PUSH2 0x1244 122C 57 *JUMPI 122D 60 PUSH1 0x40 122F 51 MLOAD 1230 62 PUSH3 0x461bcd 1234 60 PUSH1 0xe5 1236 1B SHL 1237 81 DUP2 1238 52 MSTORE 1239 60 PUSH1 0x04 123B 01 ADD 123C 61 PUSH2 0x06fe 123F 90 SWAP1 1240 61 PUSH2 0x251b 1243 56 *JUMP 1244 5B JUMPDEST 1245 60 PUSH1 0x01 1247 60 PUSH1 0x01 1249 60 PUSH1 0xa0 124B 1B SHL 124C 03 SUB 124D 83 DUP4 124E 81 DUP2 124F 16 AND 1250 60 PUSH1 0x00 1252 81 DUP2 1253 81 DUP2 1254 52 MSTORE 1255 60 PUSH1 0x05 1257 60 PUSH1 0x20 1259 90 SWAP1 125A 81 DUP2 125B 52 MSTORE 125C 60 PUSH1 0x40 125E 80 DUP1 125F 83 DUP4 1260 20 SHA3 1261 94 SWAP5 1262 87 DUP8 1263 16 AND 1264 80 DUP1 1265 84 DUP5 1266 52 MSTORE 1267 94 SWAP5 1268 90 SWAP1 1269 91 SWAP2 126A 52 MSTORE 126B 90 SWAP1 126C 81 DUP2 126D 90 SWAP1 126E 20 SHA3 126F 80 DUP1 1270 54 SLOAD 1271 60 PUSH1 0xff 1273 19 NOT 1274 16 AND 1275 85 DUP6 1276 15 ISZERO 1277 15 ISZERO 1278 17 OR 1279 90 SWAP1 127A 55 SSTORE 127B 51 MLOAD 127C 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 129D 90 SWAP1 129E 61 PUSH2 0x12a8 12A1 90 SWAP1 12A2 85 DUP6 12A3 90 SWAP1 12A4 61 PUSH2 0x245e 12A7 56 *JUMP 12A8 5B JUMPDEST 12A9 60 PUSH1 0x40 12AB 51 MLOAD 12AC 80 DUP1 12AD 91 SWAP2 12AE 03 SUB 12AF 90 SWAP1 12B0 A3 LOG3 12B1 50 POP 12B2 50 POP 12B3 50 POP 12B4 56 *JUMP 12B5 5B JUMPDEST 12B6 61 PUSH2 0x12c0 12B9 84 DUP5 12BA 84 DUP5 12BB 84 DUP5 12BC 61 PUSH2 0x102c 12BF 56 *JUMP 12C0 5B JUMPDEST 12C1 61 PUSH2 0x12cc 12C4 84 DUP5 12C5 84 DUP5 12C6 84 DUP5 12C7 84 DUP5 12C8 61 PUSH2 0x1487 12CB 56 *JUMP 12CC 5B JUMPDEST 12CD 61 PUSH2 0x0cc6 12D0 57 *JUMPI 12D1 60 PUSH1 0x40 12D3 51 MLOAD 12D4 62 PUSH3 0x461bcd 12D8 60 PUSH1 0xe5 12DA 1B SHL 12DB 81 DUP2 12DC 52 MSTORE 12DD 60 PUSH1 0x04 12DF 01 ADD 12E0 61 PUSH2 0x06fe 12E3 90 SWAP1 12E4 61 PUSH2 0x24bb 12E7 56 *JUMP label_12E8: // Incoming jump from 0x0D0C // Inputs[1] { @12EE storage[0x0b] } 12E8 5B JUMPDEST 12E9 60 PUSH1 0x60 12EB 60 PUSH1 0x0b 12ED 80 DUP1 12EE 54 SLOAD 12EF 61 PUSH2 0x0647 12F2 90 SWAP1 12F3 61 PUSH2 0x274f 12F6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @12E9 stack[0] = 0x60 // @12EB stack[1] = 0x0b // @12F2 stack[2] = 0x0647 // @12F2 stack[3] = storage[0x0b] // } // Block ends with call to 0x274f, returns to 0x0647 12F7 5B JUMPDEST 12F8 60 PUSH1 0x60 12FA 81 DUP2 12FB 61 PUSH2 0x131c 12FE 57 *JUMPI 12FF 50 POP 1300 60 PUSH1 0x40 1302 80 DUP1 1303 51 MLOAD 1304 80 DUP1 1305 82 DUP3 1306 01 ADD 1307 90 SWAP1 1308 91 SWAP2 1309 52 MSTORE 130A 60 PUSH1 0x01 130C 81 DUP2 130D 52 MSTORE 130E 60 PUSH1 0x03 1310 60 PUSH1 0xfc 1312 1B SHL 1313 60 PUSH1 0x20 1315 82 DUP3 1316 01 ADD 1317 52 MSTORE 1318 61 PUSH2 0x0633 131B 56 *JUMP 131C 5B JUMPDEST 131D 81 DUP2 131E 60 PUSH1 0x00 1320 5B JUMPDEST 1321 81 DUP2 1322 15 ISZERO 1323 61 PUSH2 0x1346 1326 57 *JUMPI 1327 80 DUP1 1328 61 PUSH2 0x1330 132B 81 DUP2 132C 61 PUSH2 0x27a9 132F 56 *JUMP 1330 5B JUMPDEST 1331 91 SWAP2 1332 50 POP 1333 61 PUSH2 0x133f 1336 90 SWAP1 1337 50 POP 1338 60 PUSH1 0x0a 133A 83 DUP4 133B 61 PUSH2 0x26a7 133E 56 *JUMP 133F 5B JUMPDEST 1340 91 SWAP2 1341 50 POP 1342 61 PUSH2 0x1320 1345 56 *JUMP 1346 5B JUMPDEST 1347 60 PUSH1 0x00 1349 81 DUP2 134A 67 PUSH8 0xffffffffffffffff 1353 81 DUP2 1354 11 GT 1355 15 ISZERO 1356 61 PUSH2 0x136f 1359 57 *JUMPI 135A 63 PUSH4 0x4e487b71 135F 60 PUSH1 0xe0 1361 1B SHL 1362 60 PUSH1 0x00 1364 52 MSTORE 1365 60 PUSH1 0x41 1367 60 PUSH1 0x04 1369 52 MSTORE 136A 60 PUSH1 0x24 136C 60 PUSH1 0x00 136E FD *REVERT 136F 5B JUMPDEST 1370 60 PUSH1 0x40 1372 51 MLOAD 1373 90 SWAP1 1374 80 DUP1 1375 82 DUP3 1376 52 MSTORE 1377 80 DUP1 1378 60 PUSH1 0x1f 137A 01 ADD 137B 60 PUSH1 0x1f 137D 19 NOT 137E 16 AND 137F 60 PUSH1 0x20 1381 01 ADD 1382 82 DUP3 1383 01 ADD 1384 60 PUSH1 0x40 1386 52 MSTORE 1387 80 DUP1 1388 15 ISZERO 1389 61 PUSH2 0x1399 138C 57 *JUMPI 138D 60 PUSH1 0x20 138F 82 DUP3 1390 01 ADD 1391 81 DUP2 1392 80 DUP1 1393 36 CALLDATASIZE 1394 83 DUP4 1395 37 CALLDATACOPY 1396 01 ADD 1397 90 SWAP1 1398 50 POP 1399 5B JUMPDEST 139A 50 POP 139B 90 SWAP1 139C 50 POP 139D 5B JUMPDEST 139E 84 DUP5 139F 15 ISZERO 13A0 61 PUSH2 0x1024 13A3 57 *JUMPI 13A4 61 PUSH2 0x13ae 13A7 60 PUSH1 0x01 13A9 83 DUP4 13AA 61 PUSH2 0x26da 13AD 56 *JUMP 13AE 5B JUMPDEST 13AF 91 SWAP2 13B0 50 POP 13B1 61 PUSH2 0x13bb 13B4 60 PUSH1 0x0a 13B6 86 DUP7 13B7 61 PUSH2 0x27c4 13BA 56 *JUMP 13BB 5B JUMPDEST 13BC 61 PUSH2 0x13c6 13BF 90 SWAP1 13C0 60 PUSH1 0x30 13C2 61 PUSH2 0x268f 13C5 56 *JUMP 13C6 5B JUMPDEST 13C7 60 PUSH1 0xf8 13C9 1B SHL 13CA 81 DUP2 13CB 83 DUP4 13CC 81 DUP2 13CD 51 MLOAD 13CE 81 DUP2 13CF 10 LT 13D0 61 PUSH2 0x13e9 13D3 57 *JUMPI 13D4 63 PUSH4 0x4e487b71 13D9 60 PUSH1 0xe0 13DB 1B SHL 13DC 60 PUSH1 0x00 13DE 52 MSTORE 13DF 60 PUSH1 0x32 13E1 60 PUSH1 0x04 13E3 52 MSTORE 13E4 60 PUSH1 0x24 13E6 60 PUSH1 0x00 13E8 FD *REVERT 13E9 5B JUMPDEST 13EA 60 PUSH1 0x20 13EC 01 ADD 13ED 01 ADD 13EE 90 SWAP1 13EF 60 PUSH1 0x01 13F1 60 PUSH1 0x01 13F3 60 PUSH1 0xf8 13F5 1B SHL 13F6 03 SUB 13F7 19 NOT 13F8 16 AND 13F9 90 SWAP1 13FA 81 DUP2 13FB 60 PUSH1 0x00 13FD 1A BYTE 13FE 90 SWAP1 13FF 53 MSTORE8 1400 50 POP 1401 61 PUSH2 0x140b 1404 60 PUSH1 0x0a 1406 86 DUP7 1407 61 PUSH2 0x26a7 140A 56 *JUMP 140B 5B JUMPDEST 140C 94 SWAP5 140D 50 POP 140E 61 PUSH2 0x139d 1411 56 *JUMP label_1412: // Incoming call from 0x0F0B, returns to 0x0630 // Inputs[1] { @141E stack[-1] } 1412 5B JUMPDEST 1413 60 PUSH1 0x00 1415 60 PUSH1 0x01 1417 60 PUSH1 0x01 1419 60 PUSH1 0xe0 141B 1B SHL 141C 03 SUB 141D 19 NOT 141E 82 DUP3 141F 16 AND 1420 63 PUSH4 0x80ac58cd 1425 60 PUSH1 0xe0 1427 1B SHL 1428 14 EQ 1429 80 DUP1 142A 61 PUSH2 0x1443 142D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1413 stack[0] = 0x00 // @1428 stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x1443, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_142E: // Incoming jump from 0x142D, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1438 stack[-3] } 142E 50 POP 142F 60 PUSH1 0x01 1431 60 PUSH1 0x01 1433 60 PUSH1 0xe0 1435 1B SHL 1436 03 SUB 1437 19 NOT 1438 82 DUP3 1439 16 AND 143A 63 PUSH4 0x5b5e139f 143F 60 PUSH1 0xe0 1441 1B SHL 1442 14 EQ 1443 5B JUMPDEST 1444 80 DUP1 1445 61 PUSH2 0x0630 1448 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1442 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0630, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_1449: // Incoming jump from 0x1448, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x1448, if not stack[-1] // Inputs[1] { @145B stack[-3] } 1449 50 POP 144A 63 PUSH4 0x01ffc9a7 144F 60 PUSH1 0xe0 1451 1B SHL 1452 60 PUSH1 0x01 1454 60 PUSH1 0x01 1456 60 PUSH1 0xe0 1458 1B SHL 1459 03 SUB 145A 19 NOT 145B 83 DUP4 145C 16 AND 145D 14 EQ 145E 61 PUSH2 0x0630 1461 56 *JUMP // Stack delta = +0 // Outputs[1] { @145D stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to 0x0630 label_1462: // Incoming call from 0x18A4, returns to 0x18A5 // Inputs[3] // { // @1466 stack[-3] // @1467 stack[-2] // @1468 stack[-1] // } 1462 5B JUMPDEST 1463 61 PUSH2 0x07a4 1466 83 DUP4 1467 83 DUP4 1468 83 DUP4 1469 61 PUSH2 0x1594 146C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1463 stack[0] = 0x07a4 // @1466 stack[1] = stack[-3] // @1467 stack[2] = stack[-2] // @1468 stack[3] = stack[-1] // } // Block ends with call to 0x1594, returns to 0x07A4 label_146D: // Incoming jump from 0x11AD // Inputs[3] // { // @1471 stack[-2] // @1472 stack[-1] // @1475 memory[0x40:0x60] // } 146D 5B JUMPDEST 146E 61 PUSH2 0x092f 1471 82 DUP3 1472 82 DUP3 1473 60 PUSH1 0x40 1475 51 MLOAD 1476 80 DUP1 1477 60 PUSH1 0x20 1479 01 ADD 147A 60 PUSH1 0x40 147C 52 MSTORE 147D 80 DUP1 147E 60 PUSH1 0x00 1480 81 DUP2 1481 52 MSTORE 1482 50 POP 1483 61 PUSH2 0x1651 1486 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @146E stack[0] = 0x092f // @1471 stack[1] = stack[-2] // @1472 stack[2] = stack[-1] // @1475 stack[3] = memory[0x40:0x60] // @147C memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1481 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x1651, returns to 0x092F label_1487: // Incoming call from 0x1667, returns to 0x1668 // Inputs[2] // { // @1492 stack[-3] // @1494 address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 1487 5B JUMPDEST 1488 60 PUSH1 0x00 148A 60 PUSH1 0x01 148C 60 PUSH1 0x01 148E 60 PUSH1 0xa0 1490 1B SHL 1491 03 SUB 1492 84 DUP5 1493 16 AND 1494 3B EXTCODESIZE 1495 15 ISZERO 1496 61 PUSH2 0x1589 1499 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1488 stack[0] = 0x00 } // Block ends with conditional jump to 0x1589, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_149A: // Incoming jump from 0x1499, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[6] // { // @149C memory[0x40:0x60] // @14AF stack[-4] // @14BC msg.sender // @14BE stack[-5] // @14C0 stack[-3] // @14C2 stack[-2] // } 149A 60 PUSH1 0x40 149C 51 MLOAD 149D 63 PUSH4 0x0a85bd01 14A2 60 PUSH1 0xe1 14A4 1B SHL 14A5 81 DUP2 14A6 52 MSTORE 14A7 60 PUSH1 0x01 14A9 60 PUSH1 0x01 14AB 60 PUSH1 0xa0 14AD 1B SHL 14AE 03 SUB 14AF 85 DUP6 14B0 16 AND 14B1 90 SWAP1 14B2 63 PUSH4 0x150b7a02 14B7 90 SWAP1 14B8 61 PUSH2 0x14cb 14BB 90 SWAP1 14BC 33 CALLER 14BD 90 SWAP1 14BE 89 DUP10 14BF 90 SWAP1 14C0 88 DUP9 14C1 90 SWAP1 14C2 88 DUP9 14C3 90 SWAP1 14C4 60 PUSH1 0x04 14C6 01 ADD 14C7 61 PUSH2 0x241a 14CA 56 *JUMP // Stack delta = +8 // Outputs[9] // { // @14A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @14B1 stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @14B7 stack[1] = 0x150b7a02 // @14BB stack[2] = 0x14cb // @14BD stack[3] = msg.sender // @14BF stack[4] = stack[-5] // @14C1 stack[5] = stack[-3] // @14C3 stack[6] = stack[-2] // @14C6 stack[7] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x241a 14CB 5B JUMPDEST 14CC 60 PUSH1 0x20 14CE 60 PUSH1 0x40 14D0 51 MLOAD 14D1 80 DUP1 14D2 83 DUP4 14D3 03 SUB 14D4 81 DUP2 14D5 60 PUSH1 0x00 14D7 87 DUP8 14D8 80 DUP1 14D9 3B EXTCODESIZE 14DA 15 ISZERO 14DB 80 DUP1 14DC 15 ISZERO 14DD 61 PUSH2 0x14e5 14E0 57 *JUMPI 14E1 60 PUSH1 0x00 14E3 80 DUP1 14E4 FD *REVERT 14E5 5B JUMPDEST 14E6 50 POP 14E7 5A GAS 14E8 F1 CALL 14E9 92 SWAP3 14EA 50 POP 14EB 50 POP 14EC 50 POP 14ED 80 DUP1 14EE 15 ISZERO 14EF 61 PUSH2 0x1515 14F2 57 *JUMPI 14F3 50 POP 14F4 60 PUSH1 0x40 14F6 80 DUP1 14F7 51 MLOAD 14F8 60 PUSH1 0x1f 14FA 3D RETURNDATASIZE 14FB 90 SWAP1 14FC 81 DUP2 14FD 01 ADD 14FE 60 PUSH1 0x1f 1500 19 NOT 1501 16 AND 1502 82 DUP3 1503 01 ADD 1504 90 SWAP1 1505 92 SWAP3 1506 52 MSTORE 1507 61 PUSH2 0x1512 150A 91 SWAP2 150B 81 DUP2 150C 01 ADD 150D 90 SWAP1 150E 61 PUSH2 0x1cbc 1511 56 *JUMP 1512 5B JUMPDEST 1513 60 PUSH1 0x01 1515 5B JUMPDEST 1516 61 PUSH2 0x156f 1519 57 *JUMPI 151A 3D RETURNDATASIZE 151B 80 DUP1 151C 80 DUP1 151D 15 ISZERO 151E 61 PUSH2 0x1543 1521 57 *JUMPI 1522 60 PUSH1 0x40 1524 51 MLOAD 1525 91 SWAP2 1526 50 POP 1527 60 PUSH1 0x1f 1529 19 NOT 152A 60 PUSH1 0x3f 152C 3D RETURNDATASIZE 152D 01 ADD 152E 16 AND 152F 82 DUP3 1530 01 ADD 1531 60 PUSH1 0x40 1533 52 MSTORE 1534 3D RETURNDATASIZE 1535 82 DUP3 1536 52 MSTORE 1537 3D RETURNDATASIZE 1538 60 PUSH1 0x00 153A 60 PUSH1 0x20 153C 84 DUP5 153D 01 ADD 153E 3E RETURNDATACOPY 153F 61 PUSH2 0x1548 1542 56 *JUMP 1543 5B JUMPDEST 1544 60 PUSH1 0x60 1546 91 SWAP2 1547 50 POP 1548 5B JUMPDEST 1549 50 POP 154A 80 DUP1 154B 51 MLOAD 154C 61 PUSH2 0x1567 154F 57 *JUMPI 1550 60 PUSH1 0x40 1552 51 MLOAD 1553 62 PUSH3 0x461bcd 1557 60 PUSH1 0xe5 1559 1B SHL 155A 81 DUP2 155B 52 MSTORE 155C 60 PUSH1 0x04 155E 01 ADD 155F 61 PUSH2 0x06fe 1562 90 SWAP1 1563 61 PUSH2 0x24bb 1566 56 *JUMP 1567 5B JUMPDEST 1568 80 DUP1 1569 51 MLOAD 156A 81 DUP2 156B 60 PUSH1 0x20 156D 01 ADD 156E FD *REVERT 156F 5B JUMPDEST 1570 60 PUSH1 0x01 1572 60 PUSH1 0x01 1574 60 PUSH1 0xe0 1576 1B SHL 1577 03 SUB 1578 19 NOT 1579 16 AND 157A 63 PUSH4 0x0a85bd01 157F 60 PUSH1 0xe1 1581 1B SHL 1582 14 EQ 1583 90 SWAP1 1584 50 POP 1585 61 PUSH2 0x1024 1588 56 *JUMP label_1589: // Incoming jump from 0x1499, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[2] // { // @158D stack[-6] // @158E stack[-5] // } 1589 5B JUMPDEST 158A 50 POP 158B 60 PUSH1 0x01 158D 94 SWAP5 158E 93 SWAP4 158F 50 POP 1590 50 POP 1591 50 POP 1592 50 POP 1593 56 *JUMP // Stack delta = -5 // Outputs[1] { @158D stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_1594: // Incoming call from 0x146C, returns to 0x07A4 // Inputs[1] { @159D stack[-3] } 1594 5B JUMPDEST 1595 60 PUSH1 0x01 1597 60 PUSH1 0x01 1599 60 PUSH1 0xa0 159B 1B SHL 159C 03 SUB 159D 83 DUP4 159E 16 AND 159F 61 PUSH2 0x15ef 15A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15ef, if stack[-3] & (0x01 << 0xa0) - 0x01 label_15A3: // Incoming jump from 0x15A2, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @15A6 stack[-1] // @15AA storage[0x08] // @15B8 memory[0x00:0x40] // } 15A3 61 PUSH2 0x15ea 15A6 81 DUP2 15A7 60 PUSH1 0x08 15A9 80 DUP1 15AA 54 SLOAD 15AB 60 PUSH1 0x00 15AD 83 DUP4 15AE 81 DUP2 15AF 52 MSTORE 15B0 60 PUSH1 0x09 15B2 60 PUSH1 0x20 15B4 52 MSTORE 15B5 60 PUSH1 0x40 15B7 81 DUP2 15B8 20 SHA3 15B9 82 DUP3 15BA 90 SWAP1 15BB 55 SSTORE 15BC 60 PUSH1 0x01 15BE 82 DUP3 15BF 01 ADD 15C0 83 DUP4 15C1 55 SSTORE 15C2 91 SWAP2 15C3 90 SWAP1 15C4 91 SWAP2 15C5 52 MSTORE 15C6 7F PUSH32 0xf3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee3 15E7 01 ADD 15E8 55 SSTORE 15E9 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @15AF memory[0x00:0x20] = stack[-1] // @15B4 memory[0x20:0x40] = 0x09 // @15BB storage[keccak256(memory[0x00:0x40])] = storage[0x08] // @15C1 storage[0x08] = storage[0x08] + 0x01 // @15C5 memory[0x00:0x20] = 0x08 // @15E8 storage[0xf3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee3 + storage[0x08]] = stack[-1] // } // Block ends with unconditional jump to 0x15ea label_15EA: // Incoming jump from 0x15E9 15EA 5B JUMPDEST 15EB 61 PUSH2 0x1612 15EE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1612 label_15EF: // Incoming jump from 0x15A2, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @15F0 stack[-2] // @15FA stack[-3] // } 15EF 5B JUMPDEST 15F0 81 DUP2 15F1 60 PUSH1 0x01 15F3 60 PUSH1 0x01 15F5 60 PUSH1 0xa0 15F7 1B SHL 15F8 03 SUB 15F9 16 AND 15FA 83 DUP4 15FB 60 PUSH1 0x01 15FD 60 PUSH1 0x01 15FF 60 PUSH1 0xa0 1601 1B SHL 1602 03 SUB 1603 16 AND 1604 14 EQ 1605 61 PUSH2 0x1612 1608 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1612, if (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] label_1609: // Incoming jump from 0x1608, if not (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] // Inputs[2] // { // @160C stack[-3] // @160D stack[-1] // } 1609 61 PUSH2 0x1612 160C 83 DUP4 160D 82 DUP3 160E 61 PUSH2 0x1684 1611 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1609 stack[0] = 0x1612 // @160C stack[1] = stack[-3] // @160D stack[2] = stack[-1] // } // Block ends with call to 0x1684, returns to 0x1612 label_1612: // Incoming jump from 0x15EE // Incoming jump from 0x1608, if (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] // Incoming return from call to 0x1684 at 0x1611 // Inputs[1] { @161B stack[-2] } 1612 5B JUMPDEST 1613 60 PUSH1 0x01 1615 60 PUSH1 0x01 1617 60 PUSH1 0xa0 1619 1B SHL 161A 03 SUB 161B 82 DUP3 161C 16 AND 161D 61 PUSH2 0x162e 1620 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x162e, if stack[-2] & (0x01 << 0xa0) - 0x01 label_1621: // Incoming jump from 0x1620, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1624 stack[-1] } 1621 61 PUSH2 0x1629 1624 81 DUP2 1625 61 PUSH2 0x1721 1628 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1621 stack[0] = 0x1629 // @1624 stack[1] = stack[-1] // } // Block ends with call to 0x1721, returns to 0x1629 label_1629: // Incoming return from call to 0x1721 at 0x1628 1629 5B JUMPDEST 162A 61 PUSH2 0x07a4 162D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07a4 label_162E: // Incoming jump from 0x1620, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @162F stack[-3] // @1639 stack[-2] // } 162E 5B JUMPDEST 162F 82 DUP3 1630 60 PUSH1 0x01 1632 60 PUSH1 0x01 1634 60 PUSH1 0xa0 1636 1B SHL 1637 03 SUB 1638 16 AND 1639 82 DUP3 163A 60 PUSH1 0x01 163C 60 PUSH1 0x01 163E 60 PUSH1 0xa0 1640 1B SHL 1641 03 SUB 1642 16 AND 1643 14 EQ 1644 61 PUSH2 0x07a4 1647 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07a4, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] label_1648: // Incoming jump from 0x1647, if not (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[2] // { // @164B stack[-2] // @164C stack[-1] // } 1648 61 PUSH2 0x07a4 164B 82 DUP3 164C 82 DUP3 164D 61 PUSH2 0x17fa 1650 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1648 stack[0] = 0x07a4 // @164B stack[1] = stack[-2] // @164C stack[2] = stack[-1] // } // Block ends with call to 0x17fa, returns to 0x07A4 label_1651: // Incoming call from 0x1486, returns to 0x092F // Inputs[2] // { // @1655 stack[-3] // @1656 stack[-2] // } 1651 5B JUMPDEST 1652 61 PUSH2 0x165b 1655 83 DUP4 1656 83 DUP4 1657 61 PUSH2 0x183e 165A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1652 stack[0] = 0x165b // @1655 stack[1] = stack[-3] // @1656 stack[2] = stack[-2] // } // Block ends with call to 0x183e, returns to 0x165B label_165B: // Incoming return from call to 0x183E at 0x165A // Inputs[3] // { // @1661 stack[-3] // @1662 stack[-2] // @1663 stack[-1] // } 165B 5B JUMPDEST 165C 61 PUSH2 0x1668 165F 60 PUSH1 0x00 1661 84 DUP5 1662 84 DUP5 1663 84 DUP5 1664 61 PUSH2 0x1487 1667 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @165C stack[0] = 0x1668 // @165F stack[1] = 0x00 // @1661 stack[2] = stack[-3] // @1662 stack[3] = stack[-2] // @1663 stack[4] = stack[-1] // } // Block ends with call to 0x1487, returns to 0x1668 label_1668: // Incoming return from call to 0x1487 at 0x1667 // Inputs[1] { @166C stack[-1] } 1668 5B JUMPDEST 1669 61 PUSH2 0x07a4 166C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x07a4, if stack[-1] label_166D: // Incoming jump from 0x166C, if not stack[-1] // Inputs[1] { @166F memory[0x40:0x60] } 166D 60 PUSH1 0x40 166F 51 MLOAD 1670 62 PUSH3 0x461bcd 1674 60 PUSH1 0xe5 1676 1B SHL 1677 81 DUP2 1678 52 MSTORE 1679 60 PUSH1 0x04 167B 01 ADD 167C 61 PUSH2 0x06fe 167F 90 SWAP1 1680 61 PUSH2 0x24bb 1683 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1678 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @167F stack[0] = 0x06fe // @167F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x24bb label_1684: // Incoming call from 0x1611, returns to 0x1612 // Inputs[1] { @168C stack[-2] } 1684 5B JUMPDEST 1685 60 PUSH1 0x00 1687 60 PUSH1 0x01 1689 61 PUSH2 0x1691 168C 84 DUP5 168D 61 PUSH2 0x0b29 1690 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1685 stack[0] = 0x00 // @1687 stack[1] = 0x01 // @1689 stack[2] = 0x1691 // @168C stack[3] = stack[-2] // } // Block ends with call to 0x0b29, returns to 0x1691 label_1691: // Incoming return from call to 0x0B29 at 0x1690 // Inputs[2] // { // @1695 stack[-2] // @1696 stack[-1] // } 1691 5B JUMPDEST 1692 61 PUSH2 0x169b 1695 91 SWAP2 1696 90 SWAP1 1697 61 PUSH2 0x26da 169A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1695 stack[-2] = 0x169b // @1696 stack[-1] = stack[-2] // @1696 stack[0] = stack[-1] // } // Block ends with call to 0x26da, returns to 0x169B label_169B: // Incoming return from call to 0x26DA at 0x169A // Inputs[5] // { // @169E stack[-3] // @16A9 memory[0x00:0x40] // @16AA storage[keccak256(memory[0x00:0x40])] // @16AB stack[-1] // @16AC stack[-2] // } 169B 5B JUMPDEST 169C 60 PUSH1 0x00 169E 83 DUP4 169F 81 DUP2 16A0 52 MSTORE 16A1 60 PUSH1 0x07 16A3 60 PUSH1 0x20 16A5 52 MSTORE 16A6 60 PUSH1 0x40 16A8 90 SWAP1 16A9 20 SHA3 16AA 54 SLOAD 16AB 90 SWAP1 16AC 91 SWAP2 16AD 50 POP 16AE 80 DUP1 16AF 82 DUP3 16B0 14 EQ 16B1 61 PUSH2 0x16ee 16B4 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @16A0 memory[0x00:0x20] = stack[-3] // @16A5 memory[0x20:0x40] = 0x07 // @16AB stack[-1] = storage[keccak256(memory[0x00:0x40])] // @16AC stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x16ee, if stack[-1] == storage[keccak256(memory[0x00:0x40])] label_16B5: // Incoming jump from 0x16B4, if not stack[-1] == storage[keccak256(memory[0x00:0x40])] // Inputs[13] // { // @16BD stack[-4] // @16CF memory[0x00:0x40] // @16D0 stack[-2] // @16D7 memory[0x00:0x40] // @16D8 storage[keccak256(memory[0x00:0x40])] // @16D9 stack[-1] // @16DE memory[0x00:0x40] // @16EA memory[0x00:0x40] // @16F2 stack[-3] // @1700 memory[0x00:0x40] // @1717 memory[0x00:0x40] // @171E memory[0x00:0x40] // @1720 stack[-5] // } 16B5 60 PUSH1 0x01 16B7 60 PUSH1 0x01 16B9 60 PUSH1 0xa0 16BB 1B SHL 16BC 03 SUB 16BD 84 DUP5 16BE 16 AND 16BF 60 PUSH1 0x00 16C1 90 SWAP1 16C2 81 DUP2 16C3 52 MSTORE 16C4 60 PUSH1 0x06 16C6 60 PUSH1 0x20 16C8 90 SWAP1 16C9 81 DUP2 16CA 52 MSTORE 16CB 60 PUSH1 0x40 16CD 80 DUP1 16CE 83 DUP4 16CF 20 SHA3 16D0 85 DUP6 16D1 84 DUP5 16D2 52 MSTORE 16D3 82 DUP3 16D4 52 MSTORE 16D5 80 DUP1 16D6 83 DUP4 16D7 20 SHA3 16D8 54 SLOAD 16D9 84 DUP5 16DA 84 DUP5 16DB 52 MSTORE 16DC 81 DUP2 16DD 84 DUP5 16DE 20 SHA3 16DF 81 DUP2 16E0 90 SWAP1 16E1 55 SSTORE 16E2 83 DUP4 16E3 52 MSTORE 16E4 60 PUSH1 0x07 16E6 90 SWAP1 16E7 91 SWAP2 16E8 52 MSTORE 16E9 90 SWAP1 16EA 20 SHA3 16EB 81 DUP2 16EC 90 SWAP1 16ED 55 SSTORE 16EE 5B JUMPDEST 16EF 50 POP 16F0 60 PUSH1 0x00 16F2 91 SWAP2 16F3 82 DUP3 16F4 52 MSTORE 16F5 60 PUSH1 0x07 16F7 60 PUSH1 0x20 16F9 90 SWAP1 16FA 81 DUP2 16FB 52 MSTORE 16FC 60 PUSH1 0x40 16FE 80 DUP1 16FF 84 DUP5 1700 20 SHA3 1701 84 DUP5 1702 90 SWAP1 1703 55 SSTORE 1704 60 PUSH1 0x01 1706 60 PUSH1 0x01 1708 60 PUSH1 0xa0 170A 1B SHL 170B 03 SUB 170C 90 SWAP1 170D 94 SWAP5 170E 16 AND 170F 83 DUP4 1710 52 MSTORE 1711 60 PUSH1 0x06 1713 81 DUP2 1714 52 MSTORE 1715 83 DUP4 1716 83 DUP4 1717 20 SHA3 1718 91 SWAP2 1719 83 DUP4 171A 52 MSTORE 171B 52 MSTORE 171C 90 SWAP1 171D 81 DUP2 171E 20 SHA3 171F 55 SSTORE 1720 56 *JUMP // Stack delta = -5 // Outputs[17] // { // @16C3 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @16CA memory[0x20:0x40] = 0x06 // @16D2 memory[0x00:0x20] = stack[-2] // @16D4 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @16DB memory[0x00:0x20] = stack[-1] // @16E1 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] // @16E3 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @16E8 memory[0x20:0x40] = 0x07 // @16ED storage[keccak256(memory[0x00:0x40])] = stack[-1] // @16F4 memory[0x00:0x20] = stack[-3] // @16FB memory[0x20:0x40] = 0x07 // @1703 storage[keccak256(memory[0x00:0x40])] = 0x00 // @1710 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1714 memory[0x20:0x40] = 0x06 // @171A memory[0x00:0x20] = stack[-2] // @171B memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @171F storage[keccak256(memory[0x00:0x40])] = 0x00 // } // Block ends with unconditional jump to stack[-5] label_1721: // Incoming call from 0x1628, returns to 0x1629 // Inputs[1] { @1724 storage[0x08] } 1721 5B JUMPDEST 1722 60 PUSH1 0x08 1724 54 SLOAD 1725 60 PUSH1 0x00 1727 90 SWAP1 1728 61 PUSH2 0x1733 172B 90 SWAP1 172C 60 PUSH1 0x01 172E 90 SWAP1 172F 61 PUSH2 0x26da 1732 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1727 stack[0] = 0x00 // @172B stack[1] = 0x1733 // @172E stack[2] = 0x01 // @172E stack[3] = storage[0x08] // } // Block ends with call to 0x26da, returns to 0x1733 label_1733: // Incoming return from call to 0x26DA at 0x1732 // Inputs[6] // { // @1736 stack[-3] // @1741 memory[0x00:0x40] // @1742 storage[keccak256(memory[0x00:0x40])] // @1746 storage[0x08] // @1747 stack[-1] // @1748 stack[-2] // } 1733 5B JUMPDEST 1734 60 PUSH1 0x00 1736 83 DUP4 1737 81 DUP2 1738 52 MSTORE 1739 60 PUSH1 0x09 173B 60 PUSH1 0x20 173D 52 MSTORE 173E 60 PUSH1 0x40 1740 81 DUP2 1741 20 SHA3 1742 54 SLOAD 1743 60 PUSH1 0x08 1745 80 DUP1 1746 54 SLOAD 1747 93 SWAP4 1748 94 SWAP5 1749 50 POP 174A 90 SWAP1 174B 92 SWAP3 174C 84 DUP5 174D 90 SWAP1 174E 81 DUP2 174F 10 LT 1750 61 PUSH2 0x1769 1753 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @1734 stack[0] = 0x00 // @1738 memory[0x00:0x20] = stack[-3] // @173D memory[0x20:0x40] = 0x09 // @1748 stack[-2] = stack[-1] // @174A stack[1] = 0x08 // @174B stack[-1] = storage[keccak256(memory[0x00:0x40])] // @174D stack[2] = stack[-1] // } // Block ends with conditional jump to 0x1769, if stack[-1] < storage[0x08] label_1754: // Incoming jump from 0x1753, if not stack[-1] < storage[0x08] // Inputs[1] { @1768 memory[0x00:0x24] } 1754 63 PUSH4 0x4e487b71 1759 60 PUSH1 0xe0 175B 1B SHL 175C 60 PUSH1 0x00 175E 52 MSTORE 175F 60 PUSH1 0x32 1761 60 PUSH1 0x04 1763 52 MSTORE 1764 60 PUSH1 0x24 1766 60 PUSH1 0x00 1768 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @175E memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1763 memory[0x04:0x24] = 0x32 // @1768 revert(memory[0x00:0x24]); // } // Block terminates label_1769: // Incoming jump from 0x1753, if stack[-1] < storage[0x08] // Inputs[7] // { // @176A stack[-1] // @176A stack[-2] // @1772 memory[0x00:0x20] // @1774 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1775 stack[-3] // @177A stack[-4] // @177C storage[0x08] // } 1769 5B JUMPDEST 176A 90 SWAP1 176B 60 PUSH1 0x00 176D 52 MSTORE 176E 60 PUSH1 0x20 1770 60 PUSH1 0x00 1772 20 SHA3 1773 01 ADD 1774 54 SLOAD 1775 90 SWAP1 1776 50 POP 1777 80 DUP1 1778 60 PUSH1 0x08 177A 83 DUP4 177B 81 DUP2 177C 54 SLOAD 177D 81 DUP2 177E 10 LT 177F 61 PUSH2 0x1798 1782 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @176D memory[0x00:0x20] = stack[-2] // @1775 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1777 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1778 stack[-1] = 0x08 // @177A stack[0] = stack[-4] // } // Block ends with conditional jump to 0x1798, if stack[-4] < storage[0x08] label_1783: // Incoming jump from 0x1782, if not stack[-4] < storage[0x08] // Inputs[1] { @1797 memory[0x00:0x24] } 1783 63 PUSH4 0x4e487b71 1788 60 PUSH1 0xe0 178A 1B SHL 178B 60 PUSH1 0x00 178D 52 MSTORE 178E 60 PUSH1 0x32 1790 60 PUSH1 0x04 1792 52 MSTORE 1793 60 PUSH1 0x24 1795 60 PUSH1 0x00 1797 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @178D memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1792 memory[0x04:0x24] = 0x32 // @1797 revert(memory[0x00:0x24]); // } // Block terminates label_1798: // Incoming jump from 0x1782, if stack[-4] < storage[0x08] // Inputs[10] // { // @179B stack[-2] // @17A2 memory[0x00:0x20] // @17A4 stack[-1] // @17A6 stack[-3] // @17AA stack[-4] // @17B6 memory[0x00:0x40] // @17B7 stack[-5] // @17BA stack[-7] // @17BE memory[0x00:0x40] // @17C3 storage[0x08] // } 1798 5B JUMPDEST 1799 60 PUSH1 0x00 179B 91 SWAP2 179C 82 DUP3 179D 52 MSTORE 179E 60 PUSH1 0x20 17A0 80 DUP1 17A1 83 DUP4 17A2 20 SHA3 17A3 90 SWAP1 17A4 91 SWAP2 17A5 01 ADD 17A6 92 SWAP3 17A7 90 SWAP1 17A8 92 SWAP3 17A9 55 SSTORE 17AA 82 DUP3 17AB 81 DUP2 17AC 52 MSTORE 17AD 60 PUSH1 0x09 17AF 90 SWAP1 17B0 91 SWAP2 17B1 52 MSTORE 17B2 60 PUSH1 0x40 17B4 80 DUP1 17B5 82 DUP3 17B6 20 SHA3 17B7 84 DUP5 17B8 90 SWAP1 17B9 55 SSTORE 17BA 85 DUP6 17BB 82 DUP3 17BC 52 MSTORE 17BD 81 DUP2 17BE 20 SHA3 17BF 55 SSTORE 17C0 60 PUSH1 0x08 17C2 80 DUP1 17C3 54 SLOAD 17C4 80 DUP1 17C5 61 PUSH2 0x17de 17C8 57 *JUMPI // Stack delta = -1 // Outputs[9] // { // @179D memory[0x00:0x20] = stack[-2] // @17A9 storage[stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // @17AC memory[0x00:0x20] = stack[-4] // @17B1 memory[0x20:0x40] = 0x09 // @17B9 storage[keccak256(memory[0x00:0x40])] = stack[-5] // @17BC memory[0x00:0x20] = stack[-7] // @17BF storage[keccak256(memory[0x00:0x40])] = 0x00 // @17C0 stack[-3] = 0x08 // @17C3 stack[-2] = storage[0x08] // } // Block ends with conditional jump to 0x17de, if storage[0x08] label_17C9: // Incoming jump from 0x17C8, if not storage[0x08] // Inputs[1] { @17DD memory[0x00:0x24] } 17C9 63 PUSH4 0x4e487b71 17CE 60 PUSH1 0xe0 17D0 1B SHL 17D1 60 PUSH1 0x00 17D3 52 MSTORE 17D4 60 PUSH1 0x31 17D6 60 PUSH1 0x04 17D8 52 MSTORE 17D9 60 PUSH1 0x24 17DB 60 PUSH1 0x00 17DD FD *REVERT // Stack delta = +0 // Outputs[3] // { // @17D3 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @17D8 memory[0x04:0x24] = 0x31 // @17DD revert(memory[0x00:0x24]); // } // Block terminates label_17DE: // Incoming jump from 0x17C8, if storage[0x08] // Inputs[4] // { // @17E1 stack[-1] // @17E3 stack[-2] // @17ED memory[0x00:0x20] // @17F9 stack[-7] // } 17DE 5B JUMPDEST 17DF 60 PUSH1 0x01 17E1 90 SWAP1 17E2 03 SUB 17E3 81 DUP2 17E4 81 DUP2 17E5 90 SWAP1 17E6 60 PUSH1 0x00 17E8 52 MSTORE 17E9 60 PUSH1 0x20 17EB 60 PUSH1 0x00 17ED 20 SHA3 17EE 01 ADD 17EF 60 PUSH1 0x00 17F1 90 SWAP1 17F2 55 SSTORE 17F3 90 SWAP1 17F4 55 SSTORE 17F5 50 POP 17F6 50 POP 17F7 50 POP 17F8 50 POP 17F9 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @17E8 memory[0x00:0x20] = stack[-2] // @17F2 storage[keccak256(memory[0x00:0x20]) + (stack[-1] - 0x01)] = 0x00 // @17F4 storage[stack[-2]] = stack[-1] - 0x01 // } // Block ends with unconditional jump to stack[-7] label_17FA: // Incoming call from 0x1650, returns to 0x07A4 // Inputs[1] { @1800 stack[-2] } 17FA 5B JUMPDEST 17FB 60 PUSH1 0x00 17FD 61 PUSH2 0x1805 1800 83 DUP4 1801 61 PUSH2 0x0b29 1804 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @17FB stack[0] = 0x00 // @17FD stack[1] = 0x1805 // @1800 stack[2] = stack[-2] // } // Block ends with call to 0x0b29, returns to 0x1805 label_1805: // Incoming return from call to 0x0B29 at 0x1804 // Inputs[8] // { // @180E stack[-1] // @180F stack[-4] // @1821 memory[0x00:0x40] // @1829 memory[0x00:0x40] // @182A stack[-3] // @1835 stack[-2] // @1837 memory[0x00:0x40] // @183D stack[-5] // } 1805 5B JUMPDEST 1806 60 PUSH1 0x01 1808 60 PUSH1 0x01 180A 60 PUSH1 0xa0 180C 1B SHL 180D 03 SUB 180E 90 SWAP1 180F 93 SWAP4 1810 16 AND 1811 60 PUSH1 0x00 1813 90 SWAP1 1814 81 DUP2 1815 52 MSTORE 1816 60 PUSH1 0x06 1818 60 PUSH1 0x20 181A 90 SWAP1 181B 81 DUP2 181C 52 MSTORE 181D 60 PUSH1 0x40 181F 80 DUP1 1820 83 DUP4 1821 20 SHA3 1822 86 DUP7 1823 84 DUP5 1824 52 MSTORE 1825 82 DUP3 1826 52 MSTORE 1827 80 DUP1 1828 83 DUP4 1829 20 SHA3 182A 85 DUP6 182B 90 SWAP1 182C 55 SSTORE 182D 93 SWAP4 182E 82 DUP3 182F 52 MSTORE 1830 60 PUSH1 0x07 1832 90 SWAP1 1833 52 MSTORE 1834 91 SWAP2 1835 90 SWAP1 1836 91 SWAP2 1837 20 SHA3 1838 91 SWAP2 1839 90 SWAP1 183A 91 SWAP2 183B 55 SSTORE 183C 50 POP 183D 56 *JUMP // Stack delta = -5 // Outputs[8] // { // @1815 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @181C memory[0x20:0x40] = 0x06 // @1824 memory[0x00:0x20] = stack[-1] // @1826 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @182C storage[keccak256(memory[0x00:0x40])] = stack[-3] // @182F memory[0x00:0x20] = stack[-3] // @1833 memory[0x20:0x40] = 0x07 // @183B storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_183E: // Incoming call from 0x165A, returns to 0x165B // Inputs[1] { @1847 stack[-2] } 183E 5B JUMPDEST 183F 60 PUSH1 0x01 1841 60 PUSH1 0x01 1843 60 PUSH1 0xa0 1845 1B SHL 1846 03 SUB 1847 82 DUP3 1848 16 AND 1849 61 PUSH2 0x1864 184C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1864, if stack[-2] & (0x01 << 0xa0) - 0x01 label_184D: // Incoming jump from 0x184C, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @184F memory[0x40:0x60] } 184D 60 PUSH1 0x40 184F 51 MLOAD 1850 62 PUSH3 0x461bcd 1854 60 PUSH1 0xe5 1856 1B SHL 1857 81 DUP2 1858 52 MSTORE 1859 60 PUSH1 0x04 185B 01 ADD 185C 61 PUSH2 0x06fe 185F 90 SWAP1 1860 61 PUSH2 0x258b 1863 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1858 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @185F stack[0] = 0x06fe // @185F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x258b label_1864: // Incoming jump from 0x184C, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1867 stack[-1] // @1872 memory[0x00:0x40] // @1873 storage[keccak256(memory[0x00:0x40])] // } 1864 5B JUMPDEST 1865 60 PUSH1 0x00 1867 81 DUP2 1868 81 DUP2 1869 52 MSTORE 186A 60 PUSH1 0x02 186C 60 PUSH1 0x20 186E 52 MSTORE 186F 60 PUSH1 0x40 1871 90 SWAP1 1872 20 SHA3 1873 54 SLOAD 1874 60 PUSH1 0x01 1876 60 PUSH1 0x01 1878 60 PUSH1 0xa0 187A 1B SHL 187B 03 SUB 187C 16 AND 187D 15 ISZERO 187E 61 PUSH2 0x1899 1881 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1869 memory[0x00:0x20] = stack[-1] // @186E memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x1899, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_1882: // Incoming jump from 0x1881, if not !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @1884 memory[0x40:0x60] } 1882 60 PUSH1 0x40 1884 51 MLOAD 1885 62 PUSH3 0x461bcd 1889 60 PUSH1 0xe5 188B 1B SHL 188C 81 DUP2 188D 52 MSTORE 188E 60 PUSH1 0x04 1890 01 ADD 1891 61 PUSH2 0x06fe 1894 90 SWAP1 1895 61 PUSH2 0x24eb 1898 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @188D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1894 stack[0] = 0x06fe // @1894 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x24eb label_1899: // Incoming jump from 0x1881, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @189F stack[-2] // @18A0 stack[-1] // } 1899 5B JUMPDEST 189A 61 PUSH2 0x18a5 189D 60 PUSH1 0x00 189F 83 DUP4 18A0 83 DUP4 18A1 61 PUSH2 0x1462 18A4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @189A stack[0] = 0x18a5 // @189D stack[1] = 0x00 // @189F stack[2] = stack[-2] // @18A0 stack[3] = stack[-1] // } // Block ends with call to 0x1462, returns to 0x18A5 label_18A5: // Incoming return from call to 0x1462 at 0x18A4 // Inputs[3] // { // @18AE stack[-2] // @18BD memory[0x00:0x40] // @18BF storage[keccak256(memory[0x00:0x40])] // } 18A5 5B JUMPDEST 18A6 60 PUSH1 0x01 18A8 60 PUSH1 0x01 18AA 60 PUSH1 0xa0 18AC 1B SHL 18AD 03 SUB 18AE 82 DUP3 18AF 16 AND 18B0 60 PUSH1 0x00 18B2 90 SWAP1 18B3 81 DUP2 18B4 52 MSTORE 18B5 60 PUSH1 0x03 18B7 60 PUSH1 0x20 18B9 52 MSTORE 18BA 60 PUSH1 0x40 18BC 81 DUP2 18BD 20 SHA3 18BE 80 DUP1 18BF 54 SLOAD 18C0 60 PUSH1 0x01 18C2 92 SWAP3 18C3 90 SWAP1 18C4 61 PUSH2 0x18ce 18C7 90 SWAP1 18C8 84 DUP5 18C9 90 SWAP1 18CA 61 PUSH2 0x268f 18CD 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @18B4 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @18B9 memory[0x20:0x40] = 0x03 // @18BD stack[1] = keccak256(memory[0x00:0x40]) // @18C2 stack[0] = 0x01 // @18C3 stack[2] = 0x00 // @18C7 stack[3] = 0x18ce // @18C9 stack[4] = 0x01 // @18C9 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x268f, returns to 0x18CE label_18CE: // Incoming return from call to 0x268F at 0x18CD // Inputs[10] // { // @18CF stack[-2] // @18CF stack[-1] // @18D0 stack[-3] // @18D6 stack[-5] // @18E2 memory[0x00:0x40] // @18E4 storage[keccak256(memory[0x00:0x40])] // @18F7 stack[-6] // @1900 memory[0x40:0x60] // @1928 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @192B stack[-7] // } 18CE 5B JUMPDEST 18CF 90 SWAP1 18D0 91 SWAP2 18D1 55 SSTORE 18D2 50 POP 18D3 50 POP 18D4 60 PUSH1 0x00 18D6 81 DUP2 18D7 81 DUP2 18D8 52 MSTORE 18D9 60 PUSH1 0x02 18DB 60 PUSH1 0x20 18DD 52 MSTORE 18DE 60 PUSH1 0x40 18E0 80 DUP1 18E1 82 DUP3 18E2 20 SHA3 18E3 80 DUP1 18E4 54 SLOAD 18E5 60 PUSH1 0x01 18E7 60 PUSH1 0x01 18E9 60 PUSH1 0xa0 18EB 1B SHL 18EC 03 SUB 18ED 19 NOT 18EE 16 AND 18EF 60 PUSH1 0x01 18F1 60 PUSH1 0x01 18F3 60 PUSH1 0xa0 18F5 1B SHL 18F6 03 SUB 18F7 86 DUP7 18F8 16 AND 18F9 90 SWAP1 18FA 81 DUP2 18FB 17 OR 18FC 90 SWAP1 18FD 91 SWAP2 18FE 55 SSTORE 18FF 90 SWAP1 1900 51 MLOAD 1901 83 DUP4 1902 92 SWAP3 1903 90 SWAP1 1904 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1925 90 SWAP1 1926 82 DUP3 1927 90 SWAP1 1928 A4 LOG4 1929 50 POP 192A 50 POP 192B 56 *JUMP // Stack delta = -7 // Outputs[5] // { // @18D1 storage[stack[-3]] = stack[-1] // @18D8 memory[0x00:0x20] = stack[-5] // @18DD memory[0x20:0x40] = 0x02 // @18FE storage[keccak256(memory[0x00:0x40])] = (stack[-6] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1928 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5]]); // } // Block ends with unconditional jump to stack[-7] 192C 5B JUMPDEST 192D 82 DUP3 192E 80 DUP1 192F 54 SLOAD 1930 61 PUSH2 0x1938 1933 90 SWAP1 1934 61 PUSH2 0x274f 1937 56 *JUMP 1938 5B JUMPDEST 1939 90 SWAP1 193A 60 PUSH1 0x00 193C 52 MSTORE 193D 60 PUSH1 0x20 193F 60 PUSH1 0x00 1941 20 SHA3 1942 90 SWAP1 1943 60 PUSH1 0x1f 1945 01 ADD 1946 60 PUSH1 0x20 1948 90 SWAP1 1949 04 DIV 194A 81 DUP2 194B 01 ADD 194C 92 SWAP3 194D 82 DUP3 194E 61 PUSH2 0x195a 1951 57 *JUMPI 1952 60 PUSH1 0x00 1954 85 DUP6 1955 55 SSTORE 1956 61 PUSH2 0x19a0 1959 56 *JUMP 195A 5B JUMPDEST 195B 82 DUP3 195C 60 PUSH1 0x1f 195E 10 LT 195F 61 PUSH2 0x1973 1962 57 *JUMPI 1963 80 DUP1 1964 51 MLOAD 1965 60 PUSH1 0xff 1967 19 NOT 1968 16 AND 1969 83 DUP4 196A 80 DUP1 196B 01 ADD 196C 17 OR 196D 85 DUP6 196E 55 SSTORE 196F 61 PUSH2 0x19a0 1972 56 *JUMP 1973 5B JUMPDEST 1974 82 DUP3 1975 80 DUP1 1976 01 ADD 1977 60 PUSH1 0x01 1979 01 ADD 197A 85 DUP6 197B 55 SSTORE 197C 82 DUP3 197D 15 ISZERO 197E 61 PUSH2 0x19a0 1981 57 *JUMPI 1982 91 SWAP2 1983 82 DUP3 1984 01 ADD 1985 5B JUMPDEST 1986 82 DUP3 1987 81 DUP2 1988 11 GT 1989 15 ISZERO 198A 61 PUSH2 0x19a0 198D 57 *JUMPI 198E 82 DUP3 198F 51 MLOAD 1990 82 DUP3 1991 55 SSTORE 1992 91 SWAP2 1993 60 PUSH1 0x20 1995 01 ADD 1996 91 SWAP2 1997 90 SWAP1 1998 60 PUSH1 0x01 199A 01 ADD 199B 90 SWAP1 199C 61 PUSH2 0x1985 199F 56 *JUMP 19A0 5B JUMPDEST 19A1 50 POP 19A2 61 PUSH2 0x19ac 19A5 92 SWAP3 19A6 91 SWAP2 19A7 50 POP 19A8 61 PUSH2 0x19b0 19AB 56 *JUMP 19AC 5B JUMPDEST 19AD 50 POP 19AE 90 SWAP1 19AF 56 *JUMP 19B0 5B JUMPDEST 19B1 5B JUMPDEST 19B2 80 DUP1 19B3 82 DUP3 19B4 11 GT 19B5 15 ISZERO 19B6 61 PUSH2 0x19ac 19B9 57 *JUMPI 19BA 60 PUSH1 0x00 19BC 81 DUP2 19BD 55 SSTORE 19BE 60 PUSH1 0x01 19C0 01 ADD 19C1 61 PUSH2 0x19b1 19C4 56 *JUMP label_19C5: // Incoming jump from 0x1A91 // Inputs[1] { @19CE stack[-2] } 19C5 5B JUMPDEST 19C6 60 PUSH1 0x00 19C8 61 PUSH2 0x19d8 19CB 61 PUSH2 0x19d3 19CE 84 DUP5 19CF 61 PUSH2 0x2640 19D2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @19C6 stack[0] = 0x00 // @19C8 stack[1] = 0x19d8 // @19CB stack[2] = 0x19d3 // @19CE stack[3] = stack[-2] // } // Block ends with call to 0x2640, returns to 0x19D3 label_19D3: // Incoming return from call to 0x2664 at 0x1A3A // Incoming return from call to 0x2640 at 0x19D2 19D3 5B JUMPDEST 19D4 61 PUSH2 0x2629 19D7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2629 19D8 5B JUMPDEST 19D9 90 SWAP1 19DA 50 POP 19DB 80 DUP1 19DC 83 DUP4 19DD 82 DUP3 19DE 52 MSTORE 19DF 60 PUSH1 0x20 19E1 82 DUP3 19E2 01 ADD 19E3 90 SWAP1 19E4 50 POP 19E5 82 DUP3 19E6 85 DUP6 19E7 60 PUSH1 0x20 19E9 86 DUP7 19EA 02 MUL 19EB 82 DUP3 19EC 01 ADD 19ED 11 GT 19EE 15 ISZERO 19EF 61 PUSH2 0x19f7 19F2 57 *JUMPI 19F3 60 PUSH1 0x00 19F5 80 DUP1 19F6 FD *REVERT 19F7 5B JUMPDEST 19F8 60 PUSH1 0x00 19FA 5B JUMPDEST 19FB 85 DUP6 19FC 81 DUP2 19FD 10 LT 19FE 15 ISZERO 19FF 61 PUSH2 0x1a23 1A02 57 *JUMPI 1A03 81 DUP2 1A04 61 PUSH2 0x1a0d 1A07 88 DUP9 1A08 82 DUP3 1A09 61 PUSH2 0x1a66 1A0C 56 *JUMP 1A0D 5B JUMPDEST 1A0E 84 DUP5 1A0F 52 MSTORE 1A10 50 POP 1A11 60 PUSH1 0x20 1A13 92 SWAP3 1A14 83 DUP4 1A15 01 ADD 1A16 92 SWAP3 1A17 91 SWAP2 1A18 90 SWAP1 1A19 91 SWAP2 1A1A 01 ADD 1A1B 90 SWAP1 1A1C 60 PUSH1 0x01 1A1E 01 ADD 1A1F 61 PUSH2 0x19fa 1A22 56 *JUMP 1A23 5B JUMPDEST 1A24 50 POP 1A25 50 POP 1A26 50 POP 1A27 93 SWAP4 1A28 92 SWAP3 1A29 50 POP 1A2A 50 POP 1A2B 50 POP 1A2C 56 *JUMP label_1A2D: // Incoming jump from 0x1AD3 // Inputs[1] { @1A36 stack[-2] } 1A2D 5B JUMPDEST 1A2E 60 PUSH1 0x00 1A30 61 PUSH2 0x1a3b 1A33 61 PUSH2 0x19d3 1A36 84 DUP5 1A37 61 PUSH2 0x2664 1A3A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A2E stack[0] = 0x00 // @1A30 stack[1] = 0x1a3b // @1A33 stack[2] = 0x19d3 // @1A36 stack[3] = stack[-2] // } // Block ends with call to 0x2664, returns to 0x19D3 1A3B 5B JUMPDEST 1A3C 90 SWAP1 1A3D 50 POP 1A3E 82 DUP3 1A3F 81 DUP2 1A40 52 MSTORE 1A41 60 PUSH1 0x20 1A43 81 DUP2 1A44 01 ADD 1A45 84 DUP5 1A46 84 DUP5 1A47 84 DUP5 1A48 01 ADD 1A49 11 GT 1A4A 15 ISZERO 1A4B 61 PUSH2 0x1a53 1A4E 57 *JUMPI 1A4F 60 PUSH1 0x00 1A51 80 DUP1 1A52 FD *REVERT 1A53 5B JUMPDEST 1A54 61 PUSH2 0x1a5e 1A57 84 DUP5 1A58 82 DUP3 1A59 85 DUP6 1A5A 61 PUSH2 0x2717 1A5D 56 *JUMP 1A5E 5B JUMPDEST 1A5F 50 POP 1A60 93 SWAP4 1A61 92 SWAP3 1A62 50 POP 1A63 50 POP 1A64 50 POP 1A65 56 *JUMP label_1A66: // Incoming jump from 0x1B62 // Incoming jump from 0x1B26 // Incoming jump from 0x1C26 // Incoming jump from 0x1BB0 // Incoming jump from 0x1B07 // Incoming jump from 0x1C56 // Inputs[2] // { // @1A67 stack[-1] // @1A68 msg.data[stack[-1]:stack[-1] + 0x20] // } 1A66 5B JUMPDEST 1A67 80 DUP1 1A68 35 CALLDATALOAD 1A69 61 PUSH2 0x0875 1A6C 81 DUP2 1A6D 61 PUSH2 0x2856 1A70 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A68 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1A69 stack[1] = 0x0875 // @1A6C stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2856 label_1A71: // Incoming jump from 0x1C9D // Inputs[2] // { // @1A74 stack[-2] // @1A77 stack[-1] // } 1A71 5B JUMPDEST 1A72 60 PUSH1 0x00 1A74 82 DUP3 1A75 60 PUSH1 0x1f 1A77 83 DUP4 1A78 01 ADD 1A79 12 SLT 1A7A 61 PUSH2 0x1a82 1A7D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A72 stack[0] = 0x00 } // Block ends with conditional jump to 0x1a82, if stack[-1] + 0x1f i< stack[-2] label_1A7E: // Incoming jump from 0x1A7D, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1A81 memory[0x00:0x00] } 1A7E 60 PUSH1 0x00 1A80 80 DUP1 1A81 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A81 revert(memory[0x00:0x00]); } // Block terminates label_1A82: // Incoming jump from 0x1A7D, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @1A83 stack[-2] // @1A84 msg.data[stack[-2]:stack[-2] + 0x20] // @1A88 stack[-3] // } 1A82 5B JUMPDEST 1A83 81 DUP2 1A84 35 CALLDATALOAD 1A85 61 PUSH2 0x1024 1A88 84 DUP5 1A89 82 DUP3 1A8A 60 PUSH1 0x20 1A8C 86 DUP7 1A8D 01 ADD 1A8E 61 PUSH2 0x19c5 1A91 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1A84 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1A85 stack[1] = 0x1024 // @1A88 stack[2] = stack[-3] // @1A89 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @1A8D stack[4] = stack[-2] + 0x20 // } // Block ends with unconditional jump to 0x19c5 1A92 5B JUMPDEST 1A93 80 DUP1 1A94 35 CALLDATALOAD 1A95 61 PUSH2 0x0875 1A98 81 DUP2 1A99 61 PUSH2 0x286a 1A9C 56 *JUMP label_1A9D: // Incoming call from 0x1CBB, returns to 0x1024 // Inputs[2] // { // @1A9E stack[-1] // @1A9F msg.data[stack[-1]:stack[-1] + 0x20] // } 1A9D 5B JUMPDEST 1A9E 80 DUP1 1A9F 35 CALLDATALOAD 1AA0 61 PUSH2 0x0875 1AA3 81 DUP2 1AA4 61 PUSH2 0x2872 1AA7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A9F stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1AA0 stack[1] = 0x0875 // @1AA3 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2872, returns to 0x0875 1AA8 5B JUMPDEST 1AA9 80 DUP1 1AAA 51 MLOAD 1AAB 61 PUSH2 0x0875 1AAE 81 DUP2 1AAF 61 PUSH2 0x2872 1AB2 56 *JUMP label_1AB3: // Incoming jump from 0x1D2C // Inputs[2] // { // @1AB6 stack[-2] // @1AB9 stack[-1] // } 1AB3 5B JUMPDEST 1AB4 60 PUSH1 0x00 1AB6 82 DUP3 1AB7 60 PUSH1 0x1f 1AB9 83 DUP4 1ABA 01 ADD 1ABB 12 SLT 1ABC 61 PUSH2 0x1ac4 1ABF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1AB4 stack[0] = 0x00 } // Block ends with conditional jump to 0x1ac4, if stack[-1] + 0x1f i< stack[-2] label_1AC0: // Incoming jump from 0x1ABF, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1AC3 memory[0x00:0x00] } 1AC0 60 PUSH1 0x00 1AC2 80 DUP1 1AC3 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AC3 revert(memory[0x00:0x00]); } // Block terminates label_1AC4: // Incoming jump from 0x1ABF, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @1AC5 stack[-2] // @1AC6 msg.data[stack[-2]:stack[-2] + 0x20] // @1ACA stack[-3] // } 1AC4 5B JUMPDEST 1AC5 81 DUP2 1AC6 35 CALLDATALOAD 1AC7 61 PUSH2 0x1024 1ACA 84 DUP5 1ACB 82 DUP3 1ACC 60 PUSH1 0x20 1ACE 86 DUP7 1ACF 01 ADD 1AD0 61 PUSH2 0x1a2d 1AD3 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1AC6 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1AC7 stack[1] = 0x1024 // @1ACA stack[2] = stack[-3] // @1ACB stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @1ACF stack[4] = stack[-2] + 0x20 // } // Block ends with unconditional jump to 0x1a2d label_1AD4: // Incoming call from 0x1CF7, returns to 0x1024 // Inputs[2] // { // @1AD5 stack[-1] // @1AD6 msg.data[stack[-1]:stack[-1] + 0x20] // } 1AD4 5B JUMPDEST 1AD5 80 DUP1 1AD6 35 CALLDATALOAD 1AD7 61 PUSH2 0x0875 1ADA 81 DUP2 1ADB 61 PUSH2 0x2882 1ADE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1AD6 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1AD7 stack[1] = 0x0875 // @1ADA stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2882, returns to 0x0875 label_1ADF: // Incoming call from 0x1D4A, returns to 0x1024 // Inputs[2] // { // @1AE0 stack[-1] // @1AE1 msg.data[stack[-1]:stack[-1] + 0x20] // } 1ADF 5B JUMPDEST 1AE0 80 DUP1 1AE1 35 CALLDATALOAD 1AE2 61 PUSH2 0x0875 1AE5 81 DUP2 1AE6 61 PUSH2 0x288f 1AE9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1AE1 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1AE2 stack[1] = 0x0875 // @1AE5 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x288f, returns to 0x0875 label_1AEA: // Incoming jump from 0x048F // Incoming jump from 0x045A // Incoming jump from 0x02EB // Incoming jump from 0x060C // Inputs[2] // { // @1AEF stack[-1] // @1AF0 stack[-2] // } 1AEA 5B JUMPDEST 1AEB 60 PUSH1 0x00 1AED 60 PUSH1 0x20 1AEF 82 DUP3 1AF0 84 DUP5 1AF1 03 SUB 1AF2 12 SLT 1AF3 15 ISZERO 1AF4 61 PUSH2 0x1afc 1AF7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1AEB stack[0] = 0x00 } // Block ends with conditional jump to 0x1afc, if !(stack[-2] - stack[-1] i< 0x20) label_1AF8: // Incoming jump from 0x1AF7, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1AFB memory[0x00:0x00] } 1AF8 60 PUSH1 0x00 1AFA 80 DUP1 1AFB FD *REVERT // Stack delta = +0 // Outputs[1] { @1AFB revert(memory[0x00:0x00]); } // Block terminates label_1AFC: // Incoming jump from 0x1AF7, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1B02 stack[-3] // @1B03 stack[-2] // } 1AFC 5B JUMPDEST 1AFD 60 PUSH1 0x00 1AFF 61 PUSH2 0x1024 1B02 84 DUP5 1B03 84 DUP5 1B04 61 PUSH2 0x1a66 1B07 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1AFD stack[0] = 0x00 // @1AFF stack[1] = 0x1024 // @1B02 stack[2] = stack[-3] // @1B03 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1a66 label_1B08: // Incoming jump from 0x05C3 // Inputs[2] // { // @1B0E stack[-1] // @1B0F stack[-2] // } 1B08 5B JUMPDEST 1B09 60 PUSH1 0x00 1B0B 80 DUP1 1B0C 60 PUSH1 0x40 1B0E 83 DUP4 1B0F 85 DUP6 1B10 03 SUB 1B11 12 SLT 1B12 15 ISZERO 1B13 61 PUSH2 0x1b1b 1B16 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1B09 stack[0] = 0x00 // @1B0B stack[1] = 0x00 // } // Block ends with conditional jump to 0x1b1b, if !(stack[-2] - stack[-1] i< 0x40) label_1B17: // Incoming jump from 0x1B16, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1B1A memory[0x00:0x00] } 1B17 60 PUSH1 0x00 1B19 80 DUP1 1B1A FD *REVERT // Stack delta = +0 // Outputs[1] { @1B1A revert(memory[0x00:0x00]); } // Block terminates label_1B1B: // Incoming jump from 0x1B16, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1B21 stack[-4] // @1B22 stack[-3] // } 1B1B 5B JUMPDEST 1B1C 60 PUSH1 0x00 1B1E 61 PUSH2 0x1b27 1B21 85 DUP6 1B22 85 DUP6 1B23 61 PUSH2 0x1a66 1B26 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B1C stack[0] = 0x00 // @1B1E stack[1] = 0x1b27 // @1B21 stack[2] = stack[-4] // @1B22 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1a66 1B27 5B JUMPDEST 1B28 92 SWAP3 1B29 50 POP 1B2A 50 POP 1B2B 60 PUSH1 0x20 1B2D 61 PUSH2 0x1b38 1B30 85 DUP6 1B31 82 DUP3 1B32 86 DUP7 1B33 01 ADD 1B34 61 PUSH2 0x1a66 1B37 56 *JUMP 1B38 5B JUMPDEST 1B39 91 SWAP2 1B3A 50 POP 1B3B 50 POP 1B3C 92 SWAP3 1B3D 50 POP 1B3E 92 SWAP3 1B3F 90 SWAP1 1B40 50 POP 1B41 56 *JUMP label_1B42: // Incoming jump from 0x036B // Incoming jump from 0x030B // Inputs[2] // { // @1B4A stack[-1] // @1B4B stack[-2] // } 1B42 5B JUMPDEST 1B43 60 PUSH1 0x00 1B45 80 DUP1 1B46 60 PUSH1 0x00 1B48 60 PUSH1 0x60 1B4A 84 DUP5 1B4B 86 DUP7 1B4C 03 SUB 1B4D 12 SLT 1B4E 15 ISZERO 1B4F 61 PUSH2 0x1b57 1B52 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1B43 stack[0] = 0x00 // @1B45 stack[1] = 0x00 // @1B46 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1b57, if !(stack[-2] - stack[-1] i< 0x60) label_1B53: // Incoming jump from 0x1B52, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1B56 memory[0x00:0x00] } 1B53 60 PUSH1 0x00 1B55 80 DUP1 1B56 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B56 revert(memory[0x00:0x00]); } // Block terminates label_1B57: // Incoming jump from 0x1B52, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @1B5D stack[-5] // @1B5E stack[-4] // } 1B57 5B JUMPDEST 1B58 60 PUSH1 0x00 1B5A 61 PUSH2 0x1b63 1B5D 86 DUP7 1B5E 86 DUP7 1B5F 61 PUSH2 0x1a66 1B62 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B58 stack[0] = 0x00 // @1B5A stack[1] = 0x1b63 // @1B5D stack[2] = stack[-5] // @1B5E stack[3] = stack[-4] // } // Block ends with unconditional jump to 0x1a66 1B63 5B JUMPDEST 1B64 93 SWAP4 1B65 50 POP 1B66 50 POP 1B67 60 PUSH1 0x20 1B69 61 PUSH2 0x1b74 1B6C 86 DUP7 1B6D 82 DUP3 1B6E 87 DUP8 1B6F 01 ADD 1B70 61 PUSH2 0x1a66 1B73 56 *JUMP 1B74 5B JUMPDEST 1B75 92 SWAP3 1B76 50 POP 1B77 50 POP 1B78 60 PUSH1 0x40 1B7A 61 PUSH2 0x1b85 1B7D 86 DUP7 1B7E 82 DUP3 1B7F 87 DUP8 1B80 01 ADD 1B81 61 PUSH2 0x1adf 1B84 56 *JUMP 1B85 5B JUMPDEST 1B86 91 SWAP2 1B87 50 POP 1B88 50 POP 1B89 92 SWAP3 1B8A 50 POP 1B8B 92 SWAP3 1B8C 50 POP 1B8D 92 SWAP3 1B8E 56 *JUMP label_1B8F: // Incoming jump from 0x056E // Inputs[2] // { // @1B98 stack[-1] // @1B99 stack[-2] // } 1B8F 5B JUMPDEST 1B90 60 PUSH1 0x00 1B92 80 DUP1 1B93 60 PUSH1 0x00 1B95 80 DUP1 1B96 60 PUSH1 0x80 1B98 85 DUP6 1B99 87 DUP8 1B9A 03 SUB 1B9B 12 SLT 1B9C 15 ISZERO 1B9D 61 PUSH2 0x1ba5 1BA0 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1B90 stack[0] = 0x00 // @1B92 stack[1] = 0x00 // @1B93 stack[2] = 0x00 // @1B95 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1ba5, if !(stack[-2] - stack[-1] i< 0x80) label_1BA1: // Incoming jump from 0x1BA0, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1BA4 memory[0x00:0x00] } 1BA1 60 PUSH1 0x00 1BA3 80 DUP1 1BA4 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BA4 revert(memory[0x00:0x00]); } // Block terminates label_1BA5: // Incoming jump from 0x1BA0, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @1BAB stack[-6] // @1BAC stack[-5] // } 1BA5 5B JUMPDEST 1BA6 60 PUSH1 0x00 1BA8 61 PUSH2 0x1bb1 1BAB 87 DUP8 1BAC 87 DUP8 1BAD 61 PUSH2 0x1a66 1BB0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BA6 stack[0] = 0x00 // @1BA8 stack[1] = 0x1bb1 // @1BAB stack[2] = stack[-6] // @1BAC stack[3] = stack[-5] // } // Block ends with unconditional jump to 0x1a66 1BB1 5B JUMPDEST 1BB2 94 SWAP5 1BB3 50 POP 1BB4 50 POP 1BB5 60 PUSH1 0x20 1BB7 61 PUSH2 0x1bc2 1BBA 87 DUP8 1BBB 82 DUP3 1BBC 88 DUP9 1BBD 01 ADD 1BBE 61 PUSH2 0x1a66 1BC1 56 *JUMP 1BC2 5B JUMPDEST 1BC3 93 SWAP4 1BC4 50 POP 1BC5 50 POP 1BC6 60 PUSH1 0x40 1BC8 61 PUSH2 0x1bd3 1BCB 87 DUP8 1BCC 82 DUP3 1BCD 88 DUP9 1BCE 01 ADD 1BCF 61 PUSH2 0x1adf 1BD2 56 *JUMP 1BD3 5B JUMPDEST 1BD4 92 SWAP3 1BD5 50 POP 1BD6 50 POP 1BD7 60 PUSH1 0x60 1BD9 85 DUP6 1BDA 01 ADD 1BDB 35 CALLDATALOAD 1BDC 67 PUSH8 0xffffffffffffffff 1BE5 81 DUP2 1BE6 11 GT 1BE7 15 ISZERO 1BE8 61 PUSH2 0x1bf0 1BEB 57 *JUMPI 1BEC 60 PUSH1 0x00 1BEE 80 DUP1 1BEF FD *REVERT 1BF0 5B JUMPDEST 1BF1 61 PUSH2 0x1bfc 1BF4 87 DUP8 1BF5 82 DUP3 1BF6 88 DUP9 1BF7 01 ADD 1BF8 61 PUSH2 0x1ab3 1BFB 56 *JUMP 1BFC 5B JUMPDEST 1BFD 91 SWAP2 1BFE 50 POP 1BFF 50 POP 1C00 92 SWAP3 1C01 95 SWAP6 1C02 91 SWAP2 1C03 94 SWAP5 1C04 50 POP 1C05 92 SWAP3 1C06 50 POP 1C07 56 *JUMP label_1C08: // Incoming jump from 0x054E // Inputs[2] // { // @1C0E stack[-1] // @1C0F stack[-2] // } 1C08 5B JUMPDEST 1C09 60 PUSH1 0x00 1C0B 80 DUP1 1C0C 60 PUSH1 0x40 1C0E 83 DUP4 1C0F 85 DUP6 1C10 03 SUB 1C11 12 SLT 1C12 15 ISZERO 1C13 61 PUSH2 0x1c1b 1C16 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C09 stack[0] = 0x00 // @1C0B stack[1] = 0x00 // } // Block ends with conditional jump to 0x1c1b, if !(stack[-2] - stack[-1] i< 0x40) label_1C17: // Incoming jump from 0x1C16, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1C1A memory[0x00:0x00] } 1C17 60 PUSH1 0x00 1C19 80 DUP1 1C1A FD *REVERT // Stack delta = +0 // Outputs[1] { @1C1A revert(memory[0x00:0x00]); } // Block terminates label_1C1B: // Incoming jump from 0x1C16, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1C21 stack[-4] // @1C22 stack[-3] // } 1C1B 5B JUMPDEST 1C1C 60 PUSH1 0x00 1C1E 61 PUSH2 0x1c27 1C21 85 DUP6 1C22 85 DUP6 1C23 61 PUSH2 0x1a66 1C26 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C1C stack[0] = 0x00 // @1C1E stack[1] = 0x1c27 // @1C21 stack[2] = stack[-4] // @1C22 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1a66 1C27 5B JUMPDEST 1C28 92 SWAP3 1C29 50 POP 1C2A 50 POP 1C2B 60 PUSH1 0x20 1C2D 61 PUSH2 0x1b38 1C30 85 DUP6 1C31 82 DUP3 1C32 86 DUP7 1C33 01 ADD 1C34 61 PUSH2 0x1a92 1C37 56 *JUMP label_1C38: // Incoming jump from 0x032B // Incoming jump from 0x02B4 // Inputs[2] // { // @1C3E stack[-1] // @1C3F stack[-2] // } 1C38 5B JUMPDEST 1C39 60 PUSH1 0x00 1C3B 80 DUP1 1C3C 60 PUSH1 0x40 1C3E 83 DUP4 1C3F 85 DUP6 1C40 03 SUB 1C41 12 SLT 1C42 15 ISZERO 1C43 61 PUSH2 0x1c4b 1C46 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C39 stack[0] = 0x00 // @1C3B stack[1] = 0x00 // } // Block ends with conditional jump to 0x1c4b, if !(stack[-2] - stack[-1] i< 0x40) label_1C47: // Incoming jump from 0x1C46, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1C4A memory[0x00:0x00] } 1C47 60 PUSH1 0x00 1C49 80 DUP1 1C4A FD *REVERT // Stack delta = +0 // Outputs[1] { @1C4A revert(memory[0x00:0x00]); } // Block terminates label_1C4B: // Incoming jump from 0x1C46, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1C51 stack[-4] // @1C52 stack[-3] // } 1C4B 5B JUMPDEST 1C4C 60 PUSH1 0x00 1C4E 61 PUSH2 0x1c57 1C51 85 DUP6 1C52 85 DUP6 1C53 61 PUSH2 0x1a66 1C56 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C4C stack[0] = 0x00 // @1C4E stack[1] = 0x1c57 // @1C51 stack[2] = stack[-4] // @1C52 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1a66 1C57 5B JUMPDEST 1C58 92 SWAP3 1C59 50 POP 1C5A 50 POP 1C5B 60 PUSH1 0x20 1C5D 61 PUSH2 0x1b38 1C60 85 DUP6 1C61 82 DUP3 1C62 86 DUP7 1C63 01 ADD 1C64 61 PUSH2 0x1adf 1C67 56 *JUMP label_1C68: // Incoming jump from 0x04C5 // Inputs[2] // { // @1C6E stack[-1] // @1C6F stack[-2] // } 1C68 5B JUMPDEST 1C69 60 PUSH1 0x00 1C6B 80 DUP1 1C6C 60 PUSH1 0x40 1C6E 83 DUP4 1C6F 85 DUP6 1C70 03 SUB 1C71 12 SLT 1C72 15 ISZERO 1C73 61 PUSH2 0x1c7b 1C76 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C69 stack[0] = 0x00 // @1C6B stack[1] = 0x00 // } // Block ends with conditional jump to 0x1c7b, if !(stack[-2] - stack[-1] i< 0x40) label_1C77: // Incoming jump from 0x1C76, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1C7A memory[0x00:0x00] } 1C77 60 PUSH1 0x00 1C79 80 DUP1 1C7A FD *REVERT // Stack delta = +0 // Outputs[1] { @1C7A revert(memory[0x00:0x00]); } // Block terminates label_1C7B: // Incoming jump from 0x1C76, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1C7C stack[-3] // @1C7D msg.data[stack[-3]:stack[-3] + 0x20] // } 1C7B 5B JUMPDEST 1C7C 82 DUP3 1C7D 35 CALLDATALOAD 1C7E 67 PUSH8 0xffffffffffffffff 1C87 81 DUP2 1C88 11 GT 1C89 15 ISZERO 1C8A 61 PUSH2 0x1c92 1C8D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C7D stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x1c92, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1C8E: // Incoming jump from 0x1C8D, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1C91 memory[0x00:0x00] } 1C8E 60 PUSH1 0x00 1C90 80 DUP1 1C91 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C91 revert(memory[0x00:0x00]); } // Block terminates label_1C92: // Incoming jump from 0x1C8D, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1C96 stack[-5] // @1C97 stack[-1] // @1C98 stack[-4] // } 1C92 5B JUMPDEST 1C93 61 PUSH2 0x1c57 1C96 85 DUP6 1C97 82 DUP3 1C98 86 DUP7 1C99 01 ADD 1C9A 61 PUSH2 0x1a71 1C9D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C93 stack[0] = 0x1c57 // @1C96 stack[1] = stack[-5] // @1C99 stack[2] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x1a71 label_1C9E: // Incoming call from 0x0238, returns to 0x0239 // Inputs[2] // { // @1CA3 stack[-1] // @1CA4 stack[-2] // } 1C9E 5B JUMPDEST 1C9F 60 PUSH1 0x00 1CA1 60 PUSH1 0x20 1CA3 82 DUP3 1CA4 84 DUP5 1CA5 03 SUB 1CA6 12 SLT 1CA7 15 ISZERO 1CA8 61 PUSH2 0x1cb0 1CAB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C9F stack[0] = 0x00 } // Block ends with conditional jump to 0x1cb0, if !(stack[-2] - stack[-1] i< 0x20) label_1CAC: // Incoming jump from 0x1CAB, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1CAF memory[0x00:0x00] } 1CAC 60 PUSH1 0x00 1CAE 80 DUP1 1CAF FD *REVERT // Stack delta = +0 // Outputs[1] { @1CAF revert(memory[0x00:0x00]); } // Block terminates label_1CB0: // Incoming jump from 0x1CAB, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1CB6 stack[-3] // @1CB7 stack[-2] // } 1CB0 5B JUMPDEST 1CB1 60 PUSH1 0x00 1CB3 61 PUSH2 0x1024 1CB6 84 DUP5 1CB7 84 DUP5 1CB8 61 PUSH2 0x1a9d 1CBB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1CB1 stack[0] = 0x00 // @1CB3 stack[1] = 0x1024 // @1CB6 stack[2] = stack[-3] // @1CB7 stack[3] = stack[-2] // } // Block ends with call to 0x1a9d, returns to 0x1024 1CBC 5B JUMPDEST 1CBD 60 PUSH1 0x00 1CBF 60 PUSH1 0x20 1CC1 82 DUP3 1CC2 84 DUP5 1CC3 03 SUB 1CC4 12 SLT 1CC5 15 ISZERO 1CC6 61 PUSH2 0x1cce 1CC9 57 *JUMPI 1CCA 60 PUSH1 0x00 1CCC 80 DUP1 1CCD FD *REVERT 1CCE 5B JUMPDEST 1CCF 60 PUSH1 0x00 1CD1 61 PUSH2 0x1024 1CD4 84 DUP5 1CD5 84 DUP5 1CD6 61 PUSH2 0x1aa8 1CD9 56 *JUMP label_1CDA: // Incoming call from 0x03CB, returns to 0x03CC // Inputs[2] // { // @1CDF stack[-1] // @1CE0 stack[-2] // } 1CDA 5B JUMPDEST 1CDB 60 PUSH1 0x00 1CDD 60 PUSH1 0x20 1CDF 82 DUP3 1CE0 84 DUP5 1CE1 03 SUB 1CE2 12 SLT 1CE3 15 ISZERO 1CE4 61 PUSH2 0x1cec 1CE7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CDB stack[0] = 0x00 } // Block ends with conditional jump to 0x1cec, if !(stack[-2] - stack[-1] i< 0x20) label_1CE8: // Incoming jump from 0x1CE7, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1CEB memory[0x00:0x00] } 1CE8 60 PUSH1 0x00 1CEA 80 DUP1 1CEB FD *REVERT // Stack delta = +0 // Outputs[1] { @1CEB revert(memory[0x00:0x00]); } // Block terminates label_1CEC: // Incoming jump from 0x1CE7, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1CF2 stack[-3] // @1CF3 stack[-2] // } 1CEC 5B JUMPDEST 1CED 60 PUSH1 0x00 1CEF 61 PUSH2 0x1024 1CF2 84 DUP5 1CF3 84 DUP5 1CF4 61 PUSH2 0x1ad4 1CF7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1CED stack[0] = 0x00 // @1CEF stack[1] = 0x1024 // @1CF2 stack[2] = stack[-3] // @1CF3 stack[3] = stack[-2] // } // Block ends with call to 0x1ad4, returns to 0x1024 label_1CF8: // Incoming jump from 0x03AB // Incoming jump from 0x0503 // Inputs[2] // { // @1CFD stack[-1] // @1CFE stack[-2] // } 1CF8 5B JUMPDEST 1CF9 60 PUSH1 0x00 1CFB 60 PUSH1 0x20 1CFD 82 DUP3 1CFE 84 DUP5 1CFF 03 SUB 1D00 12 SLT 1D01 15 ISZERO 1D02 61 PUSH2 0x1d0a 1D05 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CF9 stack[0] = 0x00 } // Block ends with conditional jump to 0x1d0a, if !(stack[-2] - stack[-1] i< 0x20) label_1D06: // Incoming jump from 0x1D05, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1D09 memory[0x00:0x00] } 1D06 60 PUSH1 0x00 1D08 80 DUP1 1D09 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D09 revert(memory[0x00:0x00]); } // Block terminates label_1D0A: // Incoming jump from 0x1D05, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1D0B stack[-2] // @1D0C msg.data[stack[-2]:stack[-2] + 0x20] // } 1D0A 5B JUMPDEST 1D0B 81 DUP2 1D0C 35 CALLDATALOAD 1D0D 67 PUSH8 0xffffffffffffffff 1D16 81 DUP2 1D17 11 GT 1D18 15 ISZERO 1D19 61 PUSH2 0x1d21 1D1C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D0C stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1d21, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1D1D: // Incoming jump from 0x1D1C, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1D20 memory[0x00:0x00] } 1D1D 60 PUSH1 0x00 1D1F 80 DUP1 1D20 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D20 revert(memory[0x00:0x00]); } // Block terminates label_1D21: // Incoming jump from 0x1D1C, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1D25 stack[-4] // @1D26 stack[-1] // @1D27 stack[-3] // } 1D21 5B JUMPDEST 1D22 61 PUSH2 0x1024 1D25 84 DUP5 1D26 82 DUP3 1D27 85 DUP6 1D28 01 ADD 1D29 61 PUSH2 0x1ab3 1D2C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D22 stack[0] = 0x1024 // @1D25 stack[1] = stack[-4] // @1D28 stack[2] = stack[-3] + stack[-1] // } // Block ends with unconditional jump to 0x1ab3 label_1D2D: // Incoming call from 0x0287, returns to 0x0288 // Incoming call from 0x061F, returns to 0x0620 // Incoming call from 0x0425, returns to 0x0426 // Incoming call from 0x038B, returns to 0x038C // Incoming call from 0x03DE, returns to 0x03DF // Incoming call from 0x058E, returns to 0x058F // Inputs[2] // { // @1D32 stack[-1] // @1D33 stack[-2] // } 1D2D 5B JUMPDEST 1D2E 60 PUSH1 0x00 1D30 60 PUSH1 0x20 1D32 82 DUP3 1D33 84 DUP5 1D34 03 SUB 1D35 12 SLT 1D36 15 ISZERO 1D37 61 PUSH2 0x1d3f 1D3A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D2E stack[0] = 0x00 } // Block ends with conditional jump to 0x1d3f, if !(stack[-2] - stack[-1] i< 0x20) label_1D3B: // Incoming jump from 0x1D3A, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1D3E memory[0x00:0x00] } 1D3B 60 PUSH1 0x00 1D3D 80 DUP1 1D3E FD *REVERT // Stack delta = +0 // Outputs[1] { @1D3E revert(memory[0x00:0x00]); } // Block terminates label_1D3F: // Incoming jump from 0x1D3A, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1D45 stack[-3] // @1D46 stack[-2] // } 1D3F 5B JUMPDEST 1D40 60 PUSH1 0x00 1D42 61 PUSH2 0x1024 1D45 84 DUP5 1D46 84 DUP5 1D47 61 PUSH2 0x1adf 1D4A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D40 stack[0] = 0x00 // @1D42 stack[1] = 0x1024 // @1D45 stack[2] = stack[-3] // @1D46 stack[3] = stack[-2] // } // Block ends with call to 0x1adf, returns to 0x1024 label_1D4B: // Incoming jump from 0x2419 // Incoming jump from 0x2427 // Inputs[1] { @1D4F stack[-1] } 1D4B 5B JUMPDEST 1D4C 61 PUSH2 0x1d54 1D4F 81 DUP2 1D50 61 PUSH2 0x26f1 1D53 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D4C stack[0] = 0x1d54 // @1D4F stack[1] = stack[-1] // } // Block ends with call to 0x26f1, returns to 0x1D54 label_1D54: // Incoming return from call to 0x26F1 at 0x1D53 // Incoming return from call to 0x270C at 0x1D9C // Incoming jump from 0x23F3 // Inputs[3] // { // @1D55 stack[-3] // @1D56 stack[-1] // @1D59 stack[-4] // } 1D54 5B JUMPDEST 1D55 82 DUP3 1D56 52 MSTORE 1D57 50 POP 1D58 50 POP 1D59 56 *JUMP // Stack delta = -4 // Outputs[1] { @1D56 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] 1D5A 5B JUMPDEST 1D5B 80 DUP1 1D5C 15 ISZERO 1D5D 15 ISZERO 1D5E 61 PUSH2 0x1d54 1D61 56 *JUMP label_1D62: // Incoming call from 0x248A, returns to 0x0D58 // Inputs[2] // { // @1D68 stack[-1] // @1D69 memory[stack[-1]:stack[-1] + 0x20] // } 1D62 5B JUMPDEST 1D63 60 PUSH1 0x00 1D65 61 PUSH2 0x1d6c 1D68 82 DUP3 1D69 51 MLOAD 1D6A 90 SWAP1 1D6B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D63 stack[0] = 0x00 // @1D6A stack[1] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1d6c label_1D6C: // Incoming jump from 0x1D6B // Inputs[3] // { // @1D6D stack[-1] // @1D6E stack[-4] // @1D7D stack[-3] // } 1D6C 5B JUMPDEST 1D6D 80 DUP1 1D6E 84 DUP5 1D6F 52 MSTORE 1D70 60 PUSH1 0x20 1D72 84 DUP5 1D73 01 ADD 1D74 93 SWAP4 1D75 50 POP 1D76 61 PUSH2 0x1d83 1D79 81 DUP2 1D7A 85 DUP6 1D7B 60 PUSH1 0x20 1D7D 86 DUP7 1D7E 01 ADD 1D7F 61 PUSH2 0x2723 1D82 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1D6F memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @1D74 stack[-4] = stack[-4] + 0x20 // @1D76 stack[0] = 0x1d83 // @1D79 stack[1] = stack[-1] // @1D7A stack[2] = stack[-4] + 0x20 // @1D7E stack[3] = stack[-3] + 0x20 // } // Block ends with call to 0x2723, returns to 0x1D83 label_1D83: // Incoming return from call to 0x2723 at 0x1D82 // Inputs[4] // { // @1D86 stack[-1] // @1D8B stack[-4] // @1D8C stack[-2] // @1D8F stack[-5] // } 1D83 5B JUMPDEST 1D84 60 PUSH1 0x1f 1D86 01 ADD 1D87 60 PUSH1 0x1f 1D89 19 NOT 1D8A 16 AND 1D8B 92 SWAP3 1D8C 90 SWAP1 1D8D 92 SWAP3 1D8E 01 ADD 1D8F 92 SWAP3 1D90 91 SWAP2 1D91 50 POP 1D92 50 POP 1D93 56 *JUMP // Stack delta = -4 // Outputs[1] { @1D8F stack[-5] = (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1D94: // Incoming jump from 0x2479 // Inputs[1] { @1D98 stack[-1] } 1D94 5B JUMPDEST 1D95 61 PUSH2 0x1d54 1D98 81 DUP2 1D99 61 PUSH2 0x270c 1D9C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D95 stack[0] = 0x1d54 // @1D98 stack[1] = stack[-1] // } // Block ends with call to 0x270c, returns to 0x1D54 1D9D 5B JUMPDEST 1D9E 60 PUSH1 0x00 1DA0 61 PUSH2 0x1da7 1DA3 82 DUP3 1DA4 51 MLOAD 1DA5 90 SWAP1 1DA6 56 *JUMP 1DA7 5B JUMPDEST 1DA8 61 PUSH2 0x1db5 1DAB 81 DUP2 1DAC 85 DUP6 1DAD 60 PUSH1 0x20 1DAF 86 DUP7 1DB0 01 ADD 1DB1 61 PUSH2 0x2723 1DB4 56 *JUMP 1DB5 5B JUMPDEST 1DB6 92 SWAP3 1DB7 90 SWAP1 1DB8 92 SWAP3 1DB9 01 ADD 1DBA 92 SWAP3 1DBB 91 SWAP2 1DBC 50 POP 1DBD 50 POP 1DBE 56 *JUMP label_1DBF: // Incoming call from 0x249A, returns to 0x0630 // Inputs[1] { @1DC2 stack[-1] } 1DBF 5B JUMPDEST 1DC0 60 PUSH1 0x15 1DC2 81 DUP2 1DC3 52 MSTORE 1DC4 60 PUSH1 0x00 1DC6 60 PUSH1 0x20 1DC8 82 DUP3 1DC9 01 ADD 1DCA 74 PUSH21 0x141d589b1a58c81cd85b19481a5cc818db1bdcd959 1DE0 60 PUSH1 0x5a 1DE2 1B SHL 1DE3 81 DUP2 1DE4 52 MSTORE 1DE5 91 SWAP2 1DE6 50 POP // Stack delta = +1 // Outputs[4] // { // @1DC3 memory[stack[-1]:stack[-1] + 0x20] = 0x15 // @1DC4 stack[0] = 0x00 // @1DE4 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x141d589b1a58c81cd85b19481a5cc818db1bdcd959 << 0x5a // @1DE5 stack[-1] = stack[-1] + 0x20 // } // Block continues label_1DE7: // Incoming jump from 0x1F70 // Incoming jump from 0x1F3C // Incoming jump from 0x2041 // Incoming jump from 0x21D7 // Incoming jump from 0x220B // Incoming jump from 0x2075 // Incoming jump from 0x2286 // Incoming jump from 0x1F98 // Incoming jump from 0x1DE6 // Inputs[2] // { // @1DEB stack[-2] // @1DEC stack[-3] // } 1DE7 5B JUMPDEST 1DE8 50 POP 1DE9 60 PUSH1 0x20 1DEB 01 ADD 1DEC 90 SWAP1 1DED 56 *JUMP // Stack delta = -2 // Outputs[1] { @1DEC stack[-3] = 0x20 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_1DEE: // Incoming call from 0x24AA, returns to 0x0630 // Inputs[1] { @1DF1 stack[-1] } 1DEE 5B JUMPDEST 1DEF 60 PUSH1 0x21 1DF1 81 DUP2 1DF2 52 MSTORE 1DF3 60 PUSH1 0x00 1DF5 60 PUSH1 0x20 1DF7 82 DUP3 1DF8 01 ADD 1DF9 7F PUSH32 0x547279696e6720746f206d696e74206d6f7265207468616e20616c6c6f747465 1E1A 81 DUP2 1E1B 52 MSTORE 1E1C 60 PUSH1 0x19 1E1E 60 PUSH1 0xfa 1E20 1B SHL 1E21 60 PUSH1 0x20 1E23 82 DUP3 1E24 01 ADD 1E25 52 MSTORE 1E26 91 SWAP2 1E27 50 POP // Stack delta = +1 // Outputs[5] // { // @1DF2 memory[stack[-1]:stack[-1] + 0x20] = 0x21 // @1DF3 stack[0] = 0x00 // @1E1B memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x547279696e6720746f206d696e74206d6f7265207468616e20616c6c6f747465 // @1E25 memory[stack[-1] + 0x20 + 0x20:stack[-1] + 0x20 + 0x20 + 0x20] = 0x19 << 0xfa // @1E26 stack[-1] = stack[-1] + 0x20 // } // Block continues label_1E28: // Incoming jump from 0x2254 // Incoming jump from 0x1E27 // Incoming jump from 0x21A5 // Incoming jump from 0x1EC5 // Incoming jump from 0x215F // Incoming jump from 0x2318 // Incoming jump from 0x23ED // Inputs[2] // { // @1E2C stack[-2] // @1E2D stack[-3] // } 1E28 5B JUMPDEST 1E29 50 POP 1E2A 60 PUSH1 0x40 1E2C 01 ADD 1E2D 90 SWAP1 1E2E 56 *JUMP // Stack delta = -2 // Outputs[1] { @1E2D stack[-3] = 0x40 + stack[-2] } // Block ends with unconditional jump to stack[-3] 1E2F 5B JUMPDEST 1E30 60 PUSH1 0x2b 1E32 81 DUP2 1E33 52 MSTORE 1E34 60 PUSH1 0x00 1E36 60 PUSH1 0x20 1E38 82 DUP3 1E39 01 ADD 1E3A 7F PUSH32 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 1E5B 81 DUP2 1E5C 52 MSTORE 1E5D 6A PUSH11 0x74206f6620626f756e6473 1E69 60 PUSH1 0xa8 1E6B 1B SHL 1E6C 60 PUSH1 0x20 1E6E 82 DUP3 1E6F 01 ADD 1E70 52 MSTORE 1E71 91 SWAP2 1E72 50 POP 1E73 61 PUSH2 0x1e28 1E76 56 *JUMP label_1E77: // Incoming call from 0x24CA, returns to 0x0630 // Inputs[1] { @1E7A stack[-1] } 1E77 5B JUMPDEST 1E78 60 PUSH1 0x32 1E7A 81 DUP2 1E7B 52 MSTORE 1E7C 60 PUSH1 0x00 1E7E 60 PUSH1 0x20 1E80 82 DUP3 1E81 01 ADD 1E82 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 1EA3 81 DUP2 1EA4 52 MSTORE 1EA5 71 PUSH18 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 1EB8 60 PUSH1 0x71 1EBA 1B SHL 1EBB 60 PUSH1 0x20 1EBD 82 DUP3 1EBE 01 ADD 1EBF 52 MSTORE 1EC0 91 SWAP2 1EC1 50 POP 1EC2 61 PUSH2 0x1e28 1EC5 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1E7B memory[stack[-1]:stack[-1] + 0x20] = 0x32 // @1E7C stack[0] = 0x00 // @1EA4 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 // @1EBF memory[stack[-1] + 0x20 + 0x20:stack[-1] + 0x20 + 0x20 + 0x20] = 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 << 0x71 // @1EC0 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1e28 1EC6 5B JUMPDEST 1EC7 60 PUSH1 0x26 1EC9 81 DUP2 1ECA 52 MSTORE 1ECB 60 PUSH1 0x00 1ECD 60 PUSH1 0x20 1ECF 82 DUP3 1ED0 01 ADD 1ED1 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 1EF2 81 DUP2 1EF3 52 MSTORE 1EF4 65 PUSH6 0x646472657373 1EFB 60 PUSH1 0xd0 1EFD 1B SHL 1EFE 60 PUSH1 0x20 1F00 82 DUP3 1F01 01 ADD 1F02 52 MSTORE 1F03 91 SWAP2 1F04 50 POP 1F05 61 PUSH2 0x1e28 1F08 56 *JUMP label_1F09: // Incoming call from 0x24EA, returns to 0x0630 // Inputs[1] { @1F0C stack[-1] } 1F09 5B JUMPDEST 1F0A 60 PUSH1 0x19 1F0C 81 DUP2 1F0D 52 MSTORE 1F0E 60 PUSH1 0x00 1F10 60 PUSH1 0x20 1F12 82 DUP3 1F13 01 ADD 1F14 7F PUSH32 0x4174206d6f7374203320706572207472616e73616374696f6e00000000000000 1F35 81 DUP2 1F36 52 MSTORE 1F37 91 SWAP2 1F38 50 POP 1F39 61 PUSH2 0x1de7 1F3C 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1F0D memory[stack[-1]:stack[-1] + 0x20] = 0x19 // @1F0E stack[0] = 0x00 // @1F36 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4174206d6f7374203320706572207472616e73616374696f6e00000000000000 // @1F37 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1de7 label_1F3D: // Incoming call from 0x24FA, returns to 0x0630 // Inputs[1] { @1F40 stack[-1] } 1F3D 5B JUMPDEST 1F3E 60 PUSH1 0x1c 1F40 81 DUP2 1F41 52 MSTORE 1F42 60 PUSH1 0x00 1F44 60 PUSH1 0x20 1F46 82 DUP3 1F47 01 ADD 1F48 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 1F69 81 DUP2 1F6A 52 MSTORE 1F6B 91 SWAP2 1F6C 50 POP 1F6D 61 PUSH2 0x1de7 1F70 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1F41 memory[stack[-1]:stack[-1] + 0x20] = 0x1c // @1F42 stack[0] = 0x00 // @1F6A memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 // @1F6B stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1de7 label_1F71: // Incoming call from 0x250A, returns to 0x0630 // Inputs[1] { @1F74 stack[-1] } 1F71 5B JUMPDEST 1F72 60 PUSH1 0x11 1F74 81 DUP2 1F75 52 MSTORE 1F76 60 PUSH1 0x00 1F78 60 PUSH1 0x20 1F7A 82 DUP3 1F7B 01 ADD 1F7C 70 PUSH17 0x141c995cd85b19481a5cc818db1bdcd959 1F8E 60 PUSH1 0x7a 1F90 1B SHL 1F91 81 DUP2 1F92 52 MSTORE 1F93 91 SWAP2 1F94 50 POP 1F95 61 PUSH2 0x1de7 1F98 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1F75 memory[stack[-1]:stack[-1] + 0x20] = 0x11 // @1F76 stack[0] = 0x00 // @1F92 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x141c995cd85b19481a5cc818db1bdcd959 << 0x7a // @1F93 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1de7 1F99 5B JUMPDEST 1F9A 60 PUSH1 0x24 1F9C 81 DUP2 1F9D 52 MSTORE 1F9E 60 PUSH1 0x00 1FA0 60 PUSH1 0x20 1FA2 82 DUP3 1FA3 01 ADD 1FA4 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 1FC5 81 DUP2 1FC6 52 MSTORE 1FC7 63 PUSH4 0x72657373 1FCC 60 PUSH1 0xe0 1FCE 1B SHL 1FCF 60 PUSH1 0x20 1FD1 82 DUP3 1FD2 01 ADD 1FD3 52 MSTORE 1FD4 91 SWAP2 1FD5 50 POP 1FD6 61 PUSH2 0x1e28 1FD9 56 *JUMP 1FDA 5B JUMPDEST 1FDB 60 PUSH1 0x19 1FDD 81 DUP2 1FDE 52 MSTORE 1FDF 60 PUSH1 0x00 1FE1 60 PUSH1 0x20 1FE3 82 DUP3 1FE4 01 ADD 1FE5 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 2006 81 DUP2 2007 52 MSTORE 2008 91 SWAP2 2009 50 POP 200A 61 PUSH2 0x1de7 200D 56 *JUMP label_200E: // Incoming call from 0x253A, returns to 0x0630 // Inputs[1] { @2011 stack[-1] } 200E 5B JUMPDEST 200F 60 PUSH1 0x18 2011 81 DUP2 2012 52 MSTORE 2013 60 PUSH1 0x00 2015 60 PUSH1 0x20 2017 82 DUP3 2018 01 ADD 2019 7F PUSH32 0x496e636f72726563742070617961626c6520616d6f756e740000000000000000 203A 81 DUP2 203B 52 MSTORE 203C 91 SWAP2 203D 50 POP 203E 61 PUSH2 0x1de7 2041 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @2012 memory[stack[-1]:stack[-1] + 0x20] = 0x18 // @2013 stack[0] = 0x00 // @203B memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x496e636f72726563742070617961626c6520616d6f756e740000000000000000 // @203C stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1de7 label_2042: // Incoming call from 0x254A, returns to 0x0630 // Inputs[1] { @2045 stack[-1] } 2042 5B JUMPDEST 2043 60 PUSH1 0x17 2045 81 DUP2 2046 52 MSTORE 2047 60 PUSH1 0x00 2049 60 PUSH1 0x20 204B 82 DUP3 204C 01 ADD 204D 7F PUSH32 0x4e6f2070726573616c6520726f6c6c657273206c656674000000000000000000 206E 81 DUP2 206F 52 MSTORE 2070 91 SWAP2 2071 50 POP 2072 61 PUSH2 0x1de7 2075 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @2046 memory[stack[-1]:stack[-1] + 0x20] = 0x17 // @2047 stack[0] = 0x00 // @206F memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4e6f2070726573616c6520726f6c6c657273206c656674000000000000000000 // @2070 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1de7 2076 5B JUMPDEST 2077 60 PUSH1 0x2c 2079 81 DUP2 207A 52 MSTORE 207B 60 PUSH1 0x00 207D 60 PUSH1 0x20 207F 82 DUP3 2080 01 ADD 2081 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 20A2 81 DUP2 20A3 52 MSTORE 20A4 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 20B1 60 PUSH1 0xa1 20B3 1B SHL 20B4 60 PUSH1 0x20 20B6 82 DUP3 20B7 01 ADD 20B8 52 MSTORE 20B9 91 SWAP2 20BA 50 POP 20BB 61 PUSH2 0x1e28 20BE 56 *JUMP 20BF 5B JUMPDEST 20C0 60 PUSH1 0x38 20C2 81 DUP2 20C3 52 MSTORE 20C4 60 PUSH1 0x00 20C6 60 PUSH1 0x20 20C8 82 DUP3 20C9 01 ADD 20CA 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 20EB 81 DUP2 20EC 52 MSTORE 20ED 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 210E 60 PUSH1 0x20 2110 82 DUP3 2111 01 ADD 2112 52 MSTORE 2113 91 SWAP2 2114 50 POP 2115 61 PUSH2 0x1e28 2118 56 *JUMP label_2119: // Incoming call from 0x257A, returns to 0x0630 // Inputs[1] { @211C stack[-1] } 2119 5B JUMPDEST 211A 60 PUSH1 0x2a 211C 81 DUP2 211D 52 MSTORE 211E 60 PUSH1 0x00 2120 60 PUSH1 0x20 2122 82 DUP3 2123 01 ADD 2124 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 2145 81 DUP2 2146 52 MSTORE 2147 69 PUSH10 0x726f2061646472657373 2152 60 PUSH1 0xb0 2154 1B SHL 2155 60 PUSH1 0x20 2157 82 DUP3 2158 01 ADD 2159 52 MSTORE 215A 91 SWAP2 215B 50 POP 215C 61 PUSH2 0x1e28 215F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @211D memory[stack[-1]:stack[-1] + 0x20] = 0x2a // @211E stack[0] = 0x00 // @2146 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 // @2159 memory[stack[-1] + 0x20 + 0x20:stack[-1] + 0x20 + 0x20 + 0x20] = 0x726f2061646472657373 << 0xb0 // @215A stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1e28 label_2160: // Incoming call from 0x258A, returns to 0x0630 // Inputs[1] { @2163 stack[-1] } 2160 5B JUMPDEST 2161 60 PUSH1 0x29 2163 81 DUP2 2164 52 MSTORE 2165 60 PUSH1 0x00 2167 60 PUSH1 0x20 2169 82 DUP3 216A 01 ADD 216B 7F PUSH32 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 218C 81 DUP2 218D 52 MSTORE 218E 68 PUSH9 0x32b73a103a37b5b2b7 2198 60 PUSH1 0xb9 219A 1B SHL 219B 60 PUSH1 0x20 219D 82 DUP3 219E 01 ADD 219F 52 MSTORE 21A0 91 SWAP2 21A1 50 POP 21A2 61 PUSH2 0x1e28 21A5 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @2164 memory[stack[-1]:stack[-1] + 0x20] = 0x29 // @2165 stack[0] = 0x00 // @218D memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 // @219F memory[stack[-1] + 0x20 + 0x20:stack[-1] + 0x20 + 0x20 + 0x20] = 0x32b73a103a37b5b2b7 << 0xb9 // @21A0 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1e28 label_21A6: // Incoming call from 0x259A, returns to 0x0630 // Inputs[1] { @21AA stack[-1] } 21A6 5B JUMPDEST 21A7 60 PUSH1 0x20 21A9 80 DUP1 21AA 82 DUP3 21AB 52 MSTORE 21AC 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 21CD 91 SWAP2 21CE 01 ADD 21CF 90 SWAP1 21D0 81 DUP2 21D1 52 MSTORE 21D2 60 PUSH1 0x00 21D4 61 PUSH2 0x1de7 21D7 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @21AB memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @21CF stack[-1] = stack[-1] + 0x20 // @21D1 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 // @21D2 stack[0] = 0x00 // } // Block ends with unconditional jump to 0x1de7 label_21D8: // Incoming call from 0x25AA, returns to 0x0630 // Inputs[1] { @21DB stack[-1] } 21D8 5B JUMPDEST 21D9 60 PUSH1 0x17 21DB 81 DUP2 21DC 52 MSTORE 21DD 60 PUSH1 0x00 21DF 60 PUSH1 0x20 21E1 82 DUP3 21E2 01 ADD 21E3 7F PUSH32 0x4d6178696d756d20737570706c79206578636565646564000000000000000000 2204 81 DUP2 2205 52 MSTORE 2206 91 SWAP2 2207 50 POP 2208 61 PUSH2 0x1de7 220B 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @21DC memory[stack[-1]:stack[-1] + 0x20] = 0x17 // @21DD stack[0] = 0x00 // @2205 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4d6178696d756d20737570706c79206578636565646564000000000000000000 // @2206 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1de7 label_220C: // Incoming call from 0x25BA, returns to 0x0630 // Inputs[1] { @220F stack[-1] } 220C 5B JUMPDEST 220D 60 PUSH1 0x2c 220F 81 DUP2 2210 52 MSTORE 2211 60 PUSH1 0x00 2213 60 PUSH1 0x20 2215 82 DUP3 2216 01 ADD 2217 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 2238 81 DUP2 2239 52 MSTORE 223A 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 2247 60 PUSH1 0xa1 2249 1B SHL 224A 60 PUSH1 0x20 224C 82 DUP3 224D 01 ADD 224E 52 MSTORE 224F 91 SWAP2 2250 50 POP 2251 61 PUSH2 0x1e28 2254 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @2210 memory[stack[-1]:stack[-1] + 0x20] = 0x2c // @2211 stack[0] = 0x00 // @2239 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 // @224E memory[stack[-1] + 0x20 + 0x20:stack[-1] + 0x20 + 0x20 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @224F stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1e28 label_2255: // Incoming call from 0x25CA, returns to 0x0630 // Inputs[1] { @2259 stack[-1] } 2255 5B JUMPDEST 2256 60 PUSH1 0x20 2258 80 DUP1 2259 82 DUP3 225A 52 MSTORE 225B 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 227C 91 SWAP2 227D 01 ADD 227E 90 SWAP1 227F 81 DUP2 2280 52 MSTORE 2281 60 PUSH1 0x00 2283 61 PUSH2 0x1de7 2286 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @225A memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @227E stack[-1] = stack[-1] + 0x20 // @2280 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @2281 stack[0] = 0x00 // } // Block ends with unconditional jump to 0x1de7 2287 5B JUMPDEST 2288 60 PUSH1 0x29 228A 81 DUP2 228B 52 MSTORE 228C 60 PUSH1 0x00 228E 60 PUSH1 0x20 2290 82 DUP3 2291 01 ADD 2292 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 22B3 81 DUP2 22B4 52 MSTORE 22B5 68 PUSH9 0x39903737ba1037bbb7 22BF 60 PUSH1 0xb9 22C1 1B SHL 22C2 60 PUSH1 0x20 22C4 82 DUP3 22C5 01 ADD 22C6 52 MSTORE 22C7 91 SWAP2 22C8 50 POP 22C9 61 PUSH2 0x1e28 22CC 56 *JUMP label_22CD: // Incoming call from 0x25EA, returns to 0x0630 // Inputs[1] { @22D0 stack[-1] } 22CD 5B JUMPDEST 22CE 60 PUSH1 0x2f 22D0 81 DUP2 22D1 52 MSTORE 22D2 60 PUSH1 0x00 22D4 60 PUSH1 0x20 22D6 82 DUP3 22D7 01 ADD 22D8 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 22F9 81 DUP2 22FA 52 MSTORE 22FB 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 230B 60 PUSH1 0x89 230D 1B SHL 230E 60 PUSH1 0x20 2310 82 DUP3 2311 01 ADD 2312 52 MSTORE 2313 91 SWAP2 2314 50 POP 2315 61 PUSH2 0x1e28 2318 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @22D1 memory[stack[-1]:stack[-1] + 0x20] = 0x2f // @22D2 stack[0] = 0x00 // @22FA memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @2312 memory[stack[-1] + 0x20 + 0x20:stack[-1] + 0x20 + 0x20 + 0x20] = 0x3732bc34b9ba32b73a103a37b5b2b7 << 0x89 // @2313 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1e28 2319 5B JUMPDEST 231A 60 PUSH1 0x21 231C 81 DUP2 231D 52 MSTORE 231E 60 PUSH1 0x00 2320 60 PUSH1 0x20 2322 82 DUP3 2323 01 ADD 2324 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 2345 81 DUP2 2346 52 MSTORE 2347 60 PUSH1 0x39 2349 60 PUSH1 0xf9 234B 1B SHL 234C 60 PUSH1 0x20 234E 82 DUP3 234F 01 ADD 2350 52 MSTORE 2351 91 SWAP2 2352 50 POP 2353 61 PUSH2 0x1e28 2356 56 *JUMP 2357 5B JUMPDEST 2358 60 PUSH1 0x31 235A 81 DUP2 235B 52 MSTORE 235C 60 PUSH1 0x00 235E 60 PUSH1 0x20 2360 82 DUP3 2361 01 ADD 2362 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 2383 81 DUP2 2384 52 MSTORE 2385 70 PUSH17 0x1ddb995c881b9bdc88185c1c1c9bdd9959 2397 60 PUSH1 0x7a 2399 1B SHL 239A 60 PUSH1 0x20 239C 82 DUP3 239D 01 ADD 239E 52 MSTORE 239F 91 SWAP2 23A0 50 POP 23A1 61 PUSH2 0x1e28 23A4 56 *JUMP label_23A5: // Incoming call from 0x261A, returns to 0x0630 // Inputs[1] { @23A8 stack[-1] } 23A5 5B JUMPDEST 23A6 60 PUSH1 0x2c 23A8 81 DUP2 23A9 52 MSTORE 23AA 60 PUSH1 0x00 23AC 60 PUSH1 0x20 23AE 82 DUP3 23AF 01 ADD 23B0 7F PUSH32 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f 23D1 81 DUP2 23D2 52 MSTORE 23D3 6B PUSH12 0x7574206f6620626f756e6473 23E0 60 PUSH1 0xa0 23E2 1B SHL 23E3 60 PUSH1 0x20 23E5 82 DUP3 23E6 01 ADD 23E7 52 MSTORE 23E8 91 SWAP2 23E9 50 POP 23EA 61 PUSH2 0x1e28 23ED 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @23A9 memory[stack[-1]:stack[-1] + 0x20] = 0x2c // @23AA stack[0] = 0x00 // @23D2 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f // @23E7 memory[stack[-1] + 0x20 + 0x20:stack[-1] + 0x20 + 0x20 + 0x20] = 0x7574206f6620626f756e6473 << 0xa0 // @23E8 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1e28 label_23EE: // Incoming call from 0x2628, returns to 0x0875 // Inputs[1] { @23EF stack[-1] } 23EE 5B JUMPDEST 23EF 80 DUP1 23F0 61 PUSH2 0x1d54 23F3 56 *JUMP // Stack delta = +1 // Outputs[1] { @23EF stack[0] = stack[-1] } // Block ends with unconditional jump to 0x1d54 23F4 5B JUMPDEST 23F5 60 PUSH1 0x00 23F7 61 PUSH2 0x2400 23FA 82 DUP3 23FB 85 DUP6 23FC 61 PUSH2 0x1d9d 23FF 56 *JUMP 2400 5B JUMPDEST 2401 91 SWAP2 2402 50 POP 2403 61 PUSH2 0x1024 2406 82 DUP3 2407 84 DUP5 2408 61 PUSH2 0x1d9d 240B 56 *JUMP label_240C: // Incoming jump from 0x0299 // Inputs[2] // { // @240F stack[-1] // @2415 stack[-2] // } 240C 5B JUMPDEST 240D 60 PUSH1 0x20 240F 81 DUP2 2410 01 ADD 2411 61 PUSH2 0x0875 2414 82 DUP3 2415 84 DUP5 2416 61 PUSH2 0x1d4b 2419 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2410 stack[0] = stack[-1] + 0x20 // @2411 stack[1] = 0x0875 // @2414 stack[2] = stack[-1] // @2415 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1d4b label_241A: // Incoming jump from 0x14CA // Inputs[2] // { // @241D stack[-1] // @2423 stack[-5] // } 241A 5B JUMPDEST 241B 60 PUSH1 0x80 241D 81 DUP2 241E 01 ADD 241F 61 PUSH2 0x2428 2422 82 DUP3 2423 87 DUP8 2424 61 PUSH2 0x1d4b 2427 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @241E stack[0] = stack[-1] + 0x80 // @241F stack[1] = 0x2428 // @2422 stack[2] = stack[-1] // @2423 stack[3] = stack[-5] // } // Block ends with unconditional jump to 0x1d4b 2428 5B JUMPDEST 2429 61 PUSH2 0x2435 242C 60 PUSH1 0x20 242E 83 DUP4 242F 01 ADD 2430 86 DUP7 2431 61 PUSH2 0x1d4b 2434 56 *JUMP 2435 5B JUMPDEST 2436 61 PUSH2 0x2442 2439 60 PUSH1 0x40 243B 83 DUP4 243C 01 ADD 243D 85 DUP6 243E 61 PUSH2 0x23ee 2441 56 *JUMP 2442 5B JUMPDEST 2443 81 DUP2 2444 81 DUP2 2445 03 SUB 2446 60 PUSH1 0x60 2448 83 DUP4 2449 01 ADD 244A 52 MSTORE 244B 61 PUSH2 0x2454 244E 81 DUP2 244F 84 DUP5 2450 61 PUSH2 0x1d62 2453 56 *JUMP 2454 5B JUMPDEST 2455 96 SWAP7 2456 95 SWAP6 2457 50 POP 2458 50 POP 2459 50 POP 245A 50 POP 245B 50 POP 245C 50 POP 245D 56 *JUMP 245E 5B JUMPDEST 245F 60 PUSH1 0x20 2461 81 DUP2 2462 01 ADD 2463 61 PUSH2 0x0875 2466 82 DUP3 2467 84 DUP5 2468 61 PUSH2 0x1d5a 246B 56 *JUMP label_246C: // Incoming jump from 0x040A // Inputs[2] // { // @246F stack[-1] // @2475 stack[-2] // } 246C 5B JUMPDEST 246D 60 PUSH1 0x20 246F 81 DUP2 2470 01 ADD 2471 61 PUSH2 0x0875 2474 82 DUP3 2475 84 DUP5 2476 61 PUSH2 0x1d94 2479 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2470 stack[0] = stack[-1] + 0x20 // @2471 stack[1] = 0x0875 // @2474 stack[2] = stack[-1] // @2475 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1d94 label_247A: // Incoming call from 0x026C, returns to 0x0215 // Inputs[2] // { // @247E stack[-1] // @2486 stack[-2] // } 247A 5B JUMPDEST 247B 60 PUSH1 0x20 247D 80 DUP1 247E 82 DUP3 247F 52 MSTORE 2480 81 DUP2 2481 01 ADD 2482 61 PUSH2 0x0d58 2485 81 DUP2 2486 84 DUP5 2487 61 PUSH2 0x1d62 248A 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @247F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2481 stack[0] = stack[-1] + 0x20 // @2482 stack[1] = 0x0d58 // @2485 stack[2] = stack[-1] + 0x20 // @2486 stack[3] = stack[-2] // } // Block ends with call to 0x1d62, returns to 0x0D58 label_248B: // Incoming jump from 0x09D5 // Inputs[1] { @248F stack[-1] } 248B 5B JUMPDEST 248C 60 PUSH1 0x20 248E 80 DUP1 248F 82 DUP3 2490 52 MSTORE 2491 81 DUP2 2492 01 ADD 2493 61 PUSH2 0x0630 2496 81 DUP2 2497 61 PUSH2 0x1dbf 249A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2490 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2492 stack[0] = stack[-1] + 0x20 // @2493 stack[1] = 0x0630 // @2496 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1dbf, returns to 0x0630 label_249B: // Incoming jump from 0x0E5A // Inputs[1] { @249F stack[-1] } 249B 5B JUMPDEST 249C 60 PUSH1 0x20 249E 80 DUP1 249F 82 DUP3 24A0 52 MSTORE 24A1 81 DUP2 24A2 01 ADD 24A3 61 PUSH2 0x0630 24A6 81 DUP2 24A7 61 PUSH2 0x1dee 24AA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @24A0 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @24A2 stack[0] = stack[-1] + 0x20 // @24A3 stack[1] = 0x0630 // @24A6 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1dee, returns to 0x0630 24AB 5B JUMPDEST 24AC 60 PUSH1 0x20 24AE 80 DUP1 24AF 82 DUP3 24B0 52 MSTORE 24B1 81 DUP2 24B2 01 ADD 24B3 61 PUSH2 0x0630 24B6 81 DUP2 24B7 61 PUSH2 0x1e2f 24BA 56 *JUMP label_24BB: // Incoming jump from 0x1683 // Inputs[1] { @24BF stack[-1] } 24BB 5B JUMPDEST 24BC 60 PUSH1 0x20 24BE 80 DUP1 24BF 82 DUP3 24C0 52 MSTORE 24C1 81 DUP2 24C2 01 ADD 24C3 61 PUSH2 0x0630 24C6 81 DUP2 24C7 61 PUSH2 0x1e77 24CA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @24C0 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @24C2 stack[0] = stack[-1] + 0x20 // @24C3 stack[1] = 0x0630 // @24C6 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1e77, returns to 0x0630 24CB 5B JUMPDEST 24CC 60 PUSH1 0x20 24CE 80 DUP1 24CF 82 DUP3 24D0 52 MSTORE 24D1 81 DUP2 24D2 01 ADD 24D3 61 PUSH2 0x0630 24D6 81 DUP2 24D7 61 PUSH2 0x1ec6 24DA 56 *JUMP label_24DB: // Incoming jump from 0x09F6 // Inputs[1] { @24DF stack[-1] } 24DB 5B JUMPDEST 24DC 60 PUSH1 0x20 24DE 80 DUP1 24DF 82 DUP3 24E0 52 MSTORE 24E1 81 DUP2 24E2 01 ADD 24E3 61 PUSH2 0x0630 24E6 81 DUP2 24E7 61 PUSH2 0x1f09 24EA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @24E0 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @24E2 stack[0] = stack[-1] + 0x20 // @24E3 stack[1] = 0x0630 // @24E6 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1f09, returns to 0x0630 label_24EB: // Incoming jump from 0x1898 // Inputs[1] { @24EF stack[-1] } 24EB 5B JUMPDEST 24EC 60 PUSH1 0x20 24EE 80 DUP1 24EF 82 DUP3 24F0 52 MSTORE 24F1 81 DUP2 24F2 01 ADD 24F3 61 PUSH2 0x0630 24F6 81 DUP2 24F7 61 PUSH2 0x1f3d 24FA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @24F0 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @24F2 stack[0] = stack[-1] + 0x20 // @24F3 stack[1] = 0x0630 // @24F6 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1f3d, returns to 0x0630 label_24FB: // Incoming jump from 0x0E0D // Inputs[1] { @24FF stack[-1] } 24FB 5B JUMPDEST 24FC 60 PUSH1 0x20 24FE 80 DUP1 24FF 82 DUP3 2500 52 MSTORE 2501 81 DUP2 2502 01 ADD 2503 61 PUSH2 0x0630 2506 81 DUP2 2507 61 PUSH2 0x1f71 250A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2500 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2502 stack[0] = stack[-1] + 0x20 // @2503 stack[1] = 0x0630 // @2506 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1f71, returns to 0x0630 250B 5B JUMPDEST 250C 60 PUSH1 0x20 250E 80 DUP1 250F 82 DUP3 2510 52 MSTORE 2511 81 DUP2 2512 01 ADD 2513 61 PUSH2 0x0630 2516 81 DUP2 2517 61 PUSH2 0x1f99 251A 56 *JUMP 251B 5B JUMPDEST 251C 60 PUSH1 0x20 251E 80 DUP1 251F 82 DUP3 2520 52 MSTORE 2521 81 DUP2 2522 01 ADD 2523 61 PUSH2 0x0630 2526 81 DUP2 2527 61 PUSH2 0x1fda 252A 56 *JUMP label_252B: // Incoming jump from 0x0A22 // Incoming jump from 0x0E86 // Inputs[1] { @252F stack[-1] } 252B 5B JUMPDEST 252C 60 PUSH1 0x20 252E 80 DUP1 252F 82 DUP3 2530 52 MSTORE 2531 81 DUP2 2532 01 ADD 2533 61 PUSH2 0x0630 2536 81 DUP2 2537 61 PUSH2 0x200e 253A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2530 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2532 stack[0] = stack[-1] + 0x20 // @2533 stack[1] = 0x0630 // @2536 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x200e, returns to 0x0630 label_253B: // Incoming jump from 0x0E3A // Inputs[1] { @253F stack[-1] } 253B 5B JUMPDEST 253C 60 PUSH1 0x20 253E 80 DUP1 253F 82 DUP3 2540 52 MSTORE 2541 81 DUP2 2542 01 ADD 2543 61 PUSH2 0x0630 2546 81 DUP2 2547 61 PUSH2 0x2042 254A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2540 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2542 stack[0] = stack[-1] + 0x20 // @2543 stack[1] = 0x0630 // @2546 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2042, returns to 0x0630 254B 5B JUMPDEST 254C 60 PUSH1 0x20 254E 80 DUP1 254F 82 DUP3 2550 52 MSTORE 2551 81 DUP2 2552 01 ADD 2553 61 PUSH2 0x0630 2556 81 DUP2 2557 61 PUSH2 0x2076 255A 56 *JUMP 255B 5B JUMPDEST 255C 60 PUSH1 0x20 255E 80 DUP1 255F 82 DUP3 2560 52 MSTORE 2561 81 DUP2 2562 01 ADD 2563 61 PUSH2 0x0630 2566 81 DUP2 2567 61 PUSH2 0x20bf 256A 56 *JUMP label_256B: // Incoming jump from 0x0B50 // Inputs[1] { @256F stack[-1] } 256B 5B JUMPDEST 256C 60 PUSH1 0x20 256E 80 DUP1 256F 82 DUP3 2570 52 MSTORE 2571 81 DUP2 2572 01 ADD 2573 61 PUSH2 0x0630 2576 81 DUP2 2577 61 PUSH2 0x2119 257A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2570 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2572 stack[0] = stack[-1] + 0x20 // @2573 stack[1] = 0x0630 // @2576 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2119, returns to 0x0630 label_257B: // Incoming jump from 0x0A9A // Inputs[1] { @257F stack[-1] } 257B 5B JUMPDEST 257C 60 PUSH1 0x20 257E 80 DUP1 257F 82 DUP3 2580 52 MSTORE 2581 81 DUP2 2582 01 ADD 2583 61 PUSH2 0x0630 2586 81 DUP2 2587 61 PUSH2 0x2160 258A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2580 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2582 stack[0] = stack[-1] + 0x20 // @2583 stack[1] = 0x0630 // @2586 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2160, returns to 0x0630 label_258B: // Incoming jump from 0x1863 // Inputs[1] { @258F stack[-1] } 258B 5B JUMPDEST 258C 60 PUSH1 0x20 258E 80 DUP1 258F 82 DUP3 2590 52 MSTORE 2591 81 DUP2 2592 01 ADD 2593 61 PUSH2 0x0630 2596 81 DUP2 2597 61 PUSH2 0x21a6 259A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2590 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2592 stack[0] = stack[-1] + 0x20 // @2593 stack[1] = 0x0630 // @2596 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x21a6, returns to 0x0630 label_259B: // Incoming jump from 0x1190 // Inputs[1] { @259F stack[-1] } 259B 5B JUMPDEST 259C 60 PUSH1 0x20 259E 80 DUP1 259F 82 DUP3 25A0 52 MSTORE 25A1 81 DUP2 25A2 01 ADD 25A3 61 PUSH2 0x0630 25A6 81 DUP2 25A7 61 PUSH2 0x21d8 25AA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @25A0 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @25A2 stack[0] = stack[-1] + 0x20 // @25A3 stack[1] = 0x0630 // @25A6 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x21d8, returns to 0x0630 label_25AB: // Incoming jump from 0x06FD // Inputs[1] { @25AF stack[-1] } 25AB 5B JUMPDEST 25AC 60 PUSH1 0x20 25AE 80 DUP1 25AF 82 DUP3 25B0 52 MSTORE 25B1 81 DUP2 25B2 01 ADD 25B3 61 PUSH2 0x0630 25B6 81 DUP2 25B7 61 PUSH2 0x220c 25BA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @25B0 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @25B2 stack[0] = stack[-1] + 0x20 // @25B3 stack[1] = 0x0630 // @25B6 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x220c, returns to 0x0630 label_25BB: // Incoming call from 0x095C, returns to 0x06FE // Incoming call from 0x0B96, returns to 0x06FE // Inputs[1] { @25BF stack[-1] } 25BB 5B JUMPDEST 25BC 60 PUSH1 0x20 25BE 80 DUP1 25BF 82 DUP3 25C0 52 MSTORE 25C1 81 DUP2 25C2 01 ADD 25C3 61 PUSH2 0x0630 25C6 81 DUP2 25C7 61 PUSH2 0x2255 25CA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @25C0 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @25C2 stack[0] = stack[-1] + 0x20 // @25C3 stack[1] = 0x0630 // @25C6 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2255, returns to 0x0630 25CB 5B JUMPDEST 25CC 60 PUSH1 0x20 25CE 80 DUP1 25CF 82 DUP3 25D0 52 MSTORE 25D1 81 DUP2 25D2 01 ADD 25D3 61 PUSH2 0x0630 25D6 81 DUP2 25D7 61 PUSH2 0x2287 25DA 56 *JUMP label_25DB: // Incoming jump from 0x0D02 // Inputs[1] { @25DF stack[-1] } 25DB 5B JUMPDEST 25DC 60 PUSH1 0x20 25DE 80 DUP1 25DF 82 DUP3 25E0 52 MSTORE 25E1 81 DUP2 25E2 01 ADD 25E3 61 PUSH2 0x0630 25E6 81 DUP2 25E7 61 PUSH2 0x22cd 25EA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @25E0 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @25E2 stack[0] = stack[-1] + 0x20 // @25E3 stack[1] = 0x0630 // @25E6 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x22cd, returns to 0x0630 25EB 5B JUMPDEST 25EC 60 PUSH1 0x20 25EE 80 DUP1 25EF 82 DUP3 25F0 52 MSTORE 25F1 81 DUP2 25F2 01 ADD 25F3 61 PUSH2 0x0630 25F6 81 DUP2 25F7 61 PUSH2 0x2319 25FA 56 *JUMP 25FB 5B JUMPDEST 25FC 60 PUSH1 0x20 25FE 80 DUP1 25FF 82 DUP3 2600 52 MSTORE 2601 81 DUP2 2602 01 ADD 2603 61 PUSH2 0x0630 2606 81 DUP2 2607 61 PUSH2 0x2357 260A 56 *JUMP label_260B: // Incoming jump from 0x08BE // Inputs[1] { @260F stack[-1] } 260B 5B JUMPDEST 260C 60 PUSH1 0x20 260E 80 DUP1 260F 82 DUP3 2610 52 MSTORE 2611 81 DUP2 2612 01 ADD 2613 61 PUSH2 0x0630 2616 81 DUP2 2617 61 PUSH2 0x23a5 261A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2610 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2612 stack[0] = stack[-1] + 0x20 // @2613 stack[1] = 0x0630 // @2616 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x23a5, returns to 0x0630 label_261B: // Incoming call from 0x0214, returns to 0x0215 // Inputs[2] // { // @261E stack[-1] // @2624 stack[-2] // } 261B 5B JUMPDEST 261C 60 PUSH1 0x20 261E 81 DUP2 261F 01 ADD 2620 61 PUSH2 0x0875 2623 82 DUP3 2624 84 DUP5 2625 61 PUSH2 0x23ee 2628 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @261F stack[0] = stack[-1] + 0x20 // @2620 stack[1] = 0x0875 // @2623 stack[2] = stack[-1] // @2624 stack[3] = stack[-2] // } // Block ends with call to 0x23ee, returns to 0x0875 label_2629: // Incoming jump from 0x19D7 // Inputs[1] { @2631 memory[0x40:0x60] } 2629 5B JUMPDEST 262A 60 PUSH1 0x00 262C 61 PUSH2 0x2634 262F 60 PUSH1 0x40 2631 51 MLOAD 2632 90 SWAP1 2633 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @262A stack[0] = 0x00 // @2632 stack[1] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2634 label_2634: // Incoming jump from 0x2633 // Inputs[3] // { // @2635 stack[-2] // @2635 stack[-1] // @263A stack[-3] // } 2634 5B JUMPDEST 2635 90 SWAP1 2636 50 POP 2637 61 PUSH2 0x0633 263A 82 DUP3 263B 82 DUP3 263C 61 PUSH2 0x277c 263F 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2635 stack[-2] = stack[-1] // @2637 stack[-1] = 0x0633 // @263A stack[0] = stack[-3] // @263B stack[1] = stack[-1] // } // Block ends with call to 0x277c, returns to 0x0633 label_2640: // Incoming call from 0x19D2, returns to 0x19D3 // Inputs[1] { @264C stack[-1] } 2640 5B JUMPDEST 2641 60 PUSH1 0x00 2643 67 PUSH8 0xffffffffffffffff 264C 82 DUP3 264D 11 GT 264E 15 ISZERO 264F 61 PUSH2 0x265a 2652 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2641 stack[0] = 0x00 } // Block ends with conditional jump to 0x265a, if !(stack[-1] > 0xffffffffffffffff) label_2653: // Incoming jump from 0x2652, if not !(stack[-1] > 0xffffffffffffffff) 2653 61 PUSH2 0x265a 2656 61 PUSH2 0x2830 2659 56 *JUMP // Stack delta = +1 // Outputs[1] { @2653 stack[0] = 0x265a } // Block ends with unconditional jump to 0x2830 label_265A: // Incoming jump from 0x2652, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @265E stack[-2] // @2662 stack[-3] // } 265A 5B JUMPDEST 265B 50 POP 265C 60 PUSH1 0x20 265E 90 SWAP1 265F 81 DUP2 2660 02 MUL 2661 01 ADD 2662 90 SWAP1 2663 56 *JUMP // Stack delta = -2 // Outputs[1] { @2662 stack[-3] = 0x20 * stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_2664: // Incoming call from 0x1A3A, returns to 0x19D3 // Inputs[1] { @2670 stack[-1] } 2664 5B JUMPDEST 2665 60 PUSH1 0x00 2667 67 PUSH8 0xffffffffffffffff 2670 82 DUP3 2671 11 GT 2672 15 ISZERO 2673 61 PUSH2 0x267e 2676 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2665 stack[0] = 0x00 } // Block ends with conditional jump to 0x267e, if !(stack[-1] > 0xffffffffffffffff) label_2677: // Incoming jump from 0x2676, if not !(stack[-1] > 0xffffffffffffffff) 2677 61 PUSH2 0x267e 267A 61 PUSH2 0x2830 267D 56 *JUMP // Stack delta = +1 // Outputs[1] { @2677 stack[0] = 0x267e } // Block ends with unconditional jump to 0x2830 label_267E: // Incoming jump from 0x2676, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @2684 stack[-2] // @268A stack[-3] // } 267E 5B JUMPDEST 267F 60 PUSH1 0x1f 2681 19 NOT 2682 60 PUSH1 0x1f 2684 83 DUP4 2685 01 ADD 2686 16 AND 2687 60 PUSH1 0x20 2689 01 ADD 268A 92 SWAP3 268B 91 SWAP2 268C 50 POP 268D 50 POP 268E 56 *JUMP // Stack delta = -2 // Outputs[1] { @268A stack[-3] = 0x20 + (stack[-2] + 0x1f & ~0x1f) } // Block ends with unconditional jump to stack[-3] label_268F: // Incoming call from 0x1172, returns to 0x1173 // Incoming call from 0x11A8, returns to 0x11A9 // Incoming call from 0x18CD, returns to 0x18CE // Inputs[2] // { // @2692 stack[-2] // @2694 stack[-1] // } 268F 5B JUMPDEST 2690 60 PUSH1 0x00 2692 82 DUP3 2693 19 NOT 2694 82 DUP3 2695 11 GT 2696 15 ISZERO 2697 61 PUSH2 0x26a2 269A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2690 stack[0] = 0x00 } // Block ends with conditional jump to 0x26a2, if !(stack[-1] > ~stack[-2]) label_269B: // Incoming jump from 0x269A, if not !(stack[-1] > ~stack[-2]) 269B 61 PUSH2 0x26a2 269E 61 PUSH2 0x27d8 26A1 56 *JUMP // Stack delta = +1 // Outputs[1] { @269B stack[0] = 0x26a2 } // Block ends with unconditional jump to 0x27d8 label_26A2: // Incoming jump from 0x269A, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @26A4 stack[-2] // @26A4 stack[-3] // @26A5 stack[-4] // } 26A2 5B JUMPDEST 26A3 50 POP 26A4 01 ADD 26A5 90 SWAP1 26A6 56 *JUMP // Stack delta = -3 // Outputs[1] { @26A5 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] 26A7 5B JUMPDEST 26A8 60 PUSH1 0x00 26AA 82 DUP3 26AB 61 PUSH2 0x26b6 26AE 57 *JUMPI 26AF 61 PUSH2 0x26b6 26B2 61 PUSH2 0x27ee 26B5 56 *JUMP 26B6 5B JUMPDEST 26B7 50 POP 26B8 04 DIV 26B9 90 SWAP1 26BA 56 *JUMP label_26BB: // Incoming call from 0x0E68, returns to 0x0E69 // Incoming call from 0x0A04, returns to 0x0A05 // Inputs[2] // { // @26BE stack[-1] // @26C3 stack[-2] // } 26BB 5B JUMPDEST 26BC 60 PUSH1 0x00 26BE 81 DUP2 26BF 60 PUSH1 0x00 26C1 19 NOT 26C2 04 DIV 26C3 83 DUP4 26C4 11 GT 26C5 82 DUP3 26C6 15 ISZERO 26C7 15 ISZERO 26C8 16 AND 26C9 15 ISZERO 26CA 61 PUSH2 0x26d5 26CD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26BC stack[0] = 0x00 } // Block ends with conditional jump to 0x26d5, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_26CE: // Incoming jump from 0x26CD, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 26CE 61 PUSH2 0x26d5 26D1 61 PUSH2 0x27d8 26D4 56 *JUMP // Stack delta = +1 // Outputs[1] { @26CE stack[0] = 0x26d5 } // Block ends with unconditional jump to 0x27d8 label_26D5: // Incoming jump from 0x26CD, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @26D7 stack[-2] // @26D7 stack[-3] // @26D8 stack[-4] // } 26D5 5B JUMPDEST 26D6 50 POP 26D7 02 MUL 26D8 90 SWAP1 26D9 56 *JUMP // Stack delta = -3 // Outputs[1] { @26D8 stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_26DA: // Incoming call from 0x169A, returns to 0x169B // Incoming call from 0x0E90, returns to 0x0E91 // Incoming call from 0x1732, returns to 0x1733 // Inputs[2] // { // @26DD stack[-2] // @26DE stack[-1] // } 26DA 5B JUMPDEST 26DB 60 PUSH1 0x00 26DD 82 DUP3 26DE 82 DUP3 26DF 10 LT 26E0 15 ISZERO 26E1 61 PUSH2 0x26ec 26E4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26DB stack[0] = 0x00 } // Block ends with conditional jump to 0x26ec, if !(stack[-1] < stack[-2]) label_26E5: // Incoming jump from 0x26E4, if not !(stack[-1] < stack[-2]) 26E5 61 PUSH2 0x26ec 26E8 61 PUSH2 0x27d8 26EB 56 *JUMP // Stack delta = +1 // Outputs[1] { @26E5 stack[0] = 0x26ec } // Block ends with unconditional jump to 0x27d8 label_26EC: // Incoming jump from 0x26E4, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @26EE stack[-3] // @26EE stack[-2] // @26EF stack[-4] // } 26EC 5B JUMPDEST 26ED 50 POP 26EE 03 SUB 26EF 90 SWAP1 26F0 56 *JUMP // Stack delta = -3 // Outputs[1] { @26EF stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_26F1: // Incoming call from 0x1D53, returns to 0x1D54 // Incoming call from 0x285E, returns to 0x285F // Inputs[1] { @26FC stack[-1] } 26F1 5B JUMPDEST 26F2 60 PUSH1 0x00 26F4 60 PUSH1 0x01 26F6 60 PUSH1 0x01 26F8 60 PUSH1 0xa0 26FA 1B SHL 26FB 03 SUB 26FC 82 DUP3 26FD 16 AND 26FE 61 PUSH2 0x0630 2701 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @26F2 stack[0] = 0x00 // @26FD stack[1] = stack[-1] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x0630 label_2702: // Incoming call from 0x2716, returns to 0x0630 // Inputs[1] { @2703 stack[-1] } 2702 5B JUMPDEST 2703 80 DUP1 2704 61 PUSH2 0x0633 2707 81 DUP2 2708 61 PUSH2 0x2846 270B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2703 stack[0] = stack[-1] // @2704 stack[1] = 0x0633 // @2707 stack[2] = stack[-1] // } // Block ends with call to 0x2846, returns to 0x0633 label_270C: // Incoming call from 0x1D9C, returns to 0x1D54 // Inputs[1] { @2712 stack[-1] } 270C 5B JUMPDEST 270D 60 PUSH1 0x00 270F 61 PUSH2 0x0630 2712 82 DUP3 2713 61 PUSH2 0x2702 2716 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @270D stack[0] = 0x00 // @270F stack[1] = 0x0630 // @2712 stack[2] = stack[-1] // } // Block ends with call to 0x2702, returns to 0x0630 2717 5B JUMPDEST 2718 82 DUP3 2719 81 DUP2 271A 83 DUP4 271B 37 CALLDATACOPY 271C 50 POP 271D 60 PUSH1 0x00 271F 91 SWAP2 2720 01 ADD 2721 52 MSTORE 2722 56 *JUMP label_2723: // Incoming call from 0x1D82, returns to 0x1D83 // Inputs[1] { @2727 stack[-3] } 2723 5B JUMPDEST 2724 60 PUSH1 0x00 2726 5B JUMPDEST 2727 83 DUP4 2728 81 DUP2 2729 10 LT 272A 15 ISZERO 272B 61 PUSH2 0x273e 272E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2724 stack[0] = 0x00 } // Block ends with conditional jump to 0x273e, if !(0x00 < stack[-3]) label_272F: // Incoming jump from 0x272E, if not !(0x00 < stack[-3]) // Incoming jump from 0x272E, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @272F stack[-2] // @2730 stack[-1] // @2732 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2733 stack[-3] // } 272F 81 DUP2 2730 81 DUP2 2731 01 ADD 2732 51 MLOAD 2733 83 DUP4 2734 82 DUP3 2735 01 ADD 2736 52 MSTORE 2737 60 PUSH1 0x20 2739 01 ADD 273A 61 PUSH2 0x2726 273D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2736 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2739 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2726 label_273E: // Incoming jump from 0x272E, if !(0x00 < stack[-3]) // Incoming jump from 0x272E, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @273F stack[-4] // @2740 stack[-1] // } 273E 5B JUMPDEST 273F 83 DUP4 2740 81 DUP2 2741 11 GT 2742 15 ISZERO 2743 61 PUSH2 0x0cc6 2746 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cc6, if !(stack[-1] > stack[-4]) label_2747: // Incoming jump from 0x2746, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @274B stack[-4] // @274C stack[-3] // @274E stack[-5] // } 2747 50 POP 2748 50 POP 2749 60 PUSH1 0x00 274B 91 SWAP2 274C 01 ADD 274D 52 MSTORE 274E 56 *JUMP // Stack delta = -5 // Outputs[1] { @274D memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_274F: // Incoming call from 0x0D6D, returns to 0x0647 // Incoming call from 0x12F6, returns to 0x0647 // Incoming call from 0x0672, returns to 0x0673 // Incoming call from 0x0646, returns to 0x0647 // Incoming call from 0x0AA7, returns to 0x0AA8 // Incoming call from 0x0C88, returns to 0x0647 // Incoming call from 0x0AD3, returns to 0x0AD4 // Inputs[1] { @2752 stack[-1] } 274F 5B JUMPDEST 2750 60 PUSH1 0x02 2752 81 DUP2 2753 04 DIV 2754 60 PUSH1 0x01 2756 82 DUP3 2757 16 AND 2758 80 DUP1 2759 61 PUSH2 0x2763 275C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2753 stack[0] = stack[-1] / 0x02 // @2757 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2763, if stack[-1] & 0x01 label_275D: // Incoming jump from 0x275C, if not stack[-1] & 0x01 // Inputs[2] // { // @275F stack[-2] // @2768 stack[-1] // } 275D 60 PUSH1 0x7f 275F 82 DUP3 2760 16 AND 2761 91 SWAP2 2762 50 POP 2763 5B JUMPDEST 2764 60 PUSH1 0x20 2766 82 DUP3 2767 10 LT 2768 81 DUP2 2769 14 EQ 276A 15 ISZERO 276B 61 PUSH2 0x2776 276E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2761 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x2776, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_276F: // Incoming jump from 0x276E, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x276E, if not !(stack[-1] == (stack[-2] < 0x20)) 276F 61 PUSH2 0x2776 2772 61 PUSH2 0x281a 2775 56 *JUMP // Stack delta = +1 // Outputs[1] { @276F stack[0] = 0x2776 } // Block ends with unconditional jump to 0x281a label_2776: // Incoming jump from 0x276E, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x276E, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @2778 stack[-4] // @2778 stack[-2] // @2779 stack[-3] // } 2776 5B JUMPDEST 2777 50 POP 2778 91 SWAP2 2779 90 SWAP1 277A 50 POP 277B 56 *JUMP // Stack delta = -3 // Outputs[1] { @2778 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_277C: // Incoming call from 0x263F, returns to 0x0633 // Inputs[2] // { // @2782 stack[-2] // @2785 stack[-1] // } 277C 5B JUMPDEST 277D 60 PUSH1 0x1f 277F 19 NOT 2780 60 PUSH1 0x1f 2782 83 DUP4 2783 01 ADD 2784 16 AND 2785 81 DUP2 2786 01 ADD 2787 81 DUP2 2788 81 DUP2 2789 10 LT 278A 67 PUSH8 0xffffffffffffffff 2793 82 DUP3 2794 11 GT 2795 17 OR 2796 15 ISZERO 2797 61 PUSH2 0x27a2 279A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2786 stack[0] = stack[-1] + (stack[-2] + 0x1f & ~0x1f) } // Block ends with conditional jump to 0x27a2, if !((stack[-1] + (stack[-2] + 0x1f & ~0x1f) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1])) label_279B: // Incoming jump from 0x279A, if not !((stack[-1] + (stack[-2] + 0x1f & ~0x1f) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1])) 279B 61 PUSH2 0x27a2 279E 61 PUSH2 0x2830 27A1 56 *JUMP // Stack delta = +1 // Outputs[1] { @279B stack[0] = 0x27a2 } // Block ends with unconditional jump to 0x2830 label_27A2: // Incoming jump from 0x279A, if !((stack[-1] + (stack[-2] + 0x1f & ~0x1f) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1])) // Inputs[2] // { // @27A5 stack[-1] // @27A8 stack[-4] // } 27A2 5B JUMPDEST 27A3 60 PUSH1 0x40 27A5 52 MSTORE 27A6 50 POP 27A7 50 POP 27A8 56 *JUMP // Stack delta = -4 // Outputs[1] { @27A5 memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] 27A9 5B JUMPDEST 27AA 60 PUSH1 0x00 27AC 60 PUSH1 0x00 27AE 19 NOT 27AF 82 DUP3 27B0 14 EQ 27B1 15 ISZERO 27B2 61 PUSH2 0x27bd 27B5 57 *JUMPI 27B6 61 PUSH2 0x27bd 27B9 61 PUSH2 0x27d8 27BC 56 *JUMP 27BD 5B JUMPDEST 27BE 50 POP 27BF 60 PUSH1 0x01 27C1 01 ADD 27C2 90 SWAP1 27C3 56 *JUMP 27C4 5B JUMPDEST 27C5 60 PUSH1 0x00 27C7 82 DUP3 27C8 61 PUSH2 0x27d3 27CB 57 *JUMPI 27CC 61 PUSH2 0x27d3 27CF 61 PUSH2 0x27ee 27D2 56 *JUMP 27D3 5B JUMPDEST 27D4 50 POP 27D5 06 MOD 27D6 90 SWAP1 27D7 56 *JUMP label_27D8: // Incoming jump from 0x26D4 // Incoming jump from 0x26A1 // Incoming jump from 0x26EB // Inputs[1] { @27ED memory[0x00:0x24] } 27D8 5B JUMPDEST 27D9 63 PUSH4 0x4e487b71 27DE 60 PUSH1 0xe0 27E0 1B SHL 27E1 60 PUSH1 0x00 27E3 52 MSTORE 27E4 60 PUSH1 0x11 27E6 60 PUSH1 0x04 27E8 52 MSTORE 27E9 60 PUSH1 0x24 27EB 60 PUSH1 0x00 27ED FD *REVERT // Stack delta = +0 // Outputs[3] // { // @27E3 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @27E8 memory[0x04:0x24] = 0x11 // @27ED revert(memory[0x00:0x24]); // } // Block terminates 27EE 5B JUMPDEST 27EF 63 PUSH4 0x4e487b71 27F4 60 PUSH1 0xe0 27F6 1B SHL 27F7 60 PUSH1 0x00 27F9 52 MSTORE 27FA 60 PUSH1 0x12 27FC 60 PUSH1 0x04 27FE 52 MSTORE 27FF 60 PUSH1 0x24 2801 60 PUSH1 0x00 2803 FD *REVERT label_2804: // Incoming jump from 0x2855 // Inputs[1] { @2819 memory[0x00:0x24] } 2804 5B JUMPDEST 2805 63 PUSH4 0x4e487b71 280A 60 PUSH1 0xe0 280C 1B SHL 280D 60 PUSH1 0x00 280F 52 MSTORE 2810 60 PUSH1 0x21 2812 60 PUSH1 0x04 2814 52 MSTORE 2815 60 PUSH1 0x24 2817 60 PUSH1 0x00 2819 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @280F memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2814 memory[0x04:0x24] = 0x21 // @2819 revert(memory[0x00:0x24]); // } // Block terminates label_281A: // Incoming jump from 0x2775 // Inputs[1] { @282F memory[0x00:0x24] } 281A 5B JUMPDEST 281B 63 PUSH4 0x4e487b71 2820 60 PUSH1 0xe0 2822 1B SHL 2823 60 PUSH1 0x00 2825 52 MSTORE 2826 60 PUSH1 0x22 2828 60 PUSH1 0x04 282A 52 MSTORE 282B 60 PUSH1 0x24 282D 60 PUSH1 0x00 282F FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2825 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @282A memory[0x04:0x24] = 0x22 // @282F revert(memory[0x00:0x24]); // } // Block terminates label_2830: // Incoming jump from 0x2659 // Incoming jump from 0x27A1 // Incoming jump from 0x267D // Inputs[1] { @2845 memory[0x00:0x24] } 2830 5B JUMPDEST 2831 63 PUSH4 0x4e487b71 2836 60 PUSH1 0xe0 2838 1B SHL 2839 60 PUSH1 0x00 283B 52 MSTORE 283C 60 PUSH1 0x41 283E 60 PUSH1 0x04 2840 52 MSTORE 2841 60 PUSH1 0x24 2843 60 PUSH1 0x00 2845 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @283B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2840 memory[0x04:0x24] = 0x41 // @2845 revert(memory[0x00:0x24]); // } // Block terminates label_2846: // Incoming call from 0x270B, returns to 0x0633 // Inputs[1] { @2849 stack[-1] } 2846 5B JUMPDEST 2847 60 PUSH1 0x03 2849 81 DUP2 284A 10 LT 284B 61 PUSH2 0x0dc7 284E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dc7, if stack[-1] < 0x03 label_284F: // Incoming jump from 0x284E, if not stack[-1] < 0x03 284F 61 PUSH2 0x0dc7 2852 61 PUSH2 0x2804 2855 56 *JUMP // Stack delta = +1 // Outputs[1] { @284F stack[0] = 0x0dc7 } // Block ends with unconditional jump to 0x2804 label_2856: // Incoming jump from 0x1A70 // Inputs[1] { @285A stack[-1] } 2856 5B JUMPDEST 2857 61 PUSH2 0x285f 285A 81 DUP2 285B 61 PUSH2 0x26f1 285E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2857 stack[0] = 0x285f // @285A stack[1] = stack[-1] // } // Block ends with call to 0x26f1, returns to 0x285F label_285F: // Incoming return from call to 0x26F1 at 0x285E // Incoming jump from 0x2881 // Incoming jump from 0x2894 // Inputs[2] // { // @2860 stack[-2] // @2861 stack[-1] // } 285F 5B JUMPDEST 2860 81 DUP2 2861 14 EQ 2862 61 PUSH2 0x0dc7 2865 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0dc7, if stack[-2] == stack[-1] label_2866: // Incoming jump from 0x2865, if not stack[-2] == stack[-1] // Inputs[1] { @2869 memory[0x00:0x00] } 2866 60 PUSH1 0x00 2868 80 DUP1 2869 FD *REVERT // Stack delta = +0 // Outputs[1] { @2869 revert(memory[0x00:0x00]); } // Block terminates 286A 5B JUMPDEST 286B 80 DUP1 286C 15 ISZERO 286D 15 ISZERO 286E 61 PUSH2 0x285f 2871 56 *JUMP label_2872: // Incoming call from 0x1AA7, returns to 0x0875 // Inputs[1] { @287C stack[-1] } 2872 5B JUMPDEST 2873 60 PUSH1 0x01 2875 60 PUSH1 0x01 2877 60 PUSH1 0xe0 2879 1B SHL 287A 03 SUB 287B 19 NOT 287C 81 DUP2 287D 16 AND 287E 61 PUSH2 0x285f 2881 56 *JUMP // Stack delta = +1 // Outputs[1] { @287D stack[0] = stack[-1] & ~((0x01 << 0xe0) - 0x01) } // Block ends with unconditional jump to 0x285f label_2882: // Incoming call from 0x1ADE, returns to 0x0875 // Inputs[1] { @2885 stack[-1] } 2882 5B JUMPDEST 2883 60 PUSH1 0x03 2885 81 DUP2 2886 10 LT 2887 61 PUSH2 0x0dc7 288A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dc7, if stack[-1] < 0x03 label_288B: // Incoming jump from 0x288A, if not stack[-1] < 0x03 // Inputs[1] { @288E memory[0x00:0x00] } 288B 60 PUSH1 0x00 288D 80 DUP1 288E FD *REVERT // Stack delta = +0 // Outputs[1] { @288E revert(memory[0x00:0x00]); } // Block terminates label_288F: // Incoming call from 0x1AE9, returns to 0x0875 // Inputs[1] { @2890 stack[-1] } 288F 5B JUMPDEST 2890 80 DUP1 2891 61 PUSH2 0x285f 2894 56 *JUMP // Stack delta = +1 // Outputs[1] { @2890 stack[0] = stack[-1] } // Block ends with unconditional jump to 0x285f 2895 FE *ASSERT 2896 A2 LOG2 2897 64 PUSH5 0x6970667358 289D 22 22 289E 12 SLT 289F 20 SHA3 28A0 04 DIV 28A1 E1 E1 28A2 6F PUSH16 0xf0434b9bb912a65387477f55390bc5af 28B3 1D SAR 28B4 1F 1F 28B5 1A BYTE 28B6 03 SUB 28B7 92 SWAP3 28B8 BA BA 28B9 67 PUSH8 0x1b68100d175e6473 28C2 6F PUSH16 0x6c63430008020033