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 0x01a1 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x01a1, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x70a08231 0019 11 GT 001A 61 PUSH2 0x00e1 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00e1, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xa22cb465 0024 11 GT 0025 61 PUSH2 0x008a 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x008a, if 0xa22cb465 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xa22cb465 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xc3c0f4e8 002F 11 GT 0030 61 PUSH2 0x0064 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0064, if 0xc3c0f4e8 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xc3c0f4e8 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xc3c0f4e8 003A 14 EQ 003B 61 PUSH2 0x0831 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0831, if 0xc3c0f4e8 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xc3c0f4e8 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xc87b56dd 0045 14 EQ 0046 61 PUSH2 0x08ae 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08ae, if 0xc87b56dd == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xc87b56dd == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe8a3d485 0050 14 EQ 0051 61 PUSH2 0x08d8 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08d8, if 0xe8a3d485 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe8a3d485 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xe985e9c5 005B 14 EQ 005C 61 PUSH2 0x08ed 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08ed, if 0xe985e9c5 == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xe985e9c5 == stack[-1] 0060 61 PUSH2 0x01a1 0063 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01a1 label_0064: // Incoming jump from 0x0033, if 0xc3c0f4e8 > stack[-1] // Inputs[1] { @0065 stack[-1] } 0064 5B JUMPDEST 0065 80 DUP1 0066 63 PUSH4 0xa22cb465 006B 14 EQ 006C 61 PUSH2 0x06e6 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06e6, if 0xa22cb465 == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xa6570beb 0076 14 EQ 0077 61 PUSH2 0x0721 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0721, if 0xa6570beb == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xa6570beb == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xb88d4fde 0081 14 EQ 0082 61 PUSH2 0x076b 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x076b, if 0xb88d4fde == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xb88d4fde == stack[-1] 0086 61 PUSH2 0x01a1 0089 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01a1 label_008A: // Incoming jump from 0x0028, if 0xa22cb465 > stack[-1] // Inputs[1] { @008B stack[-1] } 008A 5B JUMPDEST 008B 80 DUP1 008C 63 PUSH4 0x95d89b41 0091 11 GT 0092 61 PUSH2 0x00bb 0095 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00bb, if 0x95d89b41 > stack[-1] label_0096: // Incoming jump from 0x0095, if not 0x95d89b41 > stack[-1] // Inputs[1] { @0096 stack[-1] } 0096 80 DUP1 0097 63 PUSH4 0x95d89b41 009C 14 EQ 009D 61 PUSH2 0x0623 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0623, if 0x95d89b41 == stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0x9c543256 00A7 14 EQ 00A8 61 PUSH2 0x0638 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0638, if 0x9c543256 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x9c543256 == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x9f36caf8 00B2 14 EQ 00B3 61 PUSH2 0x064d 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x064d, if 0x9f36caf8 == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x9f36caf8 == stack[-1] 00B7 61 PUSH2 0x01a1 00BA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01a1 label_00BB: // Incoming jump from 0x0095, if 0x95d89b41 > stack[-1] // Inputs[1] { @00BC stack[-1] } 00BB 5B JUMPDEST 00BC 80 DUP1 00BD 63 PUSH4 0x70a08231 00C2 14 EQ 00C3 61 PUSH2 0x04ad 00C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ad, if 0x70a08231 == stack[-1] label_00C7: // Incoming jump from 0x00C6, if not 0x70a08231 == stack[-1] // Inputs[1] { @00C7 stack[-1] } 00C7 80 DUP1 00C8 63 PUSH4 0x70d5e83a 00CD 14 EQ 00CE 61 PUSH2 0x04e0 00D1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e0, if 0x70d5e83a == stack[-1] label_00D2: // Incoming jump from 0x00D1, if not 0x70d5e83a == stack[-1] // Inputs[1] { @00D2 stack[-1] } 00D2 80 DUP1 00D3 63 PUSH4 0x8ed9dcac 00D8 14 EQ 00D9 61 PUSH2 0x04f5 00DC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f5, if 0x8ed9dcac == stack[-1] label_00DD: // Incoming jump from 0x00DC, if not 0x8ed9dcac == stack[-1] 00DD 61 PUSH2 0x01a1 00E0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01a1 label_00E1: // Incoming jump from 0x001D, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00E2 stack[-1] } 00E1 5B JUMPDEST 00E2 80 DUP1 00E3 63 PUSH4 0x096863c9 00E8 11 GT 00E9 61 PUSH2 0x014e 00EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x014e, if 0x096863c9 > stack[-1] label_00ED: // Incoming jump from 0x00EC, if not 0x096863c9 > stack[-1] // Inputs[1] { @00ED stack[-1] } 00ED 80 DUP1 00EE 63 PUSH4 0x42842e0e 00F3 11 GT 00F4 61 PUSH2 0x0128 00F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0128, if 0x42842e0e > stack[-1] label_00F8: // Incoming jump from 0x00F7, if not 0x42842e0e > stack[-1] // Inputs[1] { @00F8 stack[-1] } 00F8 80 DUP1 00F9 63 PUSH4 0x42842e0e 00FE 14 EQ 00FF 61 PUSH2 0x03f8 0102 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f8, if 0x42842e0e == stack[-1] label_0103: // Incoming jump from 0x0102, if not 0x42842e0e == stack[-1] // Inputs[1] { @0103 stack[-1] } 0103 80 DUP1 0104 63 PUSH4 0x42966c68 0109 14 EQ 010A 61 PUSH2 0x042e 010D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x042e, if 0x42966c68 == stack[-1] label_010E: // Incoming jump from 0x010D, if not 0x42966c68 == stack[-1] // Inputs[1] { @010E stack[-1] } 010E 80 DUP1 010F 63 PUSH4 0x54fd4d50 0114 14 EQ 0115 61 PUSH2 0x0458 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0458, if 0x54fd4d50 == stack[-1] label_0119: // Incoming jump from 0x0118, if not 0x54fd4d50 == stack[-1] // Inputs[1] { @0119 stack[-1] } 0119 80 DUP1 011A 63 PUSH4 0x6352211e 011F 14 EQ 0120 61 PUSH2 0x0483 0123 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0483, if 0x6352211e == stack[-1] label_0124: // Incoming jump from 0x0123, if not 0x6352211e == stack[-1] 0124 61 PUSH2 0x01a1 0127 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01a1 label_0128: // Incoming jump from 0x00F7, if 0x42842e0e > stack[-1] // Inputs[1] { @0129 stack[-1] } 0128 5B JUMPDEST 0129 80 DUP1 012A 63 PUSH4 0x096863c9 012F 14 EQ 0130 61 PUSH2 0x0360 0133 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0360, if 0x096863c9 == stack[-1] label_0134: // Incoming jump from 0x0133, if not 0x096863c9 == stack[-1] // Inputs[1] { @0134 stack[-1] } 0134 80 DUP1 0135 63 PUSH4 0x18160ddd 013A 14 EQ 013B 61 PUSH2 0x039b 013E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039b, if 0x18160ddd == stack[-1] label_013F: // Incoming jump from 0x013E, if not 0x18160ddd == stack[-1] // Inputs[1] { @013F stack[-1] } 013F 80 DUP1 0140 63 PUSH4 0x23b872dd 0145 14 EQ 0146 61 PUSH2 0x03c2 0149 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c2, if 0x23b872dd == stack[-1] label_014A: // Incoming jump from 0x0149, if not 0x23b872dd == stack[-1] 014A 61 PUSH2 0x01a1 014D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01a1 label_014E: // Incoming jump from 0x00EC, if 0x096863c9 > stack[-1] // Inputs[1] { @014F stack[-1] } 014E 5B JUMPDEST 014F 80 DUP1 0150 63 PUSH4 0x06fdde03 0155 11 GT 0156 61 PUSH2 0x017f 0159 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x017f, if 0x06fdde03 > stack[-1] label_015A: // Incoming jump from 0x0159, if not 0x06fdde03 > stack[-1] // Inputs[1] { @015A stack[-1] } 015A 80 DUP1 015B 63 PUSH4 0x06fdde03 0160 14 EQ 0161 61 PUSH2 0x0280 0164 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0280, if 0x06fdde03 == stack[-1] label_0165: // Incoming jump from 0x0164, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0165 stack[-1] } 0165 80 DUP1 0166 63 PUSH4 0x081812fc 016B 14 EQ 016C 61 PUSH2 0x030a 016F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x030a, if 0x081812fc == stack[-1] label_0170: // Incoming jump from 0x016F, if not 0x081812fc == stack[-1] // Inputs[1] { @0170 stack[-1] } 0170 80 DUP1 0171 63 PUSH4 0x095ea7b3 0176 14 EQ 0177 61 PUSH2 0x0334 017A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0334, if 0x095ea7b3 == stack[-1] label_017B: // Incoming jump from 0x017A, if not 0x095ea7b3 == stack[-1] 017B 61 PUSH2 0x01a1 017E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01a1 label_017F: // Incoming jump from 0x0159, if 0x06fdde03 > stack[-1] // Inputs[1] { @0180 stack[-1] } 017F 5B JUMPDEST 0180 80 DUP1 0181 63 PUSH4 0x015b9bb3 0186 14 EQ 0187 61 PUSH2 0x01a6 018A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a6, if 0x015b9bb3 == stack[-1] label_018B: // Incoming jump from 0x018A, if not 0x015b9bb3 == stack[-1] // Inputs[1] { @018B stack[-1] } 018B 80 DUP1 018C 63 PUSH4 0x01ffc9a7 0191 14 EQ 0192 61 PUSH2 0x01ef 0195 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ef, if 0x01ffc9a7 == stack[-1] label_0196: // Incoming jump from 0x0195, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0196 stack[-1] } 0196 80 DUP1 0197 63 PUSH4 0x02d05d3f 019C 14 EQ 019D 61 PUSH2 0x024f 01A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024f, if 0x02d05d3f == stack[-1] label_01A1: // Incoming jump from 0x0089 // Incoming jump from 0x01A0, if not 0x02d05d3f == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x0127 // Incoming jump from 0x014D // Incoming jump from 0x0063 // Incoming jump from 0x00E0 // Incoming jump from 0x00BA // Incoming jump from 0x017E // Inputs[1] { @01A5 memory[0x00:0x00] } 01A1 5B JUMPDEST 01A2 60 PUSH1 0x00 01A4 80 DUP1 01A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @01A5 revert(memory[0x00:0x00]); } // Block terminates label_01A6: // Incoming jump from 0x018A, if 0x015b9bb3 == stack[-1] // Inputs[1] { @01A7 msg.value } 01A6 5B JUMPDEST 01A7 34 CALLVALUE 01A8 80 DUP1 01A9 15 ISZERO 01AA 61 PUSH2 0x01b2 01AD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01A7 stack[0] = msg.value } // Block ends with conditional jump to 0x01b2, if !msg.value label_01AE: // Incoming jump from 0x01AD, if not !msg.value // Inputs[1] { @01B1 memory[0x00:0x00] } 01AE 60 PUSH1 0x00 01B0 80 DUP1 01B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @01B1 revert(memory[0x00:0x00]); } // Block terminates label_01B2: // Incoming jump from 0x01AD, if !msg.value // Inputs[1] { @01BA msg.data.length } 01B2 5B JUMPDEST 01B3 50 POP 01B4 61 PUSH2 0x01ed 01B7 60 PUSH1 0x04 01B9 80 DUP1 01BA 36 CALLDATASIZE 01BB 03 SUB 01BC 60 PUSH1 0x80 01BE 81 DUP2 01BF 10 LT 01C0 15 ISZERO 01C1 61 PUSH2 0x01c9 01C4 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @01B4 stack[-1] = 0x01ed // @01B7 stack[0] = 0x04 // @01BB stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x01c9, if !(msg.data.length - 0x04 < 0x80) label_01C5: // Incoming jump from 0x01C4, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @01C8 memory[0x00:0x00] } 01C5 60 PUSH1 0x00 01C7 80 DUP1 01C8 FD *REVERT // Stack delta = +0 // Outputs[1] { @01C8 revert(memory[0x00:0x00]); } // Block terminates label_01C9: // Incoming jump from 0x01C4, if !(msg.data.length - 0x04 < 0x80) // Inputs[5] // { // @01CB stack[-2] // @01CC msg.data[stack[-2]:stack[-2] + 0x20] // @01D2 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @01E0 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @01E7 msg.data[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] // } 01C9 5B JUMPDEST 01CA 50 POP 01CB 80 DUP1 01CC 35 CALLDATALOAD 01CD 90 SWAP1 01CE 60 PUSH1 0x20 01D0 81 DUP2 01D1 01 ADD 01D2 35 CALLDATALOAD 01D3 90 SWAP1 01D4 60 PUSH1 0x01 01D6 60 PUSH1 0x01 01D8 60 PUSH1 0xa0 01DA 1B SHL 01DB 03 SUB 01DC 60 PUSH1 0x40 01DE 82 DUP3 01DF 01 ADD 01E0 35 CALLDATALOAD 01E1 81 DUP2 01E2 16 AND 01E3 91 SWAP2 01E4 60 PUSH1 0x60 01E6 01 ADD 01E7 35 CALLDATALOAD 01E8 16 AND 01E9 61 PUSH2 0x0928 01EC 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @01CD stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @01D3 stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @01E3 stack[0] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @01E8 stack[1] = msg.data[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x0928 label_01ED: // Incoming return from call to 0x0EF0 at 0x04F4 // Incoming return from call to 0x034A at 0x0345 // Incoming return from call to 0x0709 at 0x0704 // Incoming return from call to 0x0670 at 0x066B // Incoming return from call to 0x0383 at 0x037E // Incoming return from call to 0x0518 at 0x0513 01ED 5B JUMPDEST 01EE 00 *STOP // Stack delta = +0 // Outputs[1] { @01EE stop(); } // Block terminates label_01EF: // Incoming jump from 0x0195, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01F0 msg.value } 01EF 5B JUMPDEST 01F0 34 CALLVALUE 01F1 80 DUP1 01F2 15 ISZERO 01F3 61 PUSH2 0x01fb 01F6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01F0 stack[0] = msg.value } // Block ends with conditional jump to 0x01fb, if !msg.value label_01F7: // Incoming jump from 0x01F6, if not !msg.value // Inputs[1] { @01FA memory[0x00:0x00] } 01F7 60 PUSH1 0x00 01F9 80 DUP1 01FA FD *REVERT // Stack delta = +0 // Outputs[1] { @01FA revert(memory[0x00:0x00]); } // Block terminates label_01FB: // Incoming jump from 0x01F6, if !msg.value // Inputs[1] { @0203 msg.data.length } 01FB 5B JUMPDEST 01FC 50 POP 01FD 61 PUSH2 0x023b 0200 60 PUSH1 0x04 0202 80 DUP1 0203 36 CALLDATASIZE 0204 03 SUB 0205 60 PUSH1 0x20 0207 81 DUP2 0208 10 LT 0209 15 ISZERO 020A 61 PUSH2 0x0212 020D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @01FD stack[-1] = 0x023b // @0200 stack[0] = 0x04 // @0204 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0212, returns to 0x023B, if !(msg.data.length - 0x04 < 0x20) label_020E: // Incoming jump from 0x020D, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0211 memory[0x00:0x00] } 020E 60 PUSH1 0x00 0210 80 DUP1 0211 FD *REVERT // Stack delta = +0 // Outputs[1] { @0211 revert(memory[0x00:0x00]); } // Block terminates label_0212: // Incoming call from 0x020D, returns to 0x023B, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0214 msg.data[stack[-2]:stack[-2] + 0x20] // @0214 stack[-2] // } 0212 5B JUMPDEST 0213 50 POP 0214 35 CALLDATALOAD 0215 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 0236 16 AND 0237 61 PUSH2 0x093a 023A 56 *JUMP // Stack delta = -1 // Outputs[1] { @0236 stack[-2] = 0xffffffff00000000000000000000000000000000000000000000000000000000 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x093a label_023B: // Incoming return from call to 0x0910 at 0x090B // Incoming return from call to 0x0212 at 0x020D // Inputs[4] // { // @023F memory[0x40:0x60] // @0240 stack[-1] // @0245 memory[0x40:0x60] // @024E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 023B 5B JUMPDEST 023C 60 PUSH1 0x40 023E 80 DUP1 023F 51 MLOAD 0240 91 SWAP2 0241 15 ISZERO 0242 15 ISZERO 0243 82 DUP3 0244 52 MSTORE 0245 51 MLOAD 0246 90 SWAP1 0247 81 DUP2 0248 90 SWAP1 0249 03 SUB 024A 60 PUSH1 0x20 024C 01 ADD 024D 90 SWAP1 024E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0244 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @024E return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_024F: // Incoming jump from 0x01A0, if 0x02d05d3f == stack[-1] // Inputs[1] { @0250 msg.value } 024F 5B JUMPDEST 0250 34 CALLVALUE 0251 80 DUP1 0252 15 ISZERO 0253 61 PUSH2 0x025b 0256 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0250 stack[0] = msg.value } // Block ends with conditional jump to 0x025b, if !msg.value label_0257: // Incoming jump from 0x0256, if not !msg.value // Inputs[1] { @025A memory[0x00:0x00] } 0257 60 PUSH1 0x00 0259 80 DUP1 025A FD *REVERT // Stack delta = +0 // Outputs[1] { @025A revert(memory[0x00:0x00]); } // Block terminates label_025B: // Incoming jump from 0x0256, if !msg.value 025B 5B JUMPDEST 025C 50 POP 025D 61 PUSH2 0x0264 0260 61 PUSH2 0x0975 0263 56 *JUMP // Stack delta = +0 // Outputs[1] { @025D stack[-1] = 0x0264 } // Block ends with call to 0x0975, returns to 0x0264 label_0264: // Incoming return from call to 0x107D at 0x064C // Incoming return from call to 0x0975 at 0x0263 // Incoming return from call to 0x04A6 at 0x04A1 // Incoming return from call to 0x04A6 at 0x04A1 // Incoming return from call to 0x032D at 0x0328 // Inputs[4] // { // @0268 memory[0x40:0x60] // @0272 stack[-1] // @0276 memory[0x40:0x60] // @027F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0264 5B JUMPDEST 0265 60 PUSH1 0x40 0267 80 DUP1 0268 51 MLOAD 0269 60 PUSH1 0x01 026B 60 PUSH1 0x01 026D 60 PUSH1 0xa0 026F 1B SHL 0270 03 SUB 0271 90 SWAP1 0272 92 SWAP3 0273 16 AND 0274 82 DUP3 0275 52 MSTORE 0276 51 MLOAD 0277 90 SWAP1 0278 81 DUP2 0279 90 SWAP1 027A 03 SUB 027B 60 PUSH1 0x20 027D 01 ADD 027E 90 SWAP1 027F F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0275 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @027F return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0280: // Incoming jump from 0x0164, if 0x06fdde03 == stack[-1] // Inputs[1] { @0281 msg.value } 0280 5B JUMPDEST 0281 34 CALLVALUE 0282 80 DUP1 0283 15 ISZERO 0284 61 PUSH2 0x028c 0287 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0281 stack[0] = msg.value } // Block ends with conditional jump to 0x028c, if !msg.value label_0288: // Incoming jump from 0x0287, if not !msg.value // Inputs[1] { @028B memory[0x00:0x00] } 0288 60 PUSH1 0x00 028A 80 DUP1 028B FD *REVERT // Stack delta = +0 // Outputs[1] { @028B revert(memory[0x00:0x00]); } // Block terminates label_028C: // Incoming jump from 0x0287, if !msg.value 028C 5B JUMPDEST 028D 50 POP 028E 61 PUSH2 0x0295 0291 61 PUSH2 0x0984 0294 56 *JUMP // Stack delta = +0 // Outputs[1] { @028E stack[-1] = 0x0295 } // Block ends with call to 0x0984, returns to 0x0295 label_0295: // Incoming return from call to 0x08D1 at 0x08CC // Incoming return from call to 0x1022 at 0x0637 // Incoming return from call to 0x0984 at 0x0294 // Inputs[4] // { // @0299 memory[0x40:0x60] // @029F stack[-1] // @02A0 memory[stack[-1]:stack[-1] + 0x20] // @02A6 memory[stack[-1]:stack[-1] + 0x20] // } 0295 5B JUMPDEST 0296 60 PUSH1 0x40 0298 80 DUP1 0299 51 MLOAD 029A 60 PUSH1 0x20 029C 80 DUP1 029D 82 DUP3 029E 52 MSTORE 029F 83 DUP4 02A0 51 MLOAD 02A1 81 DUP2 02A2 83 DUP4 02A3 01 ADD 02A4 52 MSTORE 02A5 83 DUP4 02A6 51 MLOAD 02A7 91 SWAP2 02A8 92 SWAP3 02A9 83 DUP4 02AA 92 SWAP3 02AB 90 SWAP1 02AC 83 DUP4 02AD 01 ADD 02AE 91 SWAP2 02AF 85 DUP6 02B0 01 ADD 02B1 90 SWAP1 02B2 80 DUP1 02B3 83 DUP4 02B4 83 DUP4 02B5 60 PUSH1 0x00 02B7 5B JUMPDEST 02B8 83 DUP4 02B9 81 DUP2 02BA 10 LT 02BB 15 ISZERO 02BC 61 PUSH2 0x02cf 02BF 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @029E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @02A4 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @02A8 stack[0] = memory[0x40:0x60] // @02AA stack[1] = memory[0x40:0x60] // @02AE stack[2] = memory[0x40:0x60] + 0x40 // @02B1 stack[3] = stack[-1] + 0x20 // @02B1 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @02B2 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @02B3 stack[6] = memory[0x40:0x60] + 0x40 // @02B4 stack[7] = stack[-1] + 0x20 // @02B5 stack[8] = 0x00 // } // Block ends with conditional jump to 0x02cf, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_02C0: // Incoming jump from 0x02BF, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x02BF, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @02C0 stack[-2] // @02C1 stack[-1] // @02C3 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @02C4 stack[-3] // } 02C0 81 DUP2 02C1 81 DUP2 02C2 01 ADD 02C3 51 MLOAD 02C4 83 DUP4 02C5 82 DUP3 02C6 01 ADD 02C7 52 MSTORE 02C8 60 PUSH1 0x20 02CA 01 ADD 02CB 61 PUSH2 0x02b7 02CE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02C7 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @02CA stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x02b7 label_02CF: // Incoming jump from 0x02BF, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x02BF, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @02D4 stack[-5] // @02D4 stack[-6] // @02D6 stack[-7] // } 02CF 5B JUMPDEST 02D0 50 POP 02D1 50 POP 02D2 50 POP 02D3 50 POP 02D4 90 SWAP1 02D5 50 POP 02D6 90 SWAP1 02D7 81 DUP2 02D8 01 ADD 02D9 90 SWAP1 02DA 60 PUSH1 0x1f 02DC 16 AND 02DD 80 DUP1 02DE 15 ISZERO 02DF 61 PUSH2 0x02fc 02E2 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @02D9 stack[-7] = stack[-5] + stack[-7] // @02DC stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x02fc, if !(0x1f & stack[-5]) label_02E3: // Incoming jump from 0x02E2, if not !(0x1f & stack[-5]) // Inputs[6] // { // @02E3 stack[-1] // @02E4 stack[-2] // @02E7 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @02FE stack[-5] // @0304 memory[0x40:0x60] // @0309 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 02E3 80 DUP1 02E4 82 DUP3 02E5 03 SUB 02E6 80 DUP1 02E7 51 MLOAD 02E8 60 PUSH1 0x01 02EA 83 DUP4 02EB 60 PUSH1 0x20 02ED 03 SUB 02EE 61 PUSH2 0x0100 02F1 0A EXP 02F2 03 SUB 02F3 19 NOT 02F4 16 AND 02F5 81 DUP2 02F6 52 MSTORE 02F7 60 PUSH1 0x20 02F9 01 ADD 02FA 91 SWAP2 02FB 50 POP 02FC 5B JUMPDEST 02FD 50 POP 02FE 92 SWAP3 02FF 50 POP 0300 50 POP 0301 50 POP 0302 60 PUSH1 0x40 0304 51 MLOAD 0305 80 DUP1 0306 91 SWAP2 0307 03 SUB 0308 90 SWAP1 0309 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @02F6 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0309 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_030A: // Incoming jump from 0x016F, if 0x081812fc == stack[-1] // Inputs[1] { @030B msg.value } 030A 5B JUMPDEST 030B 34 CALLVALUE 030C 80 DUP1 030D 15 ISZERO 030E 61 PUSH2 0x0316 0311 57 *JUMPI // Stack delta = +1 // Outputs[1] { @030B stack[0] = msg.value } // Block ends with conditional jump to 0x0316, if !msg.value label_0312: // Incoming jump from 0x0311, if not !msg.value // Inputs[1] { @0315 memory[0x00:0x00] } 0312 60 PUSH1 0x00 0314 80 DUP1 0315 FD *REVERT // Stack delta = +0 // Outputs[1] { @0315 revert(memory[0x00:0x00]); } // Block terminates label_0316: // Incoming jump from 0x0311, if !msg.value // Inputs[1] { @031E msg.data.length } 0316 5B JUMPDEST 0317 50 POP 0318 61 PUSH2 0x0264 031B 60 PUSH1 0x04 031D 80 DUP1 031E 36 CALLDATASIZE 031F 03 SUB 0320 60 PUSH1 0x20 0322 81 DUP2 0323 10 LT 0324 15 ISZERO 0325 61 PUSH2 0x032d 0328 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0318 stack[-1] = 0x0264 // @031B stack[0] = 0x04 // @031F stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x032d, returns to 0x0264, if !(msg.data.length - 0x04 < 0x20) label_0329: // Incoming jump from 0x0328, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @032C memory[0x00:0x00] } 0329 60 PUSH1 0x00 032B 80 DUP1 032C FD *REVERT // Stack delta = +0 // Outputs[1] { @032C revert(memory[0x00:0x00]); } // Block terminates label_032D: // Incoming call from 0x0328, returns to 0x0264, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @032F msg.data[stack[-2]:stack[-2] + 0x20] // @032F stack[-2] // } 032D 5B JUMPDEST 032E 50 POP 032F 35 CALLDATALOAD 0330 61 PUSH2 0x0a12 0333 56 *JUMP // Stack delta = -1 // Outputs[1] { @032F stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0a12 label_0334: // Incoming jump from 0x017A, if 0x095ea7b3 == stack[-1] // Inputs[1] { @033B msg.data.length } 0334 5B JUMPDEST 0335 61 PUSH2 0x01ed 0338 60 PUSH1 0x04 033A 80 DUP1 033B 36 CALLDATASIZE 033C 03 SUB 033D 60 PUSH1 0x40 033F 81 DUP2 0340 10 LT 0341 15 ISZERO 0342 61 PUSH2 0x034a 0345 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0335 stack[0] = 0x01ed // @0338 stack[1] = 0x04 // @033C stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x034a, returns to 0x01ED, if !(msg.data.length - 0x04 < 0x40) label_0346: // Incoming jump from 0x0345, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0349 memory[0x00:0x00] } 0346 60 PUSH1 0x00 0348 80 DUP1 0349 FD *REVERT // Stack delta = +0 // Outputs[1] { @0349 revert(memory[0x00:0x00]); } // Block terminates label_034A: // Incoming call from 0x0345, returns to 0x01ED, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0354 stack[-2] // @0355 msg.data[stack[-2]:stack[-2] + 0x20] // @035B msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 034A 5B JUMPDEST 034B 50 POP 034C 60 PUSH1 0x01 034E 60 PUSH1 0x01 0350 60 PUSH1 0xa0 0352 1B SHL 0353 03 SUB 0354 81 DUP2 0355 35 CALLDATALOAD 0356 16 AND 0357 90 SWAP1 0358 60 PUSH1 0x20 035A 01 ADD 035B 35 CALLDATALOAD 035C 61 PUSH2 0x0ad0 035F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0357 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @035B stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0ad0 label_0360: // Incoming jump from 0x0133, if 0x096863c9 == stack[-1] // Inputs[1] { @0361 msg.value } 0360 5B JUMPDEST 0361 34 CALLVALUE 0362 80 DUP1 0363 15 ISZERO 0364 61 PUSH2 0x036c 0367 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0361 stack[0] = msg.value } // Block ends with conditional jump to 0x036c, if !msg.value label_0368: // Incoming jump from 0x0367, if not !msg.value // Inputs[1] { @036B memory[0x00:0x00] } 0368 60 PUSH1 0x00 036A 80 DUP1 036B FD *REVERT // Stack delta = +0 // Outputs[1] { @036B revert(memory[0x00:0x00]); } // Block terminates label_036C: // Incoming jump from 0x0367, if !msg.value // Inputs[1] { @0374 msg.data.length } 036C 5B JUMPDEST 036D 50 POP 036E 61 PUSH2 0x01ed 0371 60 PUSH1 0x04 0373 80 DUP1 0374 36 CALLDATASIZE 0375 03 SUB 0376 60 PUSH1 0x40 0378 81 DUP2 0379 10 LT 037A 15 ISZERO 037B 61 PUSH2 0x0383 037E 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @036E stack[-1] = 0x01ed // @0371 stack[0] = 0x04 // @0375 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0383, returns to 0x01ED, if !(msg.data.length - 0x04 < 0x40) label_037F: // Incoming jump from 0x037E, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0382 memory[0x00:0x00] } 037F 60 PUSH1 0x00 0381 80 DUP1 0382 FD *REVERT // Stack delta = +0 // Outputs[1] { @0382 revert(memory[0x00:0x00]); } // Block terminates label_0383: // Incoming call from 0x037E, returns to 0x01ED, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0385 stack[-2] // @0386 msg.data[stack[-2]:stack[-2] + 0x20] // @038D msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0383 5B JUMPDEST 0384 50 POP 0385 80 DUP1 0386 35 CALLDATALOAD 0387 15 ISZERO 0388 15 ISZERO 0389 90 SWAP1 038A 60 PUSH1 0x20 038C 01 ADD 038D 35 CALLDATALOAD 038E 60 PUSH1 0x01 0390 60 PUSH1 0x01 0392 60 PUSH1 0xa0 0394 1B SHL 0395 03 SUB 0396 16 AND 0397 61 PUSH2 0x0c49 039A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0389 stack[-2] = !!msg.data[stack[-2]:stack[-2] + 0x20] // @0396 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0c49 label_039B: // Incoming jump from 0x013E, if 0x18160ddd == stack[-1] // Inputs[1] { @039C msg.value } 039B 5B JUMPDEST 039C 34 CALLVALUE 039D 80 DUP1 039E 15 ISZERO 039F 61 PUSH2 0x03a7 03A2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @039C stack[0] = msg.value } // Block ends with conditional jump to 0x03a7, if !msg.value label_03A3: // Incoming jump from 0x03A2, if not !msg.value // Inputs[1] { @03A6 memory[0x00:0x00] } 03A3 60 PUSH1 0x00 03A5 80 DUP1 03A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A6 revert(memory[0x00:0x00]); } // Block terminates label_03A7: // Incoming jump from 0x03A2, if !msg.value 03A7 5B JUMPDEST 03A8 50 POP 03A9 61 PUSH2 0x03b0 03AC 61 PUSH2 0x0d53 03AF 56 *JUMP // Stack delta = +0 // Outputs[1] { @03A9 stack[-1] = 0x03b0 } // Block ends with call to 0x0d53, returns to 0x03B0 label_03B0: // Incoming return from call to 0x04D0 at 0x04CB // Incoming return from call to 0x0D53 at 0x03AF // Inputs[4] // { // @03B4 memory[0x40:0x60] // @03B5 stack[-1] // @03B8 memory[0x40:0x60] // @03C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 03B0 5B JUMPDEST 03B1 60 PUSH1 0x40 03B3 80 DUP1 03B4 51 MLOAD 03B5 91 SWAP2 03B6 82 DUP3 03B7 52 MSTORE 03B8 51 MLOAD 03B9 90 SWAP1 03BA 81 DUP2 03BB 90 SWAP1 03BC 03 SUB 03BD 60 PUSH1 0x20 03BF 01 ADD 03C0 90 SWAP1 03C1 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @03B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @03C1 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_03C2: // Incoming jump from 0x0149, if 0x23b872dd == stack[-1] // Inputs[1] { @03C9 msg.data.length } 03C2 5B JUMPDEST 03C3 61 PUSH2 0x01ed 03C6 60 PUSH1 0x04 03C8 80 DUP1 03C9 36 CALLDATASIZE 03CA 03 SUB 03CB 60 PUSH1 0x60 03CD 81 DUP2 03CE 10 LT 03CF 15 ISZERO 03D0 61 PUSH2 0x03d8 03D3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @03C3 stack[0] = 0x01ed // @03C6 stack[1] = 0x04 // @03CA stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x03d8, if !(msg.data.length - 0x04 < 0x60) label_03D4: // Incoming jump from 0x03D3, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @03D7 memory[0x00:0x00] } 03D4 60 PUSH1 0x00 03D6 80 DUP1 03D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D7 revert(memory[0x00:0x00]); } // Block terminates label_03D8: // Incoming jump from 0x03D3, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @03E2 stack[-2] // @03E3 msg.data[stack[-2]:stack[-2] + 0x20] // @03EB msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @03F3 msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 03D8 5B JUMPDEST 03D9 50 POP 03DA 60 PUSH1 0x01 03DC 60 PUSH1 0x01 03DE 60 PUSH1 0xa0 03E0 1B SHL 03E1 03 SUB 03E2 81 DUP2 03E3 35 CALLDATALOAD 03E4 81 DUP2 03E5 16 AND 03E6 91 SWAP2 03E7 60 PUSH1 0x20 03E9 81 DUP2 03EA 01 ADD 03EB 35 CALLDATALOAD 03EC 90 SWAP1 03ED 91 SWAP2 03EE 16 AND 03EF 90 SWAP1 03F0 60 PUSH1 0x40 03F2 01 ADD 03F3 35 CALLDATALOAD 03F4 61 PUSH2 0x0d59 03F7 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @03E6 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @03EF stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @03F3 stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0d59 label_03F8: // Incoming jump from 0x0102, if 0x42842e0e == stack[-1] // Inputs[1] { @03FF msg.data.length } 03F8 5B JUMPDEST 03F9 61 PUSH2 0x01ed 03FC 60 PUSH1 0x04 03FE 80 DUP1 03FF 36 CALLDATASIZE 0400 03 SUB 0401 60 PUSH1 0x60 0403 81 DUP2 0404 10 LT 0405 15 ISZERO 0406 61 PUSH2 0x040e 0409 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @03F9 stack[0] = 0x01ed // @03FC stack[1] = 0x04 // @0400 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x040e, if !(msg.data.length - 0x04 < 0x60) label_040A: // Incoming jump from 0x0409, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @040D memory[0x00:0x00] } 040A 60 PUSH1 0x00 040C 80 DUP1 040D FD *REVERT // Stack delta = +0 // Outputs[1] { @040D revert(memory[0x00:0x00]); } // Block terminates label_040E: // Incoming jump from 0x0409, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @0418 stack[-2] // @0419 msg.data[stack[-2]:stack[-2] + 0x20] // @0421 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0429 msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 040E 5B JUMPDEST 040F 50 POP 0410 60 PUSH1 0x01 0412 60 PUSH1 0x01 0414 60 PUSH1 0xa0 0416 1B SHL 0417 03 SUB 0418 81 DUP2 0419 35 CALLDATALOAD 041A 81 DUP2 041B 16 AND 041C 91 SWAP2 041D 60 PUSH1 0x20 041F 81 DUP2 0420 01 ADD 0421 35 CALLDATALOAD 0422 90 SWAP1 0423 91 SWAP2 0424 16 AND 0425 90 SWAP1 0426 60 PUSH1 0x40 0428 01 ADD 0429 35 CALLDATALOAD 042A 61 PUSH2 0x0d6a 042D 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @041C stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0425 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0429 stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0d6a label_042E: // Incoming jump from 0x010D, if 0x42966c68 == stack[-1] // Inputs[1] { @042F msg.value } 042E 5B JUMPDEST 042F 34 CALLVALUE 0430 80 DUP1 0431 15 ISZERO 0432 61 PUSH2 0x043a 0435 57 *JUMPI // Stack delta = +1 // Outputs[1] { @042F stack[0] = msg.value } // Block ends with conditional jump to 0x043a, if !msg.value label_0436: // Incoming jump from 0x0435, if not !msg.value // Inputs[1] { @0439 memory[0x00:0x00] } 0436 60 PUSH1 0x00 0438 80 DUP1 0439 FD *REVERT // Stack delta = +0 // Outputs[1] { @0439 revert(memory[0x00:0x00]); } // Block terminates label_043A: // Incoming jump from 0x0435, if !msg.value // Inputs[1] { @0442 msg.data.length } 043A 5B JUMPDEST 043B 50 POP 043C 61 PUSH2 0x01ed 043F 60 PUSH1 0x04 0441 80 DUP1 0442 36 CALLDATASIZE 0443 03 SUB 0444 60 PUSH1 0x20 0446 81 DUP2 0447 10 LT 0448 15 ISZERO 0449 61 PUSH2 0x0451 044C 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @043C stack[-1] = 0x01ed // @043F stack[0] = 0x04 // @0443 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0451, if !(msg.data.length - 0x04 < 0x20) label_044D: // Incoming jump from 0x044C, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0450 memory[0x00:0x00] } 044D 60 PUSH1 0x00 044F 80 DUP1 0450 FD *REVERT // Stack delta = +0 // Outputs[1] { @0450 revert(memory[0x00:0x00]); } // Block terminates label_0451: // Incoming jump from 0x044C, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0453 stack[-2] // @0453 msg.data[stack[-2]:stack[-2] + 0x20] // } 0451 5B JUMPDEST 0452 50 POP 0453 35 CALLDATALOAD 0454 61 PUSH2 0x0d85 0457 56 *JUMP // Stack delta = -1 // Outputs[1] { @0453 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0d85 label_0458: // Incoming jump from 0x0118, if 0x54fd4d50 == stack[-1] // Inputs[1] { @0459 msg.value } 0458 5B JUMPDEST 0459 34 CALLVALUE 045A 80 DUP1 045B 15 ISZERO 045C 61 PUSH2 0x0464 045F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0459 stack[0] = msg.value } // Block ends with conditional jump to 0x0464, if !msg.value label_0460: // Incoming jump from 0x045F, if not !msg.value // Inputs[1] { @0463 memory[0x00:0x00] } 0460 60 PUSH1 0x00 0462 80 DUP1 0463 FD *REVERT // Stack delta = +0 // Outputs[1] { @0463 revert(memory[0x00:0x00]); } // Block terminates label_0464: // Incoming jump from 0x045F, if !msg.value 0464 5B JUMPDEST 0465 50 POP 0466 61 PUSH2 0x046d 0469 61 PUSH2 0x0dd1 046C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0466 stack[-1] = 0x046d } // Block ends with call to 0x0dd1, returns to 0x046D label_046D: // Incoming return from call to 0x0DD1 at 0x046C // Inputs[4] // { // @0471 memory[0x40:0x60] // @0475 stack[-1] // @0479 memory[0x40:0x60] // @0482 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 046D 5B JUMPDEST 046E 60 PUSH1 0x40 0470 80 DUP1 0471 51 MLOAD 0472 60 PUSH1 0xff 0474 90 SWAP1 0475 92 SWAP3 0476 16 AND 0477 82 DUP3 0478 52 MSTORE 0479 51 MLOAD 047A 90 SWAP1 047B 81 DUP2 047C 90 SWAP1 047D 03 SUB 047E 60 PUSH1 0x20 0480 01 ADD 0481 90 SWAP1 0482 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0478 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xff // @0482 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0483: // Incoming jump from 0x0123, if 0x6352211e == stack[-1] // Inputs[1] { @0484 msg.value } 0483 5B JUMPDEST 0484 34 CALLVALUE 0485 80 DUP1 0486 15 ISZERO 0487 61 PUSH2 0x048f 048A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0484 stack[0] = msg.value } // Block ends with conditional jump to 0x048f, if !msg.value label_048B: // Incoming jump from 0x048A, if not !msg.value // Inputs[1] { @048E memory[0x00:0x00] } 048B 60 PUSH1 0x00 048D 80 DUP1 048E FD *REVERT // Stack delta = +0 // Outputs[1] { @048E revert(memory[0x00:0x00]); } // Block terminates label_048F: // Incoming jump from 0x048A, if !msg.value // Inputs[1] { @0497 msg.data.length } 048F 5B JUMPDEST 0490 50 POP 0491 61 PUSH2 0x0264 0494 60 PUSH1 0x04 0496 80 DUP1 0497 36 CALLDATASIZE 0498 03 SUB 0499 60 PUSH1 0x20 049B 81 DUP2 049C 10 LT 049D 15 ISZERO 049E 61 PUSH2 0x04a6 04A1 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0491 stack[-1] = 0x0264 // @0494 stack[0] = 0x04 // @0498 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04a6, returns to 0x0264, if !(msg.data.length - 0x04 < 0x20) label_04A2: // Incoming jump from 0x04A1, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @04A5 memory[0x00:0x00] } 04A2 60 PUSH1 0x00 04A4 80 DUP1 04A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A5 revert(memory[0x00:0x00]); } // Block terminates label_04A6: // Incoming call from 0x04A1, returns to 0x0264, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @04A8 stack[-2] // @04A8 msg.data[stack[-2]:stack[-2] + 0x20] // } 04A6 5B JUMPDEST 04A7 50 POP 04A8 35 CALLDATALOAD 04A9 61 PUSH2 0x0dda 04AC 56 *JUMP // Stack delta = -1 // Outputs[1] { @04A8 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0dda label_04AD: // Incoming jump from 0x00C6, if 0x70a08231 == stack[-1] // Inputs[1] { @04AE msg.value } 04AD 5B JUMPDEST 04AE 34 CALLVALUE 04AF 80 DUP1 04B0 15 ISZERO 04B1 61 PUSH2 0x04b9 04B4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04AE stack[0] = msg.value } // Block ends with conditional jump to 0x04b9, if !msg.value label_04B5: // Incoming jump from 0x04B4, if not !msg.value // Inputs[1] { @04B8 memory[0x00:0x00] } 04B5 60 PUSH1 0x00 04B7 80 DUP1 04B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B8 revert(memory[0x00:0x00]); } // Block terminates label_04B9: // Incoming jump from 0x04B4, if !msg.value // Inputs[1] { @04C1 msg.data.length } 04B9 5B JUMPDEST 04BA 50 POP 04BB 61 PUSH2 0x03b0 04BE 60 PUSH1 0x04 04C0 80 DUP1 04C1 36 CALLDATASIZE 04C2 03 SUB 04C3 60 PUSH1 0x20 04C5 81 DUP2 04C6 10 LT 04C7 15 ISZERO 04C8 61 PUSH2 0x04d0 04CB 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @04BB stack[-1] = 0x03b0 // @04BE stack[0] = 0x04 // @04C2 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04d0, returns to 0x03B0, if !(msg.data.length - 0x04 < 0x20) label_04CC: // Incoming jump from 0x04CB, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @04CF memory[0x00:0x00] } 04CC 60 PUSH1 0x00 04CE 80 DUP1 04CF FD *REVERT // Stack delta = +0 // Outputs[1] { @04CF revert(memory[0x00:0x00]); } // Block terminates label_04D0: // Incoming call from 0x04CB, returns to 0x03B0, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @04D2 stack[-2] // @04D2 msg.data[stack[-2]:stack[-2] + 0x20] // } 04D0 5B JUMPDEST 04D1 50 POP 04D2 35 CALLDATALOAD 04D3 60 PUSH1 0x01 04D5 60 PUSH1 0x01 04D7 60 PUSH1 0xa0 04D9 1B SHL 04DA 03 SUB 04DB 16 AND 04DC 61 PUSH2 0x0ede 04DF 56 *JUMP // Stack delta = -1 // Outputs[1] { @04DB stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0ede label_04E0: // Incoming jump from 0x00D1, if 0x70d5e83a == stack[-1] // Inputs[1] { @04E1 msg.value } 04E0 5B JUMPDEST 04E1 34 CALLVALUE 04E2 80 DUP1 04E3 15 ISZERO 04E4 61 PUSH2 0x04ec 04E7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04E1 stack[0] = msg.value } // Block ends with conditional jump to 0x04ec, if !msg.value label_04E8: // Incoming jump from 0x04E7, if not !msg.value // Inputs[1] { @04EB memory[0x00:0x00] } 04E8 60 PUSH1 0x00 04EA 80 DUP1 04EB FD *REVERT // Stack delta = +0 // Outputs[1] { @04EB revert(memory[0x00:0x00]); } // Block terminates label_04EC: // Incoming jump from 0x04E7, if !msg.value 04EC 5B JUMPDEST 04ED 50 POP 04EE 61 PUSH2 0x01ed 04F1 61 PUSH2 0x0ef0 04F4 56 *JUMP // Stack delta = +0 // Outputs[1] { @04EE stack[-1] = 0x01ed } // Block ends with call to 0x0ef0, returns to 0x01ED label_04F5: // Incoming jump from 0x00DC, if 0x8ed9dcac == stack[-1] // Inputs[1] { @04F6 msg.value } 04F5 5B JUMPDEST 04F6 34 CALLVALUE 04F7 80 DUP1 04F8 15 ISZERO 04F9 61 PUSH2 0x0501 04FC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04F6 stack[0] = msg.value } // Block ends with conditional jump to 0x0501, if !msg.value label_04FD: // Incoming jump from 0x04FC, if not !msg.value // Inputs[1] { @0500 memory[0x00:0x00] } 04FD 60 PUSH1 0x00 04FF 80 DUP1 0500 FD *REVERT // Stack delta = +0 // Outputs[1] { @0500 revert(memory[0x00:0x00]); } // Block terminates label_0501: // Incoming jump from 0x04FC, if !msg.value // Inputs[1] { @0509 msg.data.length } 0501 5B JUMPDEST 0502 50 POP 0503 61 PUSH2 0x01ed 0506 60 PUSH1 0x04 0508 80 DUP1 0509 36 CALLDATASIZE 050A 03 SUB 050B 60 PUSH1 0x80 050D 81 DUP2 050E 10 LT 050F 15 ISZERO 0510 61 PUSH2 0x0518 0513 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0503 stack[-1] = 0x01ed // @0506 stack[0] = 0x04 // @050A stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0518, returns to 0x01ED, if !(msg.data.length - 0x04 < 0x80) label_0514: // Incoming jump from 0x0513, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @0517 memory[0x00:0x00] } 0514 60 PUSH1 0x00 0516 80 DUP1 0517 FD *REVERT // Stack delta = +0 // Outputs[1] { @0517 revert(memory[0x00:0x00]); } // Block terminates label_0518: // Incoming call from 0x0513, returns to 0x01ED, if !(msg.data.length - 0x04 < 0x80) // Inputs[3] // { // @0519 stack[-2] // @051A stack[-1] // @0521 msg.data[stack[-2]:stack[-2] + 0x20] // } 0518 5B JUMPDEST 0519 81 DUP2 051A 01 ADD 051B 90 SWAP1 051C 60 PUSH1 0x20 051E 81 DUP2 051F 01 ADD 0520 81 DUP2 0521 35 CALLDATALOAD 0522 64 PUSH5 0x0100000000 0528 81 DUP2 0529 11 GT 052A 15 ISZERO 052B 61 PUSH2 0x0533 052E 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @051B stack[-1] = stack[-2] // @051B stack[-2] = stack[-2] + stack[-1] // @051F stack[0] = stack[-2] + 0x20 // @0521 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x0533, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_052F: // Incoming jump from 0x052E, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0532 memory[0x00:0x00] } 052F 60 PUSH1 0x00 0531 80 DUP1 0532 FD *REVERT // Stack delta = +0 // Outputs[1] { @0532 revert(memory[0x00:0x00]); } // Block terminates label_0533: // Incoming jump from 0x052E, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @0534 stack[-3] // @0535 stack[-1] // @0536 stack[-4] // } 0533 5B JUMPDEST 0534 82 DUP3 0535 01 ADD 0536 83 DUP4 0537 60 PUSH1 0x20 0539 82 DUP3 053A 01 ADD 053B 11 GT 053C 15 ISZERO 053D 61 PUSH2 0x0545 0540 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0535 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0545, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0541: // Incoming jump from 0x0540, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0544 memory[0x00:0x00] } 0541 60 PUSH1 0x00 0543 80 DUP1 0544 FD *REVERT // Stack delta = +0 // Outputs[1] { @0544 revert(memory[0x00:0x00]); } // Block terminates label_0545: // Incoming jump from 0x0540, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0546 stack[-1] // @0547 msg.data[stack[-1]:stack[-1] + 0x20] // @054C stack[-2] // @054D stack[-4] // } 0545 5B JUMPDEST 0546 80 DUP1 0547 35 CALLDATALOAD 0548 90 SWAP1 0549 60 PUSH1 0x20 054B 01 ADD 054C 91 SWAP2 054D 84 DUP5 054E 60 PUSH1 0x20 0550 83 DUP4 0551 02 MUL 0552 84 DUP5 0553 01 ADD 0554 11 GT 0555 64 PUSH5 0x0100000000 055B 83 DUP4 055C 11 GT 055D 17 OR 055E 15 ISZERO 055F 61 PUSH2 0x0567 0562 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0548 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @054C stack[0] = stack[-2] // @054C stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0567, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0563: // Incoming jump from 0x0562, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0566 memory[0x00:0x00] } 0563 60 PUSH1 0x00 0565 80 DUP1 0566 FD *REVERT // Stack delta = +0 // Outputs[1] { @0566 revert(memory[0x00:0x00]); } // Block terminates label_0567: // Incoming jump from 0x0562, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[6] // { // @0568 stack[-1] // @0568 stack[-3] // @0569 stack[-5] // @056A stack[-2] // @056B stack[-4] // @0573 msg.data[stack[-1]:stack[-1] + 0x20] // } 0567 5B JUMPDEST 0568 91 SWAP2 0569 93 SWAP4 056A 90 SWAP1 056B 92 SWAP3 056C 90 SWAP1 056D 91 SWAP2 056E 60 PUSH1 0x20 0570 81 DUP2 0571 01 ADD 0572 90 SWAP1 0573 35 CALLDATALOAD 0574 64 PUSH5 0x0100000000 057A 81 DUP2 057B 11 GT 057C 15 ISZERO 057D 61 PUSH2 0x0585 0580 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @0569 stack[-5] = stack[-3] // @056B stack[-4] = stack[-2] // @056C stack[-2] = stack[-4] // @056D stack[-3] = stack[-5] // @0572 stack[-1] = stack[-1] + 0x20 // @0573 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0585, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_0581: // Incoming jump from 0x0580, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @0584 memory[0x00:0x00] } 0581 60 PUSH1 0x00 0583 80 DUP1 0584 FD *REVERT // Stack delta = +0 // Outputs[1] { @0584 revert(memory[0x00:0x00]); } // Block terminates label_0585: // Incoming jump from 0x0580, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @0586 stack[-3] // @0587 stack[-1] // @0588 stack[-4] // } 0585 5B JUMPDEST 0586 82 DUP3 0587 01 ADD 0588 83 DUP4 0589 60 PUSH1 0x20 058B 82 DUP3 058C 01 ADD 058D 11 GT 058E 15 ISZERO 058F 61 PUSH2 0x0597 0592 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0587 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0597, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0593: // Incoming jump from 0x0592, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0596 memory[0x00:0x00] } 0593 60 PUSH1 0x00 0595 80 DUP1 0596 FD *REVERT // Stack delta = +0 // Outputs[1] { @0596 revert(memory[0x00:0x00]); } // Block terminates label_0597: // Incoming jump from 0x0592, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0598 stack[-1] // @0599 msg.data[stack[-1]:stack[-1] + 0x20] // @059E stack[-2] // @059F stack[-4] // } 0597 5B JUMPDEST 0598 80 DUP1 0599 35 CALLDATALOAD 059A 90 SWAP1 059B 60 PUSH1 0x20 059D 01 ADD 059E 91 SWAP2 059F 84 DUP5 05A0 60 PUSH1 0x20 05A2 83 DUP4 05A3 02 MUL 05A4 84 DUP5 05A5 01 ADD 05A6 11 GT 05A7 64 PUSH5 0x0100000000 05AD 83 DUP4 05AE 11 GT 05AF 17 OR 05B0 15 ISZERO 05B1 61 PUSH2 0x05b9 05B4 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @059A stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @059E stack[0] = stack[-2] // @059E stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x05b9, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_05B5: // Incoming jump from 0x05B4, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @05B8 memory[0x00:0x00] } 05B5 60 PUSH1 0x00 05B7 80 DUP1 05B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B8 revert(memory[0x00:0x00]); } // Block terminates label_05B9: // Incoming jump from 0x05B4, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[7] // { // @05BA stack[-1] // @05BA stack[-3] // @05BB stack[-5] // @05BC stack[-2] // @05BD stack[-4] // @05C7 msg.data[stack[-1]:stack[-1] + 0x20] // @05D2 msg.data[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // } 05B9 5B JUMPDEST 05BA 91 SWAP2 05BB 93 SWAP4 05BC 90 SWAP1 05BD 92 SWAP3 05BE 60 PUSH1 0x01 05C0 60 PUSH1 0x01 05C2 60 PUSH1 0xa0 05C4 1B SHL 05C5 03 SUB 05C6 83 DUP4 05C7 35 CALLDATALOAD 05C8 16 AND 05C9 92 SWAP3 05CA 60 PUSH1 0x40 05CC 81 DUP2 05CD 01 ADD 05CE 90 SWAP1 05CF 60 PUSH1 0x20 05D1 01 ADD 05D2 35 CALLDATALOAD 05D3 64 PUSH5 0x0100000000 05D9 81 DUP2 05DA 11 GT 05DB 15 ISZERO 05DC 61 PUSH2 0x05e4 05DF 57 *JUMPI // Stack delta = +2 // Outputs[7] // { // @05BB stack[-5] = stack[-3] // @05BC stack[-2] = stack[-5] // @05BD stack[-1] = stack[-4] // @05BD stack[-4] = stack[-2] // @05C9 stack[-3] = msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // @05CE stack[0] = stack[-1] + 0x40 // @05D2 stack[1] = msg.data[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // } // Block ends with conditional jump to 0x05e4, if !(msg.data[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] > 0x0100000000) label_05E0: // Incoming jump from 0x05DF, if not !(msg.data[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @05E3 memory[0x00:0x00] } 05E0 60 PUSH1 0x00 05E2 80 DUP1 05E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @05E3 revert(memory[0x00:0x00]); } // Block terminates label_05E4: // Incoming jump from 0x05DF, if !(msg.data[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @05E5 stack[-3] // @05E6 stack[-1] // @05E7 stack[-4] // } 05E4 5B JUMPDEST 05E5 82 DUP3 05E6 01 ADD 05E7 83 DUP4 05E8 60 PUSH1 0x20 05EA 82 DUP3 05EB 01 ADD 05EC 11 GT 05ED 15 ISZERO 05EE 61 PUSH2 0x05f6 05F1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @05E6 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x05f6, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_05F2: // Incoming jump from 0x05F1, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @05F5 memory[0x00:0x00] } 05F2 60 PUSH1 0x00 05F4 80 DUP1 05F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @05F5 revert(memory[0x00:0x00]); } // Block terminates label_05F6: // Incoming jump from 0x05F1, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @05F7 stack[-1] // @05F8 msg.data[stack[-1]:stack[-1] + 0x20] // @05FD stack[-2] // @05FE stack[-4] // } 05F6 5B JUMPDEST 05F7 80 DUP1 05F8 35 CALLDATALOAD 05F9 90 SWAP1 05FA 60 PUSH1 0x20 05FC 01 ADD 05FD 91 SWAP2 05FE 84 DUP5 05FF 60 PUSH1 0x20 0601 83 DUP4 0602 02 MUL 0603 84 DUP5 0604 01 ADD 0605 11 GT 0606 64 PUSH5 0x0100000000 060C 83 DUP4 060D 11 GT 060E 17 OR 060F 15 ISZERO 0610 61 PUSH2 0x0618 0613 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @05F9 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @05FD stack[0] = stack[-2] // @05FD stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0618, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0614: // Incoming jump from 0x0613, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0617 memory[0x00:0x00] } 0614 60 PUSH1 0x00 0616 80 DUP1 0617 FD *REVERT // Stack delta = +0 // Outputs[1] { @0617 revert(memory[0x00:0x00]); } // Block terminates label_0618: // Incoming jump from 0x0613, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[4] // { // @061A stack[-2] // @061A stack[-3] // @061B stack[-5] // @061D stack[-4] // } 0618 5B JUMPDEST 0619 50 POP 061A 90 SWAP1 061B 92 SWAP3 061C 50 POP 061D 90 SWAP1 061E 50 POP 061F 61 PUSH2 0x0f5b 0622 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @061B stack[-5] = stack[-3] // @061D stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x0f5b label_0623: // Incoming jump from 0x00A0, if 0x95d89b41 == stack[-1] // Inputs[1] { @0624 msg.value } 0623 5B JUMPDEST 0624 34 CALLVALUE 0625 80 DUP1 0626 15 ISZERO 0627 61 PUSH2 0x062f 062A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0624 stack[0] = msg.value } // Block ends with conditional jump to 0x062f, if !msg.value label_062B: // Incoming jump from 0x062A, if not !msg.value // Inputs[1] { @062E memory[0x00:0x00] } 062B 60 PUSH1 0x00 062D 80 DUP1 062E FD *REVERT // Stack delta = +0 // Outputs[1] { @062E revert(memory[0x00:0x00]); } // Block terminates label_062F: // Incoming jump from 0x062A, if !msg.value 062F 5B JUMPDEST 0630 50 POP 0631 61 PUSH2 0x0295 0634 61 PUSH2 0x1022 0637 56 *JUMP // Stack delta = +0 // Outputs[1] { @0631 stack[-1] = 0x0295 } // Block ends with call to 0x1022, returns to 0x0295 label_0638: // Incoming jump from 0x00AB, if 0x9c543256 == stack[-1] // Inputs[1] { @0639 msg.value } 0638 5B JUMPDEST 0639 34 CALLVALUE 063A 80 DUP1 063B 15 ISZERO 063C 61 PUSH2 0x0644 063F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0639 stack[0] = msg.value } // Block ends with conditional jump to 0x0644, if !msg.value label_0640: // Incoming jump from 0x063F, if not !msg.value // Inputs[1] { @0643 memory[0x00:0x00] } 0640 60 PUSH1 0x00 0642 80 DUP1 0643 FD *REVERT // Stack delta = +0 // Outputs[1] { @0643 revert(memory[0x00:0x00]); } // Block terminates label_0644: // Incoming jump from 0x063F, if !msg.value 0644 5B JUMPDEST 0645 50 POP 0646 61 PUSH2 0x0264 0649 61 PUSH2 0x107d 064C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0646 stack[-1] = 0x0264 } // Block ends with call to 0x107d, returns to 0x0264 label_064D: // Incoming jump from 0x00B6, if 0x9f36caf8 == stack[-1] // Inputs[1] { @064E msg.value } 064D 5B JUMPDEST 064E 34 CALLVALUE 064F 80 DUP1 0650 15 ISZERO 0651 61 PUSH2 0x0659 0654 57 *JUMPI // Stack delta = +1 // Outputs[1] { @064E stack[0] = msg.value } // Block ends with conditional jump to 0x0659, if !msg.value label_0655: // Incoming jump from 0x0654, if not !msg.value // Inputs[1] { @0658 memory[0x00:0x00] } 0655 60 PUSH1 0x00 0657 80 DUP1 0658 FD *REVERT // Stack delta = +0 // Outputs[1] { @0658 revert(memory[0x00:0x00]); } // Block terminates label_0659: // Incoming jump from 0x0654, if !msg.value // Inputs[1] { @0661 msg.data.length } 0659 5B JUMPDEST 065A 50 POP 065B 61 PUSH2 0x01ed 065E 60 PUSH1 0x04 0660 80 DUP1 0661 36 CALLDATASIZE 0662 03 SUB 0663 60 PUSH1 0x80 0665 81 DUP2 0666 10 LT 0667 15 ISZERO 0668 61 PUSH2 0x0670 066B 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @065B stack[-1] = 0x01ed // @065E stack[0] = 0x04 // @0662 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0670, returns to 0x01ED, if !(msg.data.length - 0x04 < 0x80) label_066C: // Incoming jump from 0x066B, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @066F memory[0x00:0x00] } 066C 60 PUSH1 0x00 066E 80 DUP1 066F FD *REVERT // Stack delta = +0 // Outputs[1] { @066F revert(memory[0x00:0x00]); } // Block terminates label_0670: // Incoming call from 0x066B, returns to 0x01ED, if !(msg.data.length - 0x04 < 0x80) // Inputs[6] // { // @0671 stack[-2] // @0672 msg.data[stack[-2]:stack[-2] + 0x20] // @0680 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0682 stack[-1] // @0687 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0695 msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } 0670 5B JUMPDEST 0671 81 DUP2 0672 35 CALLDATALOAD 0673 91 SWAP2 0674 60 PUSH1 0x01 0676 60 PUSH1 0x01 0678 60 PUSH1 0xa0 067A 1B SHL 067B 03 SUB 067C 60 PUSH1 0x20 067E 82 DUP3 067F 01 ADD 0680 35 CALLDATALOAD 0681 16 AND 0682 91 SWAP2 0683 60 PUSH1 0x40 0685 82 DUP3 0686 01 ADD 0687 35 CALLDATALOAD 0688 91 SWAP2 0689 90 SWAP1 068A 81 DUP2 068B 01 ADD 068C 90 SWAP1 068D 60 PUSH1 0x80 068F 81 DUP2 0690 01 ADD 0691 60 PUSH1 0x60 0693 82 DUP3 0694 01 ADD 0695 35 CALLDATALOAD 0696 64 PUSH5 0x0100000000 069C 81 DUP2 069D 11 GT 069E 15 ISZERO 069F 61 PUSH2 0x06a7 06A2 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @0673 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0682 stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] & (0x01 << 0xa0) - 0x01 // @0688 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @068C stack[1] = stack[-2] + stack[-1] // @068C stack[2] = stack[-2] // @0690 stack[3] = stack[-2] + 0x80 // @0695 stack[4] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x06a7, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x0100000000) label_06A3: // Incoming jump from 0x06A2, if not !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x0100000000) // Inputs[1] { @06A6 memory[0x00:0x00] } 06A3 60 PUSH1 0x00 06A5 80 DUP1 06A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @06A6 revert(memory[0x00:0x00]); } // Block terminates label_06A7: // Incoming jump from 0x06A2, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x0100000000) // Inputs[3] // { // @06A8 stack[-3] // @06A9 stack[-1] // @06AA stack[-4] // } 06A7 5B JUMPDEST 06A8 82 DUP3 06A9 01 ADD 06AA 83 DUP4 06AB 60 PUSH1 0x20 06AD 82 DUP3 06AE 01 ADD 06AF 11 GT 06B0 15 ISZERO 06B1 61 PUSH2 0x06b9 06B4 57 *JUMPI // Stack delta = +0 // Outputs[1] { @06A9 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x06b9, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_06B5: // Incoming jump from 0x06B4, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @06B8 memory[0x00:0x00] } 06B5 60 PUSH1 0x00 06B7 80 DUP1 06B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @06B8 revert(memory[0x00:0x00]); } // Block terminates label_06B9: // Incoming jump from 0x06B4, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @06BA stack[-1] // @06BB msg.data[stack[-1]:stack[-1] + 0x20] // @06C0 stack[-2] // @06C1 stack[-4] // } 06B9 5B JUMPDEST 06BA 80 DUP1 06BB 35 CALLDATALOAD 06BC 90 SWAP1 06BD 60 PUSH1 0x20 06BF 01 ADD 06C0 91 SWAP2 06C1 84 DUP5 06C2 60 PUSH1 0x01 06C4 83 DUP4 06C5 02 MUL 06C6 84 DUP5 06C7 01 ADD 06C8 11 GT 06C9 64 PUSH5 0x0100000000 06CF 83 DUP4 06D0 11 GT 06D1 17 OR 06D2 15 ISZERO 06D3 61 PUSH2 0x06db 06D6 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @06BC stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @06C0 stack[0] = stack[-2] // @06C0 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x06db, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_06D7: // Incoming jump from 0x06D6, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @06DA memory[0x00:0x00] } 06D7 60 PUSH1 0x00 06D9 80 DUP1 06DA FD *REVERT // Stack delta = +0 // Outputs[1] { @06DA revert(memory[0x00:0x00]); } // Block terminates label_06DB: // Incoming jump from 0x06D6, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @06DD stack[-2] // @06DD stack[-3] // @06DE stack[-5] // @06E0 stack[-4] // } 06DB 5B JUMPDEST 06DC 50 POP 06DD 90 SWAP1 06DE 92 SWAP3 06DF 50 POP 06E0 90 SWAP1 06E1 50 POP 06E2 61 PUSH2 0x108c 06E5 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @06DE stack[-5] = stack[-3] // @06E0 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x108c label_06E6: // Incoming jump from 0x006F, if 0xa22cb465 == stack[-1] // Inputs[1] { @06E7 msg.value } 06E6 5B JUMPDEST 06E7 34 CALLVALUE 06E8 80 DUP1 06E9 15 ISZERO 06EA 61 PUSH2 0x06f2 06ED 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06E7 stack[0] = msg.value } // Block ends with conditional jump to 0x06f2, if !msg.value label_06EE: // Incoming jump from 0x06ED, if not !msg.value // Inputs[1] { @06F1 memory[0x00:0x00] } 06EE 60 PUSH1 0x00 06F0 80 DUP1 06F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @06F1 revert(memory[0x00:0x00]); } // Block terminates label_06F2: // Incoming jump from 0x06ED, if !msg.value // Inputs[1] { @06FA msg.data.length } 06F2 5B JUMPDEST 06F3 50 POP 06F4 61 PUSH2 0x01ed 06F7 60 PUSH1 0x04 06F9 80 DUP1 06FA 36 CALLDATASIZE 06FB 03 SUB 06FC 60 PUSH1 0x40 06FE 81 DUP2 06FF 10 LT 0700 15 ISZERO 0701 61 PUSH2 0x0709 0704 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @06F4 stack[-1] = 0x01ed // @06F7 stack[0] = 0x04 // @06FB stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0709, returns to 0x01ED, if !(msg.data.length - 0x04 < 0x40) label_0705: // Incoming jump from 0x0704, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0708 memory[0x00:0x00] } 0705 60 PUSH1 0x00 0707 80 DUP1 0708 FD *REVERT // Stack delta = +0 // Outputs[1] { @0708 revert(memory[0x00:0x00]); } // Block terminates label_0709: // Incoming call from 0x0704, returns to 0x01ED, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0713 stack[-2] // @0714 msg.data[stack[-2]:stack[-2] + 0x20] // @071A msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0709 5B JUMPDEST 070A 50 POP 070B 60 PUSH1 0x01 070D 60 PUSH1 0x01 070F 60 PUSH1 0xa0 0711 1B SHL 0712 03 SUB 0713 81 DUP2 0714 35 CALLDATALOAD 0715 16 AND 0716 90 SWAP1 0717 60 PUSH1 0x20 0719 01 ADD 071A 35 CALLDATALOAD 071B 15 ISZERO 071C 15 ISZERO 071D 61 PUSH2 0x145f 0720 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0716 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @071C stack[-1] = !!msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x145f label_0721: // Incoming jump from 0x007A, if 0xa6570beb == stack[-1] // Inputs[1] { @0722 msg.value } 0721 5B JUMPDEST 0722 34 CALLVALUE 0723 80 DUP1 0724 15 ISZERO 0725 61 PUSH2 0x072d 0728 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0722 stack[0] = msg.value } // Block ends with conditional jump to 0x072d, if !msg.value label_0729: // Incoming jump from 0x0728, if not !msg.value // Inputs[1] { @072C memory[0x00:0x00] } 0729 60 PUSH1 0x00 072B 80 DUP1 072C FD *REVERT // Stack delta = +0 // Outputs[1] { @072C revert(memory[0x00:0x00]); } // Block terminates label_072D: // Incoming jump from 0x0728, if !msg.value 072D 5B JUMPDEST 072E 50 POP 072F 61 PUSH2 0x0736 0732 61 PUSH2 0x152b 0735 56 *JUMP // Stack delta = +0 // Outputs[1] { @072F stack[-1] = 0x0736 } // Block ends with call to 0x152b, returns to 0x0736 label_0736: // Incoming return from call to 0x152B at 0x0735 // Inputs[4] // { // @073A memory[0x40:0x60] // @075D stack[-1] // @0761 memory[0x40:0x60] // @076A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0736 5B JUMPDEST 0737 60 PUSH1 0x40 0739 80 DUP1 073A 51 MLOAD 073B 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 075C 90 SWAP1 075D 92 SWAP3 075E 16 AND 075F 82 DUP3 0760 52 MSTORE 0761 51 MLOAD 0762 90 SWAP1 0763 81 DUP2 0764 90 SWAP1 0765 03 SUB 0766 60 PUSH1 0x20 0768 01 ADD 0769 90 SWAP1 076A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0760 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // @076A return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_076B: // Incoming jump from 0x0085, if 0xb88d4fde == stack[-1] // Inputs[1] { @0772 msg.data.length } 076B 5B JUMPDEST 076C 61 PUSH2 0x01ed 076F 60 PUSH1 0x04 0771 80 DUP1 0772 36 CALLDATASIZE 0773 03 SUB 0774 60 PUSH1 0x80 0776 81 DUP2 0777 10 LT 0778 15 ISZERO 0779 61 PUSH2 0x0781 077C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @076C stack[0] = 0x01ed // @076F stack[1] = 0x04 // @0773 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0781, if !(msg.data.length - 0x04 < 0x80) label_077D: // Incoming jump from 0x077C, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @0780 memory[0x00:0x00] } 077D 60 PUSH1 0x00 077F 80 DUP1 0780 FD *REVERT // Stack delta = +0 // Outputs[1] { @0780 revert(memory[0x00:0x00]); } // Block terminates label_0781: // Incoming jump from 0x077C, if !(msg.data.length - 0x04 < 0x80) // Inputs[6] // { // @078A stack[-2] // @078B msg.data[stack[-2]:stack[-2] + 0x20] // @0793 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0797 stack[-1] // @079C msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @07AA msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } 0781 5B JUMPDEST 0782 60 PUSH1 0x01 0784 60 PUSH1 0x01 0786 60 PUSH1 0xa0 0788 1B SHL 0789 03 SUB 078A 82 DUP3 078B 35 CALLDATALOAD 078C 81 DUP2 078D 16 AND 078E 92 SWAP3 078F 60 PUSH1 0x20 0791 81 DUP2 0792 01 ADD 0793 35 CALLDATALOAD 0794 90 SWAP1 0795 91 SWAP2 0796 16 AND 0797 91 SWAP2 0798 60 PUSH1 0x40 079A 82 DUP3 079B 01 ADD 079C 35 CALLDATALOAD 079D 91 SWAP2 079E 90 SWAP1 079F 81 DUP2 07A0 01 ADD 07A1 90 SWAP1 07A2 60 PUSH1 0x80 07A4 81 DUP2 07A5 01 ADD 07A6 60 PUSH1 0x60 07A8 82 DUP3 07A9 01 ADD 07AA 35 CALLDATALOAD 07AB 64 PUSH5 0x0100000000 07B1 81 DUP2 07B2 11 GT 07B3 15 ISZERO 07B4 61 PUSH2 0x07bc 07B7 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @078E stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0797 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @079D stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @07A1 stack[1] = stack[-2] + stack[-1] // @07A1 stack[2] = stack[-2] // @07A5 stack[3] = stack[-2] + 0x80 // @07AA stack[4] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x07bc, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x0100000000) label_07B8: // Incoming jump from 0x07B7, if not !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x0100000000) // Inputs[1] { @07BB memory[0x00:0x00] } 07B8 60 PUSH1 0x00 07BA 80 DUP1 07BB FD *REVERT // Stack delta = +0 // Outputs[1] { @07BB revert(memory[0x00:0x00]); } // Block terminates label_07BC: // Incoming jump from 0x07B7, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x0100000000) // Inputs[3] // { // @07BD stack[-3] // @07BE stack[-1] // @07BF stack[-4] // } 07BC 5B JUMPDEST 07BD 82 DUP3 07BE 01 ADD 07BF 83 DUP4 07C0 60 PUSH1 0x20 07C2 82 DUP3 07C3 01 ADD 07C4 11 GT 07C5 15 ISZERO 07C6 61 PUSH2 0x07ce 07C9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @07BE stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x07ce, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_07CA: // Incoming jump from 0x07C9, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @07CD memory[0x00:0x00] } 07CA 60 PUSH1 0x00 07CC 80 DUP1 07CD FD *REVERT // Stack delta = +0 // Outputs[1] { @07CD revert(memory[0x00:0x00]); } // Block terminates label_07CE: // Incoming jump from 0x07C9, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @07CF stack[-1] // @07D0 msg.data[stack[-1]:stack[-1] + 0x20] // @07D5 stack[-2] // @07D6 stack[-4] // } 07CE 5B JUMPDEST 07CF 80 DUP1 07D0 35 CALLDATALOAD 07D1 90 SWAP1 07D2 60 PUSH1 0x20 07D4 01 ADD 07D5 91 SWAP2 07D6 84 DUP5 07D7 60 PUSH1 0x01 07D9 83 DUP4 07DA 02 MUL 07DB 84 DUP5 07DC 01 ADD 07DD 11 GT 07DE 64 PUSH5 0x0100000000 07E4 83 DUP4 07E5 11 GT 07E6 17 OR 07E7 15 ISZERO 07E8 61 PUSH2 0x07f0 07EB 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @07D1 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @07D5 stack[0] = stack[-2] // @07D5 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x07f0, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_07EC: // Incoming jump from 0x07EB, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @07EF memory[0x00:0x00] } 07EC 60 PUSH1 0x00 07EE 80 DUP1 07EF FD *REVERT // Stack delta = +0 // Outputs[1] { @07EF revert(memory[0x00:0x00]); } // Block terminates label_07F0: // Incoming jump from 0x07EB, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @07F1 stack[-3] // @07F1 stack[-1] // @07F2 stack[-2] // @0803 memory[0x40:0x60] // @081A msg.data[stack[-3]:stack[-3] + stack[-2]] // @0825 stack[-5] // @082A stack[-4] // } 07F0 5B JUMPDEST 07F1 91 SWAP2 07F2 90 SWAP1 07F3 80 DUP1 07F4 80 DUP1 07F5 60 PUSH1 0x1f 07F7 01 ADD 07F8 60 PUSH1 0x20 07FA 80 DUP1 07FB 91 SWAP2 07FC 04 DIV 07FD 02 MUL 07FE 60 PUSH1 0x20 0800 01 ADD 0801 60 PUSH1 0x40 0803 51 MLOAD 0804 90 SWAP1 0805 81 DUP2 0806 01 ADD 0807 60 PUSH1 0x40 0809 52 MSTORE 080A 80 DUP1 080B 93 SWAP4 080C 92 SWAP3 080D 91 SWAP2 080E 90 SWAP1 080F 81 DUP2 0810 81 DUP2 0811 52 MSTORE 0812 60 PUSH1 0x20 0814 01 ADD 0815 83 DUP4 0816 83 DUP4 0817 80 DUP1 0818 82 DUP3 0819 84 DUP5 081A 37 CALLDATACOPY 081B 60 PUSH1 0x00 081D 92 SWAP3 081E 01 ADD 081F 91 SWAP2 0820 90 SWAP1 0821 91 SWAP2 0822 52 MSTORE 0823 50 POP 0824 92 SWAP3 0825 95 SWAP6 0826 50 POP 0827 61 PUSH2 0x154f 082A 94 SWAP5 082B 50 POP 082C 50 POP 082D 50 POP 082E 50 POP 082F 50 POP 0830 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0809 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0811 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @081A memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0822 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0825 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x154f label_0831: // Incoming jump from 0x003E, if 0xc3c0f4e8 == stack[-1] // Inputs[1] { @0832 msg.value } 0831 5B JUMPDEST 0832 34 CALLVALUE 0833 80 DUP1 0834 15 ISZERO 0835 61 PUSH2 0x083d 0838 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0832 stack[0] = msg.value } // Block ends with conditional jump to 0x083d, if !msg.value label_0839: // Incoming jump from 0x0838, if not !msg.value // Inputs[1] { @083C memory[0x00:0x00] } 0839 60 PUSH1 0x00 083B 80 DUP1 083C FD *REVERT // Stack delta = +0 // Outputs[1] { @083C revert(memory[0x00:0x00]); } // Block terminates label_083D: // Incoming jump from 0x0838, if !msg.value // Inputs[1] { @0845 msg.data.length } 083D 5B JUMPDEST 083E 50 POP 083F 61 PUSH2 0x01ed 0842 60 PUSH1 0x04 0844 80 DUP1 0845 36 CALLDATASIZE 0846 03 SUB 0847 60 PUSH1 0x20 0849 81 DUP2 084A 10 LT 084B 15 ISZERO 084C 61 PUSH2 0x0854 084F 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @083F stack[-1] = 0x01ed // @0842 stack[0] = 0x04 // @0846 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0854, if !(msg.data.length - 0x04 < 0x20) label_0850: // Incoming jump from 0x084F, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0853 memory[0x00:0x00] } 0850 60 PUSH1 0x00 0852 80 DUP1 0853 FD *REVERT // Stack delta = +0 // Outputs[1] { @0853 revert(memory[0x00:0x00]); } // Block terminates label_0854: // Incoming jump from 0x084F, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0855 stack[-2] // @0856 stack[-1] // @085D msg.data[stack[-2]:stack[-2] + 0x20] // } 0854 5B JUMPDEST 0855 81 DUP2 0856 01 ADD 0857 90 SWAP1 0858 60 PUSH1 0x20 085A 81 DUP2 085B 01 ADD 085C 81 DUP2 085D 35 CALLDATALOAD 085E 64 PUSH5 0x0100000000 0864 81 DUP2 0865 11 GT 0866 15 ISZERO 0867 61 PUSH2 0x086f 086A 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0857 stack[-1] = stack[-2] // @0857 stack[-2] = stack[-2] + stack[-1] // @085B stack[0] = stack[-2] + 0x20 // @085D stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x086f, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_086B: // Incoming jump from 0x086A, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @086E memory[0x00:0x00] } 086B 60 PUSH1 0x00 086D 80 DUP1 086E FD *REVERT // Stack delta = +0 // Outputs[1] { @086E revert(memory[0x00:0x00]); } // Block terminates label_086F: // Incoming jump from 0x086A, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @0870 stack[-3] // @0871 stack[-1] // @0872 stack[-4] // } 086F 5B JUMPDEST 0870 82 DUP3 0871 01 ADD 0872 83 DUP4 0873 60 PUSH1 0x20 0875 82 DUP3 0876 01 ADD 0877 11 GT 0878 15 ISZERO 0879 61 PUSH2 0x0881 087C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0871 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0881, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_087D: // Incoming jump from 0x087C, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0880 memory[0x00:0x00] } 087D 60 PUSH1 0x00 087F 80 DUP1 0880 FD *REVERT // Stack delta = +0 // Outputs[1] { @0880 revert(memory[0x00:0x00]); } // Block terminates label_0881: // Incoming jump from 0x087C, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0882 stack[-1] // @0883 msg.data[stack[-1]:stack[-1] + 0x20] // @0888 stack[-2] // @0889 stack[-4] // } 0881 5B JUMPDEST 0882 80 DUP1 0883 35 CALLDATALOAD 0884 90 SWAP1 0885 60 PUSH1 0x20 0887 01 ADD 0888 91 SWAP2 0889 84 DUP5 088A 60 PUSH1 0x01 088C 83 DUP4 088D 02 MUL 088E 84 DUP5 088F 01 ADD 0890 11 GT 0891 64 PUSH5 0x0100000000 0897 83 DUP4 0898 11 GT 0899 17 OR 089A 15 ISZERO 089B 61 PUSH2 0x08a3 089E 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0884 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0888 stack[0] = stack[-2] // @0888 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x08a3, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_089F: // Incoming jump from 0x089E, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @08A2 memory[0x00:0x00] } 089F 60 PUSH1 0x00 08A1 80 DUP1 08A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @08A2 revert(memory[0x00:0x00]); } // Block terminates label_08A3: // Incoming jump from 0x089E, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @08A5 stack[-2] // @08A5 stack[-3] // @08A6 stack[-5] // @08A8 stack[-4] // } 08A3 5B JUMPDEST 08A4 50 POP 08A5 90 SWAP1 08A6 92 SWAP3 08A7 50 POP 08A8 90 SWAP1 08A9 50 POP 08AA 61 PUSH2 0x155b 08AD 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @08A6 stack[-5] = stack[-3] // @08A8 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x155b label_08AE: // Incoming jump from 0x0049, if 0xc87b56dd == stack[-1] // Inputs[1] { @08AF msg.value } 08AE 5B JUMPDEST 08AF 34 CALLVALUE 08B0 80 DUP1 08B1 15 ISZERO 08B2 61 PUSH2 0x08ba 08B5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08AF stack[0] = msg.value } // Block ends with conditional jump to 0x08ba, if !msg.value label_08B6: // Incoming jump from 0x08B5, if not !msg.value // Inputs[1] { @08B9 memory[0x00:0x00] } 08B6 60 PUSH1 0x00 08B8 80 DUP1 08B9 FD *REVERT // Stack delta = +0 // Outputs[1] { @08B9 revert(memory[0x00:0x00]); } // Block terminates label_08BA: // Incoming jump from 0x08B5, if !msg.value // Inputs[1] { @08C2 msg.data.length } 08BA 5B JUMPDEST 08BB 50 POP 08BC 61 PUSH2 0x0295 08BF 60 PUSH1 0x04 08C1 80 DUP1 08C2 36 CALLDATASIZE 08C3 03 SUB 08C4 60 PUSH1 0x20 08C6 81 DUP2 08C7 10 LT 08C8 15 ISZERO 08C9 61 PUSH2 0x08d1 08CC 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @08BC stack[-1] = 0x0295 // @08BF stack[0] = 0x04 // @08C3 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x08d1, returns to 0x0295, if !(msg.data.length - 0x04 < 0x20) label_08CD: // Incoming jump from 0x08CC, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @08D0 memory[0x00:0x00] } 08CD 60 PUSH1 0x00 08CF 80 DUP1 08D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @08D0 revert(memory[0x00:0x00]); } // Block terminates label_08D1: // Incoming call from 0x08CC, returns to 0x0295, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @08D3 stack[-2] // @08D3 msg.data[stack[-2]:stack[-2] + 0x20] // } 08D1 5B JUMPDEST 08D2 50 POP 08D3 35 CALLDATALOAD 08D4 61 PUSH2 0x15d8 08D7 56 *JUMP // Stack delta = -1 // Outputs[1] { @08D3 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x15d8 label_08D8: // Incoming jump from 0x0054, if 0xe8a3d485 == stack[-1] // Inputs[1] { @08D9 msg.value } 08D8 5B JUMPDEST 08D9 34 CALLVALUE 08DA 80 DUP1 08DB 15 ISZERO 08DC 61 PUSH2 0x08e4 08DF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08D9 stack[0] = msg.value } // Block ends with conditional jump to 0x08e4, if !msg.value label_08E0: // Incoming jump from 0x08DF, if not !msg.value // Inputs[1] { @08E3 memory[0x00:0x00] } 08E0 60 PUSH1 0x00 08E2 80 DUP1 08E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @08E3 revert(memory[0x00:0x00]); } // Block terminates label_08E4: // Incoming jump from 0x08DF, if !msg.value 08E4 5B JUMPDEST 08E5 50 POP 08E6 61 PUSH2 0x0295 08E9 61 PUSH2 0x19d8 08EC 56 *JUMP // Stack delta = +0 // Outputs[1] { @08E6 stack[-1] = 0x0295 } // Block ends with unconditional jump to 0x19d8 label_08ED: // Incoming jump from 0x005F, if 0xe985e9c5 == stack[-1] // Inputs[1] { @08EE msg.value } 08ED 5B JUMPDEST 08EE 34 CALLVALUE 08EF 80 DUP1 08F0 15 ISZERO 08F1 61 PUSH2 0x08f9 08F4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08EE stack[0] = msg.value } // Block ends with conditional jump to 0x08f9, if !msg.value label_08F5: // Incoming jump from 0x08F4, if not !msg.value // Inputs[1] { @08F8 memory[0x00:0x00] } 08F5 60 PUSH1 0x00 08F7 80 DUP1 08F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @08F8 revert(memory[0x00:0x00]); } // Block terminates label_08F9: // Incoming jump from 0x08F4, if !msg.value // Inputs[1] { @0901 msg.data.length } 08F9 5B JUMPDEST 08FA 50 POP 08FB 61 PUSH2 0x023b 08FE 60 PUSH1 0x04 0900 80 DUP1 0901 36 CALLDATASIZE 0902 03 SUB 0903 60 PUSH1 0x40 0905 81 DUP2 0906 10 LT 0907 15 ISZERO 0908 61 PUSH2 0x0910 090B 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @08FB stack[-1] = 0x023b // @08FE stack[0] = 0x04 // @0902 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0910, returns to 0x023B, if !(msg.data.length - 0x04 < 0x40) label_090C: // Incoming jump from 0x090B, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @090F memory[0x00:0x00] } 090C 60 PUSH1 0x00 090E 80 DUP1 090F FD *REVERT // Stack delta = +0 // Outputs[1] { @090F revert(memory[0x00:0x00]); } // Block terminates label_0910: // Incoming call from 0x090B, returns to 0x023B, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @091A stack[-2] // @091B msg.data[stack[-2]:stack[-2] + 0x20] // @0922 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0910 5B JUMPDEST 0911 50 POP 0912 60 PUSH1 0x01 0914 60 PUSH1 0x01 0916 60 PUSH1 0xa0 0918 1B SHL 0919 03 SUB 091A 81 DUP2 091B 35 CALLDATALOAD 091C 81 DUP2 091D 16 AND 091E 91 SWAP2 091F 60 PUSH1 0x20 0921 01 ADD 0922 35 CALLDATALOAD 0923 16 AND 0924 61 PUSH2 0x1a59 0927 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @091E stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0923 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x1a59 label_0928: // Incoming jump from 0x100F // Incoming jump from 0x01EC // Inputs[4] // { // @092C stack[-4] // @092D stack[-3] // @092E stack[-2] // @092F stack[-1] // } 0928 5B JUMPDEST 0929 61 PUSH2 0x0934 092C 84 DUP5 092D 84 DUP5 092E 84 DUP5 092F 84 DUP5 0930 61 PUSH2 0x1a87 0933 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0929 stack[0] = 0x0934 // @092C stack[1] = stack[-4] // @092D stack[2] = stack[-3] // @092E stack[3] = stack[-2] // @092F stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x1a87 label_0934: // Incoming return from call to 0x2669 at 0x21BA // Incoming return from call to 0x2669 at 0x21BA // Inputs[1] { @0939 stack[-5] } 0934 5B JUMPDEST 0935 50 POP 0936 50 POP 0937 50 POP 0938 50 POP 0939 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_093A: // Incoming jump from 0x023A // Inputs[4] // { // @095C stack[-1] // @096B memory[0x00:0x40] // @096C storage[keccak256(memory[0x00:0x40])] // @0971 stack[-2] // } 093A 5B JUMPDEST 093B 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 095C 81 DUP2 095D 16 AND 095E 60 PUSH1 0x00 0960 90 SWAP1 0961 81 DUP2 0962 52 MSTORE 0963 60 PUSH1 0x20 0965 81 DUP2 0966 90 SWAP1 0967 52 MSTORE 0968 60 PUSH1 0x40 096A 90 SWAP1 096B 20 SHA3 096C 54 SLOAD 096D 60 PUSH1 0xff 096F 16 AND 0970 5B JUMPDEST 0971 91 SWAP2 0972 90 SWAP1 0973 50 POP 0974 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0962 memory[0x00:0x20] = stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // @0967 memory[0x20:0x40] = 0x00 // @0971 stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0975: // Incoming call from 0x0263, returns to 0x0264 // Inputs[2] // { // @0978 storage[0x05] // @0982 stack[-1] // } 0975 5B JUMPDEST 0976 60 PUSH1 0x05 0978 54 SLOAD 0979 60 PUSH1 0x01 097B 60 PUSH1 0x01 097D 60 PUSH1 0xa0 097F 1B SHL 0980 03 SUB 0981 16 AND 0982 81 DUP2 0983 56 *JUMP // Stack delta = +1 // Outputs[1] { @0981 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x05] } // Block ends with unconditional jump to stack[-1] label_0984: // Incoming call from 0x0294, returns to 0x0295 // Inputs[2] // { // @0988 storage[0x03] // @098C memory[0x40:0x60] // } 0984 5B JUMPDEST 0985 60 PUSH1 0x03 0987 80 DUP1 0988 54 SLOAD 0989 60 PUSH1 0x40 098B 80 DUP1 098C 51 MLOAD 098D 60 PUSH1 0x20 098F 60 PUSH1 0x02 0991 60 PUSH1 0x01 0993 85 DUP6 0994 16 AND 0995 15 ISZERO 0996 61 PUSH2 0x0100 0999 02 MUL 099A 60 PUSH1 0x00 099C 19 NOT 099D 01 ADD 099E 90 SWAP1 099F 94 SWAP5 09A0 16 AND 09A1 93 SWAP4 09A2 90 SWAP1 09A3 93 SWAP4 09A4 04 DIV 09A5 60 PUSH1 0x1f 09A7 81 DUP2 09A8 01 ADD 09A9 84 DUP5 09AA 90 SWAP1 09AB 04 DIV 09AC 84 DUP5 09AD 02 MUL 09AE 82 DUP3 09AF 01 ADD 09B0 84 DUP5 09B1 01 ADD 09B2 90 SWAP1 09B3 92 SWAP3 09B4 52 MSTORE 09B5 81 DUP2 09B6 81 DUP2 09B7 52 MSTORE 09B8 92 SWAP3 09B9 91 SWAP2 09BA 83 DUP4 09BB 01 ADD 09BC 82 DUP3 09BD 82 DUP3 09BE 80 DUP1 09BF 15 ISZERO 09C0 61 PUSH2 0x0a0a 09C3 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @09B3 stack[2] = (storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02 // @09B4 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02 + 0x1f) / 0x20) // @09B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02 // @09B8 stack[0] = memory[0x40:0x60] // @09B9 stack[1] = 0x03 // @09BB stack[3] = memory[0x40:0x60] + 0x20 // @09BC stack[4] = 0x03 // @09BD stack[5] = (storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x0a0a, if !((storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02) label_09C4: // Incoming jump from 0x09C3, if not !((storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02) // Inputs[1] { @09C4 stack[-1] } 09C4 80 DUP1 09C5 60 PUSH1 0x1f 09C7 10 LT 09C8 61 PUSH2 0x09df 09CB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09df, if 0x1f < stack[-1] label_09CC: // Incoming jump from 0x09CB, if not 0x1f < stack[-1] // Inputs[4] // { // @09D0 stack[-2] // @09D1 storage[stack[-2]] // @09D4 stack[-3] // @09D6 stack[-1] // } 09CC 61 PUSH2 0x0100 09CF 80 DUP1 09D0 83 DUP4 09D1 54 SLOAD 09D2 04 DIV 09D3 02 MUL 09D4 83 DUP4 09D5 52 MSTORE 09D6 91 SWAP2 09D7 60 PUSH1 0x20 09D9 01 ADD 09DA 91 SWAP2 09DB 61 PUSH2 0x0a0a 09DE 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @09D5 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @09DA stack[-1] = stack[-1] // @09DA stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0a0a label_09DF: // Incoming jump from 0x1069, if 0x1f < stack[-1] // Incoming jump from 0x09CB, if 0x1f < stack[-1] // Inputs[5] // { // @09E0 stack[-3] // @09E1 stack[-1] // @09E3 stack[-2] // @09EB memory[0x00:0x20] // @09EF storage[keccak256(memory[0x00:0x20])] // } 09DF 5B JUMPDEST 09E0 82 DUP3 09E1 01 ADD 09E2 91 SWAP2 09E3 90 SWAP1 09E4 60 PUSH1 0x00 09E6 52 MSTORE 09E7 60 PUSH1 0x20 09E9 60 PUSH1 0x00 09EB 20 SHA3 09EC 90 SWAP1 09ED 5B JUMPDEST 09EE 81 DUP2 09EF 54 SLOAD 09F0 81 DUP2 09F1 52 MSTORE 09F2 90 SWAP1 09F3 60 PUSH1 0x01 09F5 01 ADD 09F6 90 SWAP1 09F7 60 PUSH1 0x20 09F9 01 ADD 09FA 80 DUP1 09FB 83 DUP4 09FC 11 GT 09FD 61 PUSH2 0x09ed 0A00 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @09E2 stack[-3] = stack[-3] + stack[-1] // @09E6 memory[0x00:0x20] = stack[-2] // @09F1 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @09F6 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @09F9 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x09ed, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0A01: // Incoming jump from 0x0A00, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0A00, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0A01 stack[-3] // @0A02 stack[-1] // } 0A01 82 DUP3 0A02 90 SWAP1 0A03 03 SUB 0A04 60 PUSH1 0x1f 0A06 16 AND 0A07 82 DUP3 0A08 01 ADD 0A09 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0A09 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0A09 stack[-1] = stack[-3] // } // Block continues label_0A0A: // Incoming jump from 0x1061, if !((storage[0x04] & ~0x00 + 0x0100 * !(storage[0x04] & 0x01)) / 0x02) // Incoming jump from 0x107C // Incoming jump from 0x0A09 // Incoming jump from 0x09C3, if !((storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02) // Incoming jump from 0x09DE // Inputs[1] { @0A10 stack[-7] } 0A0A 5B JUMPDEST 0A0B 50 POP 0A0C 50 POP 0A0D 50 POP 0A0E 50 POP 0A0F 50 POP 0A10 81 DUP2 0A11 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0A12: // Incoming call from 0x257F, returns to 0x2580 // Incoming jump from 0x0333 // Inputs[1] { @0A19 stack[-1] } 0A12 5B JUMPDEST 0A13 60 PUSH1 0x00 0A15 80 DUP1 0A16 61 PUSH2 0x0a1e 0A19 83 DUP4 0A1A 61 PUSH2 0x0dda 0A1D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A13 stack[0] = 0x00 // @0A15 stack[1] = 0x00 // @0A16 stack[2] = 0x0a1e // @0A19 stack[3] = stack[-1] // } // Block ends with call to 0x0dda, returns to 0x0A1E label_0A1E: // Incoming return from call to 0x0DDA at 0x0A1D // Incoming return from call to 0x0DDA at 0x0A1D // Inputs[5] // { // @0A21 stack[-4] // @0A2C memory[0x00:0x40] // @0A2D storage[keccak256(memory[0x00:0x40])] // @0A2E stack[-1] // @0A2F stack[-2] // } 0A1E 5B JUMPDEST 0A1F 60 PUSH1 0x00 0A21 84 DUP5 0A22 81 DUP2 0A23 52 MSTORE 0A24 60 PUSH1 0x14 0A26 60 PUSH1 0x20 0A28 52 MSTORE 0A29 60 PUSH1 0x40 0A2B 90 SWAP1 0A2C 20 SHA3 0A2D 54 SLOAD 0A2E 90 SWAP1 0A2F 91 SWAP2 0A30 50 POP 0A31 60 PUSH1 0x01 0A33 60 PUSH1 0x01 0A35 60 PUSH1 0xa0 0A37 1B SHL 0A38 03 SUB 0A39 16 AND 0A3A 15 ISZERO 0A3B 61 PUSH2 0x0a58 0A3E 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @0A23 memory[0x00:0x20] = stack[-4] // @0A28 memory[0x20:0x40] = 0x14 // @0A2F stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x0a58, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_0A3F: // Incoming jump from 0x0A3E, if not !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @0A42 stack[-3] // @0A4D memory[0x00:0x40] // @0A4E storage[keccak256(memory[0x00:0x40])] // } 0A3F 50 POP 0A40 60 PUSH1 0x00 0A42 82 DUP3 0A43 81 DUP2 0A44 52 MSTORE 0A45 60 PUSH1 0x14 0A47 60 PUSH1 0x20 0A49 52 MSTORE 0A4A 60 PUSH1 0x40 0A4C 90 SWAP1 0A4D 20 SHA3 0A4E 54 SLOAD 0A4F 60 PUSH1 0x01 0A51 60 PUSH1 0x01 0A53 60 PUSH1 0xa0 0A55 1B SHL 0A56 03 SUB 0A57 16 AND 0A58 5B JUMPDEST 0A59 60 PUSH1 0x01 0A5B 60 PUSH1 0x01 0A5D 60 PUSH1 0xa0 0A5F 1B SHL 0A60 03 SUB 0A61 81 DUP2 0A62 16 AND 0A63 61 PUSH2 0x0ab3 0A66 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @0A44 memory[0x00:0x20] = stack[-3] // @0A49 memory[0x20:0x40] = 0x14 // @0A57 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0ab3, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_0A67: // Incoming jump from 0x0A66, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x0A66, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0A6A memory[0x40:0x60] // @0AA9 memory[0x40:0x60] // @0AB2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0A67 60 PUSH1 0x40 0A69 80 DUP1 0A6A 51 MLOAD 0A6B 62 PUSH3 0x461bcd 0A6F 60 PUSH1 0xe5 0A71 1B SHL 0A72 81 DUP2 0A73 52 MSTORE 0A74 60 PUSH1 0x20 0A76 60 PUSH1 0x04 0A78 82 DUP3 0A79 01 ADD 0A7A 52 MSTORE 0A7B 60 PUSH1 0x1a 0A7D 60 PUSH1 0x24 0A7F 82 DUP3 0A80 01 ADD 0A81 52 MSTORE 0A82 7F PUSH32 0x4552433732313a204e6f6e2d6578697374656e7420746f6b656e000000000000 0AA3 60 PUSH1 0x44 0AA5 82 DUP3 0AA6 01 ADD 0AA7 52 MSTORE 0AA8 90 SWAP1 0AA9 51 MLOAD 0AAA 90 SWAP1 0AAB 81 DUP2 0AAC 90 SWAP1 0AAD 03 SUB 0AAE 60 PUSH1 0x64 0AB0 01 ADD 0AB1 90 SWAP1 0AB2 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0A73 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A7A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A81 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1a // @0AA7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a204e6f6e2d6578697374656e7420746f6b656e000000000000 // @0AB2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0AB3: // Incoming jump from 0x0A66, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x0A66, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0AB8 stack[-3] // @0AC3 memory[0x00:0x40] // @0AC4 storage[keccak256(memory[0x00:0x40])] // @0ACE stack[-4] // } 0AB3 5B JUMPDEST 0AB4 50 POP 0AB5 50 POP 0AB6 60 PUSH1 0x00 0AB8 90 SWAP1 0AB9 81 DUP2 0ABA 52 MSTORE 0ABB 60 PUSH1 0x12 0ABD 60 PUSH1 0x20 0ABF 52 MSTORE 0AC0 60 PUSH1 0x40 0AC2 90 SWAP1 0AC3 20 SHA3 0AC4 54 SLOAD 0AC5 60 PUSH1 0x01 0AC7 60 PUSH1 0x01 0AC9 60 PUSH1 0xa0 0ACB 1B SHL 0ACC 03 SUB 0ACD 16 AND 0ACE 90 SWAP1 0ACF 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0ABA memory[0x00:0x20] = stack[-3] // @0ABF memory[0x20:0x40] = 0x12 // @0ACE stack[-4] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_0AD0: // Incoming jump from 0x035F // Inputs[1] { @0AD6 stack[-1] } 0AD0 5B JUMPDEST 0AD1 60 PUSH1 0x00 0AD3 61 PUSH2 0x0adb 0AD6 82 DUP3 0AD7 61 PUSH2 0x0dda 0ADA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AD1 stack[0] = 0x00 // @0AD3 stack[1] = 0x0adb // @0AD6 stack[2] = stack[-1] // } // Block ends with call to 0x0dda, returns to 0x0ADB label_0ADB: // Incoming return from call to 0x0DDA at 0x0ADA // Incoming return from call to 0x0DDA at 0x0ADA // Inputs[2] // { // @0ADC stack[-1] // @0ADC stack[-2] // } 0ADB 5B JUMPDEST 0ADC 90 SWAP1 0ADD 50 POP 0ADE 60 PUSH1 0x01 0AE0 60 PUSH1 0x01 0AE2 60 PUSH1 0xa0 0AE4 1B SHL 0AE5 03 SUB 0AE6 81 DUP2 0AE7 16 AND 0AE8 61 PUSH2 0x0b38 0AEB 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0ADC stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0b38, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0AEC: // Incoming jump from 0x0AEB, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0AEF memory[0x40:0x60] // @0B2E memory[0x40:0x60] // @0B37 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0AEC 60 PUSH1 0x40 0AEE 80 DUP1 0AEF 51 MLOAD 0AF0 62 PUSH3 0x461bcd 0AF4 60 PUSH1 0xe5 0AF6 1B SHL 0AF7 81 DUP2 0AF8 52 MSTORE 0AF9 60 PUSH1 0x20 0AFB 60 PUSH1 0x04 0AFD 82 DUP3 0AFE 01 ADD 0AFF 52 MSTORE 0B00 60 PUSH1 0x1c 0B02 60 PUSH1 0x24 0B04 82 DUP3 0B05 01 ADD 0B06 52 MSTORE 0B07 7F PUSH32 0x4552433732313a20546f6b656e20646f6573206e6f7420657869737400000000 0B28 60 PUSH1 0x44 0B2A 82 DUP3 0B2B 01 ADD 0B2C 52 MSTORE 0B2D 90 SWAP1 0B2E 51 MLOAD 0B2F 90 SWAP1 0B30 81 DUP2 0B31 90 SWAP1 0B32 03 SUB 0B33 60 PUSH1 0x64 0B35 01 ADD 0B36 90 SWAP1 0B37 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0AF8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AFF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B06 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1c // @0B2C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20546f6b656e20646f6573206e6f7420657869737400000000 // @0B37 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0B38: // Incoming jump from 0x0AEB, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0B39 stack[-1] // @0B43 stack[-3] // } 0B38 5B JUMPDEST 0B39 80 DUP1 0B3A 60 PUSH1 0x01 0B3C 60 PUSH1 0x01 0B3E 60 PUSH1 0xa0 0B40 1B SHL 0B41 03 SUB 0B42 16 AND 0B43 83 DUP4 0B44 60 PUSH1 0x01 0B46 60 PUSH1 0x01 0B48 60 PUSH1 0xa0 0B4A 1B SHL 0B4B 03 SUB 0B4C 16 AND 0B4D 14 EQ 0B4E 15 ISZERO 0B4F 61 PUSH2 0x0b89 0B52 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b89, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0B53: // Incoming jump from 0x0B52, if not !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @0B55 memory[0x40:0x60] // @0B83 memory[0x40:0x60] // @0B88 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B53 60 PUSH1 0x40 0B55 51 MLOAD 0B56 62 PUSH3 0x461bcd 0B5A 60 PUSH1 0xe5 0B5C 1B SHL 0B5D 81 DUP2 0B5E 52 MSTORE 0B5F 60 PUSH1 0x04 0B61 01 ADD 0B62 80 DUP1 0B63 80 DUP1 0B64 60 PUSH1 0x20 0B66 01 ADD 0B67 82 DUP3 0B68 81 DUP2 0B69 03 SUB 0B6A 82 DUP3 0B6B 52 MSTORE 0B6C 60 PUSH1 0x21 0B6E 81 DUP2 0B6F 52 MSTORE 0B70 60 PUSH1 0x20 0B72 01 ADD 0B73 80 DUP1 0B74 61 PUSH2 0x2db6 0B77 60 PUSH1 0x21 0B79 91 SWAP2 0B7A 39 CODECOPY 0B7B 60 PUSH1 0x40 0B7D 01 ADD 0B7E 91 SWAP2 0B7F 50 POP 0B80 50 POP 0B81 60 PUSH1 0x40 0B83 51 MLOAD 0B84 80 DUP1 0B85 91 SWAP2 0B86 03 SUB 0B87 90 SWAP1 0B88 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0B5E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B6B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0B6F memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @0B7A memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x2db6:0x2dd7] // @0B88 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0B89: // Incoming jump from 0x0B52, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @0B8A msg.sender // @0B93 stack[-1] // } 0B89 5B JUMPDEST 0B8A 33 CALLER 0B8B 60 PUSH1 0x01 0B8D 60 PUSH1 0x01 0B8F 60 PUSH1 0xa0 0B91 1B SHL 0B92 03 SUB 0B93 82 DUP3 0B94 16 AND 0B95 14 EQ 0B96 80 DUP1 0B97 61 PUSH2 0x0ba5 0B9A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B95 stack[0] = stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender } // Block ends with conditional jump to 0x0ba5, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_0B9B: // Incoming jump from 0x0B9A, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0B9F stack[-2] // @0BA0 msg.sender // } 0B9B 50 POP 0B9C 61 PUSH2 0x0ba5 0B9F 81 DUP2 0BA0 33 CALLER 0BA1 61 PUSH2 0x1a59 0BA4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B9C stack[-1] = 0x0ba5 // @0B9F stack[0] = stack[-2] // @0BA0 stack[1] = msg.sender // } // Block ends with call to 0x1a59, returns to 0x0BA5 label_0BA5: // Incoming jump from 0x0B9A, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming return from call to 0x1A59 at 0x0BA4 // Inputs[1] { @0BA9 stack[-1] } 0BA5 5B JUMPDEST 0BA6 61 PUSH2 0x0be0 0BA9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0be0, if stack[-1] label_0BAA: // Incoming jump from 0x0BA9, if not stack[-1] // Inputs[3] // { // @0BAC memory[0x40:0x60] // @0BDA memory[0x40:0x60] // @0BDF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0BAA 60 PUSH1 0x40 0BAC 51 MLOAD 0BAD 62 PUSH3 0x461bcd 0BB1 60 PUSH1 0xe5 0BB3 1B SHL 0BB4 81 DUP2 0BB5 52 MSTORE 0BB6 60 PUSH1 0x04 0BB8 01 ADD 0BB9 80 DUP1 0BBA 80 DUP1 0BBB 60 PUSH1 0x20 0BBD 01 ADD 0BBE 82 DUP3 0BBF 81 DUP2 0BC0 03 SUB 0BC1 82 DUP3 0BC2 52 MSTORE 0BC3 60 PUSH1 0x38 0BC5 81 DUP2 0BC6 52 MSTORE 0BC7 60 PUSH1 0x20 0BC9 01 ADD 0BCA 80 DUP1 0BCB 61 PUSH2 0x2d5b 0BCE 60 PUSH1 0x38 0BD0 91 SWAP2 0BD1 39 CODECOPY 0BD2 60 PUSH1 0x40 0BD4 01 ADD 0BD5 91 SWAP2 0BD6 50 POP 0BD7 50 POP 0BD8 60 PUSH1 0x40 0BDA 51 MLOAD 0BDB 80 DUP1 0BDC 91 SWAP2 0BDD 03 SUB 0BDE 90 SWAP1 0BDF FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0BB5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BC2 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0BC6 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x38 // @0BD1 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x38] = code[0x2d5b:0x2d93] // @0BDF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0BE0: // Incoming jump from 0x0BA9, if stack[-1] // Inputs[8] // { // @0BE3 stack[-2] // @0BEF memory[0x00:0x40] // @0BF1 storage[keccak256(memory[0x00:0x40])] // @0C11 stack[-3] // @0C1B memory[0x40:0x60] // @0C1F stack[-1] // @0C44 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0C48 stack[-4] // } 0BE0 5B JUMPDEST 0BE1 60 PUSH1 0x00 0BE3 82 DUP3 0BE4 81 DUP2 0BE5 52 MSTORE 0BE6 60 PUSH1 0x12 0BE8 60 PUSH1 0x20 0BEA 52 MSTORE 0BEB 60 PUSH1 0x40 0BED 80 DUP1 0BEE 82 DUP3 0BEF 20 SHA3 0BF0 80 DUP1 0BF1 54 SLOAD 0BF2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C07 19 NOT 0C08 16 AND 0C09 60 PUSH1 0x01 0C0B 60 PUSH1 0x01 0C0D 60 PUSH1 0xa0 0C0F 1B SHL 0C10 03 SUB 0C11 87 DUP8 0C12 81 DUP2 0C13 16 AND 0C14 91 SWAP2 0C15 82 DUP3 0C16 17 OR 0C17 90 SWAP1 0C18 92 SWAP3 0C19 55 SSTORE 0C1A 91 SWAP2 0C1B 51 MLOAD 0C1C 85 DUP6 0C1D 93 SWAP4 0C1E 91 SWAP2 0C1F 85 DUP6 0C20 16 AND 0C21 91 SWAP2 0C22 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0C43 91 SWAP2 0C44 A4 LOG4 0C45 50 POP 0C46 50 POP 0C47 50 POP 0C48 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @0BE5 memory[0x00:0x20] = stack[-2] // @0BEA memory[0x20:0x40] = 0x12 // @0C19 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @0C44 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_0C49: // Incoming jump from 0x039A // Inputs[1] { @0C4A stack[-2] } 0C49 5B JUMPDEST 0C4A 81 DUP2 0C4B 80 DUP1 0C4C 15 ISZERO 0C4D 61 PUSH2 0x0c60 0C50 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C4A stack[0] = stack[-2] } // Block ends with conditional jump to 0x0c60, if !stack[-2] label_0C51: // Incoming jump from 0x0C50, if not !stack[-2] // Inputs[2] // { // @0C54 storage[0x05] // @0C5E msg.sender // } 0C51 50 POP 0C52 60 PUSH1 0x05 0C54 54 SLOAD 0C55 60 PUSH1 0x01 0C57 60 PUSH1 0x01 0C59 60 PUSH1 0xa0 0C5B 1B SHL 0C5C 03 SUB 0C5D 16 AND 0C5E 33 CALLER 0C5F 14 EQ 0C60 5B JUMPDEST 0C61 61 PUSH2 0x0c9b 0C64 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c9b, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] label_0C65: // Incoming jump from 0x0C64, if not stack[-1] // Incoming jump from 0x0C64, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] // Inputs[3] // { // @0C67 memory[0x40:0x60] // @0C95 memory[0x40:0x60] // @0C9A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C65 60 PUSH1 0x40 0C67 51 MLOAD 0C68 62 PUSH3 0x461bcd 0C6C 60 PUSH1 0xe5 0C6E 1B SHL 0C6F 81 DUP2 0C70 52 MSTORE 0C71 60 PUSH1 0x04 0C73 01 ADD 0C74 80 DUP1 0C75 80 DUP1 0C76 60 PUSH1 0x20 0C78 01 ADD 0C79 82 DUP3 0C7A 81 DUP2 0C7B 03 SUB 0C7C 82 DUP3 0C7D 52 MSTORE 0C7E 60 PUSH1 0x23 0C80 81 DUP2 0C81 52 MSTORE 0C82 60 PUSH1 0x20 0C84 01 ADD 0C85 80 DUP1 0C86 61 PUSH2 0x2d93 0C89 60 PUSH1 0x23 0C8B 91 SWAP2 0C8C 39 CODECOPY 0C8D 60 PUSH1 0x40 0C8F 01 ADD 0C90 91 SWAP2 0C91 50 POP 0C92 50 POP 0C93 60 PUSH1 0x40 0C95 51 MLOAD 0C96 80 DUP1 0C97 91 SWAP2 0C98 03 SUB 0C99 90 SWAP1 0C9A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0C70 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C7D memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0C81 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x23 // @0C8C memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x23] = code[0x2d93:0x2db6] // @0C9A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C9B: // Incoming jump from 0x0C64, if stack[-1] // Incoming jump from 0x0C64, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] // Inputs[1] { @0CA4 stack[-1] } 0C9B 5B JUMPDEST 0C9C 60 PUSH1 0x01 0C9E 60 PUSH1 0x01 0CA0 60 PUSH1 0xa0 0CA2 1B SHL 0CA3 03 SUB 0CA4 81 DUP2 0CA5 16 AND 0CA6 61 PUSH2 0x0cae 0CA9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cae, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0CAA: // Incoming jump from 0x0CA9, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0CAD memory[0x00:0x00] } 0CAA 60 PUSH1 0x00 0CAC 80 DUP1 0CAD FD *REVERT // Stack delta = +0 // Outputs[1] { @0CAD revert(memory[0x00:0x00]); } // Block terminates label_0CAE: // Incoming jump from 0x0CA9, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @0CB2 storage[0x05] // @0CD2 stack[-1] // @0CDD storage[0x01] // @0CE1 memory[0x40:0x60] // @0D0D memory[0x40:0x60] // @0D2B address((0x01 << 0xa0) - 0x01 & storage[0x01]).code.length // } 0CAE 5B JUMPDEST 0CAF 60 PUSH1 0x05 0CB1 80 DUP1 0CB2 54 SLOAD 0CB3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CC8 19 NOT 0CC9 16 AND 0CCA 60 PUSH1 0x01 0CCC 60 PUSH1 0x01 0CCE 60 PUSH1 0xa0 0CD0 1B SHL 0CD1 03 SUB 0CD2 83 DUP4 0CD3 81 DUP2 0CD4 16 AND 0CD5 91 SWAP2 0CD6 82 DUP3 0CD7 17 OR 0CD8 90 SWAP1 0CD9 92 SWAP3 0CDA 55 SSTORE 0CDB 60 PUSH1 0x01 0CDD 54 SLOAD 0CDE 60 PUSH1 0x40 0CE0 80 DUP1 0CE1 51 MLOAD 0CE2 7F PUSH32 0x9610ba5b00000000000000000000000000000000000000000000000000000000 0D03 81 DUP2 0D04 52 MSTORE 0D05 60 PUSH1 0x04 0D07 81 DUP2 0D08 01 ADD 0D09 93 SWAP4 0D0A 90 SWAP1 0D0B 93 SWAP4 0D0C 52 MSTORE 0D0D 51 MLOAD 0D0E 92 SWAP3 0D0F 16 AND 0D10 91 SWAP2 0D11 63 PUSH4 0x9610ba5b 0D16 91 SWAP2 0D17 60 PUSH1 0x24 0D19 80 DUP1 0D1A 82 DUP3 0D1B 01 ADD 0D1C 92 SWAP3 0D1D 60 PUSH1 0x00 0D1F 92 SWAP3 0D20 90 SWAP1 0D21 91 SWAP2 0D22 90 SWAP1 0D23 82 DUP3 0D24 90 SWAP1 0D25 03 SUB 0D26 01 ADD 0D27 81 DUP2 0D28 83 DUP4 0D29 87 DUP8 0D2A 80 DUP1 0D2B 3B EXTCODESIZE 0D2C 15 ISZERO 0D2D 80 DUP1 0D2E 15 ISZERO 0D2F 61 PUSH2 0x0d37 0D32 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @0CDA storage[0x05] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[0x05]) // @0D04 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x9610ba5b00000000000000000000000000000000000000000000000000000000 // @0D0C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0D10 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x01] // @0D16 stack[1] = 0x9610ba5b // @0D1C stack[2] = memory[0x40:0x60] + 0x24 // @0D1F stack[3] = 0x00 // @0D21 stack[4] = memory[0x40:0x60] // @0D26 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @0D27 stack[6] = memory[0x40:0x60] // @0D28 stack[7] = 0x00 // @0D29 stack[8] = (0x01 << 0xa0) - 0x01 & storage[0x01] // @0D2C stack[9] = !address((0x01 << 0xa0) - 0x01 & storage[0x01]).code.length // } // Block ends with conditional jump to 0x0d37, if !!address((0x01 << 0xa0) - 0x01 & storage[0x01]).code.length label_0D33: // Incoming jump from 0x0D32, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x01]).code.length // Inputs[1] { @0D36 memory[0x00:0x00] } 0D33 60 PUSH1 0x00 0D35 80 DUP1 0D36 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D36 revert(memory[0x00:0x00]); } // Block terminates label_0D37: // Incoming jump from 0x0D32, if !!address((0x01 << 0xa0) - 0x01 & storage[0x01]).code.length // Inputs[9] // { // @0D39 msg.gas // @0D3A address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0D3A stack[-2] // @0D3A stack[-4] // @0D3A stack[-7] // @0D3A stack[-3] // @0D3A stack[-6] // @0D3A stack[-5] // @0D3A memory[stack[-4]:stack[-4] + stack[-5]] // } 0D37 5B JUMPDEST 0D38 50 POP 0D39 5A GAS 0D3A F1 CALL 0D3B 15 ISZERO 0D3C 80 DUP1 0D3D 15 ISZERO 0D3E 61 PUSH2 0x0d4b 0D41 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0D3A memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0D3B stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x0d4b, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0D42: // Incoming jump from 0x0D41, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0D42 returndata.length // @0D46 returndata[0x00:0x00 + returndata.length] // @0D47 returndata.length // @0D4A memory[0x00:0x00 + returndata.length] // } 0D42 3D RETURNDATASIZE 0D43 60 PUSH1 0x00 0D45 80 DUP1 0D46 3E RETURNDATACOPY 0D47 3D RETURNDATASIZE 0D48 60 PUSH1 0x00 0D4A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0D46 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0D4A revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0D4B: // Incoming jump from 0x0D41, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @0D52 stack[-7] } 0D4B 5B JUMPDEST 0D4C 50 POP 0D4D 50 POP 0D4E 50 POP 0D4F 50 POP 0D50 50 POP 0D51 50 POP 0D52 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_0D53: // Incoming call from 0x03AF, returns to 0x03B0 // Inputs[2] // { // @0D56 storage[0x11] // @0D57 stack[-1] // } 0D53 5B JUMPDEST 0D54 60 PUSH1 0x11 0D56 54 SLOAD 0D57 81 DUP2 0D58 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D56 stack[0] = storage[0x11] } // Block ends with unconditional jump to stack[-1] label_0D59: // Incoming jump from 0x0D9D // Incoming jump from 0x03F7 // Inputs[3] // { // @0D5D stack[-1] // @0D5F stack[-3] // @0D60 stack[-2] // } 0D59 5B JUMPDEST 0D5A 61 PUSH2 0x0d65 0D5D 81 DUP2 0D5E 82 DUP3 0D5F 85 DUP6 0D60 85 DUP6 0D61 61 PUSH2 0x1a87 0D64 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0D5A stack[0] = 0x0d65 // @0D5D stack[1] = stack[-1] // @0D5E stack[2] = stack[-1] // @0D5F stack[3] = stack[-3] // @0D60 stack[4] = stack[-2] // } // Block ends with unconditional jump to 0x1a87 0D65 5B JUMPDEST 0D66 50 POP 0D67 50 POP 0D68 50 POP 0D69 56 *JUMP label_0D6A: // Incoming jump from 0x042D // Inputs[4] // { // @0D6E stack[-3] // @0D6F stack[-2] // @0D70 stack[-1] // @0D73 memory[0x40:0x60] // } 0D6A 5B JUMPDEST 0D6B 61 PUSH2 0x0d65 0D6E 83 DUP4 0D6F 83 DUP4 0D70 83 DUP4 0D71 60 PUSH1 0x40 0D73 51 MLOAD 0D74 80 DUP1 0D75 60 PUSH1 0x20 0D77 01 ADD 0D78 60 PUSH1 0x40 0D7A 52 MSTORE 0D7B 80 DUP1 0D7C 60 PUSH1 0x00 0D7E 81 DUP2 0D7F 52 MSTORE 0D80 50 POP 0D81 61 PUSH2 0x154f 0D84 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0D6B stack[0] = 0x0d65 // @0D6E stack[1] = stack[-3] // @0D6F stack[2] = stack[-2] // @0D70 stack[3] = stack[-1] // @0D73 stack[4] = memory[0x40:0x60] // @0D7A memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0D7F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x154f label_0D85: // Incoming jump from 0x0457 // Inputs[1] { @0D8B stack[-1] } 0D85 5B JUMPDEST 0D86 60 PUSH1 0x00 0D88 61 PUSH2 0x0d90 0D8B 82 DUP3 0D8C 61 PUSH2 0x0dda 0D8F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D86 stack[0] = 0x00 // @0D88 stack[1] = 0x0d90 // @0D8B stack[2] = stack[-1] // } // Block ends with call to 0x0dda, returns to 0x0D90 label_0D90: // Incoming return from call to 0x0DDA at 0x0D8F // Incoming return from call to 0x0DDA at 0x0D8F // Inputs[3] // { // @0D91 stack[-2] // @0D91 stack[-1] // @0D99 stack[-3] // } 0D90 5B JUMPDEST 0D91 90 SWAP1 0D92 50 POP 0D93 61 PUSH2 0x0d9e 0D96 81 DUP2 0D97 60 PUSH1 0x00 0D99 84 DUP5 0D9A 61 PUSH2 0x0d59 0D9D 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0D91 stack[-2] = stack[-1] // @0D93 stack[-1] = 0x0d9e // @0D96 stack[0] = stack[-1] // @0D97 stack[1] = 0x00 // @0D99 stack[2] = stack[-3] // } // Block ends with unconditional jump to 0x0d59 0D9E 5B JUMPDEST 0D9F 60 PUSH1 0x11 0DA1 54 SLOAD 0DA2 61 PUSH2 0x0db2 0DA5 90 SWAP1 0DA6 60 PUSH1 0x01 0DA8 63 PUSH4 0xffffffff 0DAD 61 PUSH2 0x1d2f 0DB0 16 AND 0DB1 56 *JUMP 0DB2 5B JUMPDEST 0DB3 60 PUSH1 0x11 0DB5 55 SSTORE 0DB6 50 POP 0DB7 60 PUSH1 0x00 0DB9 90 SWAP1 0DBA 81 DUP2 0DBB 52 MSTORE 0DBC 60 PUSH1 0x08 0DBE 60 PUSH1 0x20 0DC0 52 MSTORE 0DC1 60 PUSH1 0x40 0DC3 90 SWAP1 0DC4 20 SHA3 0DC5 80 DUP1 0DC6 54 SLOAD 0DC7 60 PUSH1 0xff 0DC9 19 NOT 0DCA 16 AND 0DCB 60 PUSH1 0x01 0DCD 17 OR 0DCE 90 SWAP1 0DCF 55 SSTORE 0DD0 56 *JUMP label_0DD1: // Incoming call from 0x046C, returns to 0x046D // Inputs[2] // { // @0DD4 storage[0x0e] // @0DD8 stack[-1] // } 0DD1 5B JUMPDEST 0DD2 60 PUSH1 0x0e 0DD4 54 SLOAD 0DD5 60 PUSH1 0xff 0DD7 16 AND 0DD8 81 DUP2 0DD9 56 *JUMP // Stack delta = +1 // Outputs[1] { @0DD7 stack[0] = 0xff & storage[0x0e] } // Block ends with unconditional jump to stack[-1] label_0DDA: // Incoming call from 0x1AFB, returns to 0x1AFC // Incoming call from 0x0D8F, returns to 0x0D90 // Incoming call from 0x250A, returns to 0x250B // Incoming call from 0x0ADA, returns to 0x0ADB // Incoming jump from 0x04AC // Incoming call from 0x0A1D, returns to 0x0A1E // Inputs[3] // { // @0DDD stack[-1] // @0DE8 memory[0x00:0x40] // @0DE9 storage[keccak256(memory[0x00:0x40])] // } 0DDA 5B JUMPDEST 0DDB 60 PUSH1 0x00 0DDD 81 DUP2 0DDE 81 DUP2 0DDF 52 MSTORE 0DE0 60 PUSH1 0x08 0DE2 60 PUSH1 0x20 0DE4 52 MSTORE 0DE5 60 PUSH1 0x40 0DE7 81 DUP2 0DE8 20 SHA3 0DE9 54 SLOAD 0DEA 60 PUSH1 0xff 0DEC 16 AND 0DED 15 ISZERO 0DEE 15 ISZERO 0DEF 60 PUSH1 0x01 0DF1 14 EQ 0DF2 15 ISZERO 0DF3 61 PUSH2 0x0e3a 0DF6 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0DDB stack[0] = 0x00 // @0DDF memory[0x00:0x20] = stack[-1] // @0DE4 memory[0x20:0x40] = 0x08 // } // Block ends with conditional jump to 0x0e3a, if !(0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])])) label_0DF7: // Incoming jump from 0x0DF6, if not !(0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])])) // Inputs[3] // { // @0DFA memory[0x40:0x60] // @0E30 memory[0x40:0x60] // @0E39 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0DF7 60 PUSH1 0x40 0DF9 80 DUP1 0DFA 51 MLOAD 0DFB 62 PUSH3 0x461bcd 0DFF 60 PUSH1 0xe5 0E01 1B SHL 0E02 81 DUP2 0E03 52 MSTORE 0E04 60 PUSH1 0x20 0E06 60 PUSH1 0x04 0E08 82 DUP3 0E09 01 ADD 0E0A 52 MSTORE 0E0B 60 PUSH1 0x14 0E0D 60 PUSH1 0x24 0E0F 82 DUP3 0E10 01 ADD 0E11 52 MSTORE 0E12 73 PUSH20 0x151bdad95b88191bd95cc81b9bdd08195e1a5cdd 0E27 60 PUSH1 0x62 0E29 1B SHL 0E2A 60 PUSH1 0x44 0E2C 82 DUP3 0E2D 01 ADD 0E2E 52 MSTORE 0E2F 90 SWAP1 0E30 51 MLOAD 0E31 90 SWAP1 0E32 81 DUP2 0E33 90 SWAP1 0E34 03 SUB 0E35 60 PUSH1 0x64 0E37 01 ADD 0E38 90 SWAP1 0E39 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0E03 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E0A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E11 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @0E2E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x151bdad95b88191bd95cc81b9bdd08195e1a5cdd << 0x62 // @0E39 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0E3A: // Incoming jump from 0x0DF6, if !(0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])])) // Inputs[3] // { // @0E3D stack[-2] // @0E48 memory[0x00:0x40] // @0E49 storage[keccak256(memory[0x00:0x40])] // } 0E3A 5B JUMPDEST 0E3B 60 PUSH1 0x00 0E3D 82 DUP3 0E3E 81 DUP2 0E3F 52 MSTORE 0E40 60 PUSH1 0x14 0E42 60 PUSH1 0x20 0E44 52 MSTORE 0E45 60 PUSH1 0x40 0E47 90 SWAP1 0E48 20 SHA3 0E49 54 SLOAD 0E4A 60 PUSH1 0x01 0E4C 60 PUSH1 0x01 0E4E 60 PUSH1 0xa0 0E50 1B SHL 0E51 03 SUB 0E52 16 AND 0E53 15 ISZERO 0E54 61 PUSH2 0x0e75 0E57 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0E3F memory[0x00:0x20] = stack[-2] // @0E44 memory[0x20:0x40] = 0x14 // } // Block ends with conditional jump to 0x0e75, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_0E58: // Incoming jump from 0x0E57, if not !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @0E5B stack[-2] // @0E66 memory[0x00:0x40] // @0E67 storage[keccak256(memory[0x00:0x40])] // } 0E58 50 POP 0E59 60 PUSH1 0x00 0E5B 81 DUP2 0E5C 81 DUP2 0E5D 52 MSTORE 0E5E 60 PUSH1 0x14 0E60 60 PUSH1 0x20 0E62 52 MSTORE 0E63 60 PUSH1 0x40 0E65 90 SWAP1 0E66 20 SHA3 0E67 54 SLOAD 0E68 60 PUSH1 0x01 0E6A 60 PUSH1 0x01 0E6C 60 PUSH1 0xa0 0E6E 1B SHL 0E6F 03 SUB 0E70 16 AND 0E71 61 PUSH2 0x0970 0E74 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0E5D memory[0x00:0x20] = stack[-2] // @0E62 memory[0x20:0x40] = 0x14 // @0E70 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x0970 label_0E75: // Incoming jump from 0x0E57, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0E7B stack[-2] } 0E75 5B JUMPDEST 0E76 60 PUSH1 0x00 0E78 61 PUSH2 0x0e80 0E7B 83 DUP4 0E7C 61 PUSH2 0x1d78 0E7F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E76 stack[0] = 0x00 // @0E78 stack[1] = 0x0e80 // @0E7B stack[2] = stack[-2] // } // Block ends with call to 0x1d78, returns to 0x0E80 label_0E80: // Incoming return from call to 0x1D78 at 0x0E7F // Inputs[3] // { // @0E82 stack[-4] // @0E82 stack[-2] // @0E83 stack[-5] // } 0E80 5B JUMPDEST 0E81 50 POP 0E82 91 SWAP2 0E83 92 SWAP3 0E84 50 POP 0E85 50 POP 0E86 50 POP 0E87 60 PUSH1 0x01 0E89 60 PUSH1 0x01 0E8B 60 PUSH1 0xa0 0E8D 1B SHL 0E8E 03 SUB 0E8F 81 DUP2 0E90 16 AND 0E91 61 PUSH2 0x0ed8 0E94 57 *JUMPI // Stack delta = -4 // Outputs[1] { @0E83 stack[-5] = stack[-4] } // Block ends with conditional jump to 0x0ed8, if stack[-4] & (0x01 << 0xa0) - 0x01 label_0E95: // Incoming jump from 0x0E94, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0E98 memory[0x40:0x60] // @0ECE memory[0x40:0x60] // @0ED7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0E95 60 PUSH1 0x40 0E97 80 DUP1 0E98 51 MLOAD 0E99 62 PUSH3 0x461bcd 0E9D 60 PUSH1 0xe5 0E9F 1B SHL 0EA0 81 DUP2 0EA1 52 MSTORE 0EA2 60 PUSH1 0x20 0EA4 60 PUSH1 0x04 0EA6 82 DUP3 0EA7 01 ADD 0EA8 52 MSTORE 0EA9 60 PUSH1 0x14 0EAB 60 PUSH1 0x24 0EAD 82 DUP3 0EAE 01 ADD 0EAF 52 MSTORE 0EB0 73 PUSH20 0x151bdad95b88191bd95cc81b9bdd08195e1a5cdd 0EC5 60 PUSH1 0x62 0EC7 1B SHL 0EC8 60 PUSH1 0x44 0ECA 82 DUP3 0ECB 01 ADD 0ECC 52 MSTORE 0ECD 90 SWAP1 0ECE 51 MLOAD 0ECF 90 SWAP1 0ED0 81 DUP2 0ED1 90 SWAP1 0ED2 03 SUB 0ED3 60 PUSH1 0x64 0ED5 01 ADD 0ED6 90 SWAP1 0ED7 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0EA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EA8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0EAF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @0ECC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x151bdad95b88191bd95cc81b9bdd08195e1a5cdd << 0x62 // @0ED7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0ED8: // Incoming jump from 0x0E94, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0ED9 stack[-1] // @0ED9 stack[-4] // @0EDA stack[-3] // } 0ED8 5B JUMPDEST 0ED9 92 SWAP3 0EDA 91 SWAP2 0EDB 50 POP 0EDC 50 POP 0EDD 56 *JUMP // Stack delta = -3 // Outputs[1] { @0ED9 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0EDE: // Incoming jump from 0x04DF // Inputs[4] // { // @0EE6 stack[-1] // @0EEC memory[0x00:0x40] // @0EED storage[keccak256(memory[0x00:0x40])] // @0EEE stack[-2] // } 0EDE 5B JUMPDEST 0EDF 60 PUSH1 0x15 0EE1 60 PUSH1 0x20 0EE3 52 MSTORE 0EE4 60 PUSH1 0x00 0EE6 90 SWAP1 0EE7 81 DUP2 0EE8 52 MSTORE 0EE9 60 PUSH1 0x40 0EEB 90 SWAP1 0EEC 20 SHA3 0EED 54 SLOAD 0EEE 81 DUP2 0EEF 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0EE3 memory[0x20:0x40] = 0x15 // @0EE8 memory[0x00:0x20] = stack[-1] // @0EED stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0EF0: // Incoming call from 0x04F4, returns to 0x01ED // Inputs[2] // { // @0EF3 storage[0x05] // @0EFD msg.sender // } 0EF0 5B JUMPDEST 0EF1 60 PUSH1 0x05 0EF3 54 SLOAD 0EF4 60 PUSH1 0x01 0EF6 60 PUSH1 0x01 0EF8 60 PUSH1 0xa0 0EFA 1B SHL 0EFB 03 SUB 0EFC 16 AND 0EFD 33 CALLER 0EFE 14 EQ 0EFF 61 PUSH2 0x0f4f 0F02 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f4f, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] label_0F03: // Incoming jump from 0x0F02, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] // Inputs[3] // { // @0F06 memory[0x40:0x60] // @0F45 memory[0x40:0x60] // @0F4E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0F03 60 PUSH1 0x40 0F05 80 DUP1 0F06 51 MLOAD 0F07 62 PUSH3 0x461bcd 0F0B 60 PUSH1 0xe5 0F0D 1B SHL 0F0E 81 DUP2 0F0F 52 MSTORE 0F10 60 PUSH1 0x20 0F12 60 PUSH1 0x04 0F14 82 DUP3 0F15 01 ADD 0F16 52 MSTORE 0F17 60 PUSH1 0x12 0F19 60 PUSH1 0x24 0F1B 82 DUP3 0F1C 01 ADD 0F1D 52 MSTORE 0F1E 7F PUSH32 0x53656e646572206e6f742063726561746f720000000000000000000000000000 0F3F 60 PUSH1 0x44 0F41 82 DUP3 0F42 01 ADD 0F43 52 MSTORE 0F44 90 SWAP1 0F45 51 MLOAD 0F46 90 SWAP1 0F47 81 DUP2 0F48 90 SWAP1 0F49 03 SUB 0F4A 60 PUSH1 0x64 0F4C 01 ADD 0F4D 90 SWAP1 0F4E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0F0F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F16 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F1D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @0F43 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53656e646572206e6f742063726561746f720000000000000000000000000000 // @0F4E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0F4F: // Incoming jump from 0x0F02, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] // Inputs[2] // { // @0F53 storage[0x10] // @0F5A stack[-1] // } 0F4F 5B JUMPDEST 0F50 60 PUSH1 0x10 0F52 80 DUP1 0F53 54 SLOAD 0F54 60 PUSH1 0xff 0F56 19 NOT 0F57 16 AND 0F58 90 SWAP1 0F59 55 SSTORE 0F5A 56 *JUMP // Stack delta = -1 // Outputs[1] { @0F59 storage[0x10] = ~0xff & storage[0x10] } // Block ends with unconditional jump to stack[-1] label_0F5B: // Incoming jump from 0x0622 // Inputs[2] // { // @0F5C stack[-6] // @0F5D stack[-4] // } 0F5B 5B JUMPDEST 0F5C 85 DUP6 0F5D 84 DUP5 0F5E 14 EQ 0F5F 80 DUP1 0F60 15 ISZERO 0F61 61 PUSH2 0x0f69 0F64 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0F5E stack[0] = stack[-4] == stack[-6] } // Block ends with conditional jump to 0x0f69, if !(stack[-4] == stack[-6]) label_0F65: // Incoming jump from 0x0F64, if not !(stack[-4] == stack[-6]) // Inputs[2] // { // @0F66 stack[-2] // @0F67 stack[-5] // } 0F65 50 POP 0F66 80 DUP1 0F67 84 DUP5 0F68 14 EQ 0F69 5B JUMPDEST 0F6A 61 PUSH2 0x0fba 0F6D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0fba, if stack[-5] == stack[-2] label_0F6E: // Incoming jump from 0x0F6D, if not stack[-5] == stack[-2] // Incoming jump from 0x0F6D, if not stack[-1] // Inputs[3] // { // @0F71 memory[0x40:0x60] // @0FB0 memory[0x40:0x60] // @0FB9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0F6E 60 PUSH1 0x40 0F70 80 DUP1 0F71 51 MLOAD 0F72 62 PUSH3 0x461bcd 0F76 60 PUSH1 0xe5 0F78 1B SHL 0F79 81 DUP2 0F7A 52 MSTORE 0F7B 60 PUSH1 0x20 0F7D 60 PUSH1 0x04 0F7F 82 DUP3 0F80 01 ADD 0F81 52 MSTORE 0F82 60 PUSH1 0x17 0F84 60 PUSH1 0x24 0F86 82 DUP3 0F87 01 ADD 0F88 52 MSTORE 0F89 7F PUSH32 0x4172726179206c656e677468206d757374206d61746368000000000000000000 0FAA 60 PUSH1 0x44 0FAC 82 DUP3 0FAD 01 ADD 0FAE 52 MSTORE 0FAF 90 SWAP1 0FB0 51 MLOAD 0FB1 90 SWAP1 0FB2 81 DUP2 0FB3 90 SWAP1 0FB4 03 SUB 0FB5 60 PUSH1 0x64 0FB7 01 ADD 0FB8 90 SWAP1 0FB9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0F7A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F81 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F88 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x17 // @0FAE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4172726179206c656e677468206d757374206d61746368000000000000000000 // @0FB9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0FBA: // Incoming jump from 0x0F6D, if stack[-5] == stack[-2] // Incoming jump from 0x0F6D, if stack[-1] // Inputs[1] { @0FBE stack[-6] } 0FBA 5B JUMPDEST 0FBB 60 PUSH1 0x00 0FBD 5B JUMPDEST 0FBE 86 DUP7 0FBF 81 DUP2 0FC0 10 LT 0FC1 15 ISZERO 0FC2 61 PUSH2 0x1018 0FC5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0FBB stack[0] = 0x00 } // Block ends with conditional jump to 0x1018, if !(0x00 < stack[-6]) label_0FC6: // Incoming jump from 0x0FC5, if not !(0x00 < stack[-6]) // Inputs[3] // { // @0FC9 stack[-8] // @0FCA stack[-7] // @0FCB stack[-1] // } 0FC6 61 PUSH2 0x1010 0FC9 88 DUP9 0FCA 88 DUP9 0FCB 83 DUP4 0FCC 81 DUP2 0FCD 81 DUP2 0FCE 10 LT 0FCF 61 PUSH2 0x0fd4 0FD2 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0FC6 stack[0] = 0x1010 // @0FC9 stack[1] = stack[-8] // @0FCA stack[2] = stack[-7] // @0FCB stack[3] = stack[-1] // } // Block ends with conditional jump to 0x0fd4, if stack[-1] < stack[-7] label_0FD3: // Incoming jump from 0x0FD2, if not stack[-1] < stack[-7] 0FD3 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0FD3 assert(); } // Block terminates label_0FD4: // Incoming jump from 0x0FD2, if stack[-1] < stack[-7] // Inputs[7] // { // @0FD5 stack[-1] // @0FD5 stack[-2] // @0FDA stack[-3] // @0FDB msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0FDC stack[-10] // @0FDD stack[-9] // @0FDE stack[-5] // } 0FD4 5B JUMPDEST 0FD5 90 SWAP1 0FD6 50 POP 0FD7 60 PUSH1 0x20 0FD9 02 MUL 0FDA 01 ADD 0FDB 35 CALLDATALOAD 0FDC 87 DUP8 0FDD 87 DUP8 0FDE 84 DUP5 0FDF 81 DUP2 0FE0 81 DUP2 0FE1 10 LT 0FE2 61 PUSH2 0x0fe7 0FE5 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0FDB stack[-3] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0FDC stack[-2] = stack[-10] // @0FDD stack[-1] = stack[-9] // @0FDE stack[0] = stack[-5] // } // Block ends with conditional jump to 0x0fe7, if stack[-5] < stack[-9] label_0FE6: // Incoming jump from 0x0FE5, if not stack[-5] < stack[-9] 0FE6 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0FE6 assert(); } // Block terminates label_0FE7: // Incoming jump from 0x0FE5, if stack[-5] < stack[-9] // Inputs[8] // { // @0FE8 stack[-1] // @0FE8 stack[-2] // @0FED stack[-3] // @0FEE msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0FEF stack[-9] // @0FF0 stack[-8] // @0FF1 stack[-7] // @0FF2 stack[-6] // } 0FE7 5B JUMPDEST 0FE8 90 SWAP1 0FE9 50 POP 0FEA 60 PUSH1 0x20 0FEC 02 MUL 0FED 01 ADD 0FEE 35 CALLDATALOAD 0FEF 86 DUP7 0FF0 86 DUP7 0FF1 86 DUP7 0FF2 86 DUP7 0FF3 81 DUP2 0FF4 81 DUP2 0FF5 10 LT 0FF6 61 PUSH2 0x0ffb 0FF9 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @0FEE stack[-3] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0FEF stack[-2] = stack[-9] // @0FF0 stack[-1] = stack[-8] // @0FF1 stack[0] = stack[-7] // @0FF2 stack[1] = stack[-6] // } // Block ends with conditional jump to 0x0ffb, if stack[-6] < stack[-7] label_0FFA: // Incoming jump from 0x0FF9, if not stack[-6] < stack[-7] 0FFA FE *ASSERT // Stack delta = +0 // Outputs[1] { @0FFA assert(); } // Block terminates label_0FFB: // Incoming jump from 0x0FF9, if stack[-6] < stack[-7] // Inputs[4] // { // @0FFC stack[-1] // @0FFC stack[-2] // @1001 stack[-3] // @1002 msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // } 0FFB 5B JUMPDEST 0FFC 90 SWAP1 0FFD 50 POP 0FFE 60 PUSH1 0x20 1000 02 MUL 1001 01 ADD 1002 35 CALLDATALOAD 1003 60 PUSH1 0x01 1005 60 PUSH1 0x01 1007 60 PUSH1 0xa0 1009 1B SHL 100A 03 SUB 100B 16 AND 100C 61 PUSH2 0x0928 100F 56 *JUMP // Stack delta = -2 // Outputs[1] { @100B stack[-3] = (0x01 << 0xa0) - 0x01 & msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] } // Block ends with unconditional jump to 0x0928 1010 5B JUMPDEST 1011 60 PUSH1 0x01 1013 01 ADD 1014 61 PUSH2 0x0fbd 1017 56 *JUMP label_1018: // Incoming jump from 0x141C // Incoming jump from 0x0FC5, if !(0x00 < stack[-6]) // Inputs[1] { @1021 stack[-9] } 1018 5B JUMPDEST 1019 50 POP 101A 50 POP 101B 50 POP 101C 50 POP 101D 50 POP 101E 50 POP 101F 50 POP 1020 50 POP 1021 56 *JUMP // Stack delta = -9 // Block ends with unconditional jump to stack[-9] label_1022: // Incoming call from 0x0637, returns to 0x0295 // Inputs[2] // { // @1026 storage[0x04] // @102A memory[0x40:0x60] // } 1022 5B JUMPDEST 1023 60 PUSH1 0x04 1025 80 DUP1 1026 54 SLOAD 1027 60 PUSH1 0x40 1029 80 DUP1 102A 51 MLOAD 102B 60 PUSH1 0x20 102D 60 PUSH1 0x02 102F 60 PUSH1 0x01 1031 85 DUP6 1032 16 AND 1033 15 ISZERO 1034 61 PUSH2 0x0100 1037 02 MUL 1038 60 PUSH1 0x00 103A 19 NOT 103B 01 ADD 103C 90 SWAP1 103D 94 SWAP5 103E 16 AND 103F 93 SWAP4 1040 90 SWAP1 1041 93 SWAP4 1042 04 DIV 1043 60 PUSH1 0x1f 1045 81 DUP2 1046 01 ADD 1047 84 DUP5 1048 90 SWAP1 1049 04 DIV 104A 84 DUP5 104B 02 MUL 104C 82 DUP3 104D 01 ADD 104E 84 DUP5 104F 01 ADD 1050 90 SWAP1 1051 92 SWAP3 1052 52 MSTORE 1053 81 DUP2 1054 81 DUP2 1055 52 MSTORE 1056 92 SWAP3 1057 91 SWAP2 1058 83 DUP4 1059 01 ADD 105A 82 DUP3 105B 82 DUP3 105C 80 DUP1 105D 15 ISZERO 105E 61 PUSH2 0x0a0a 1061 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @1051 stack[2] = (storage[0x04] & ~0x00 + 0x0100 * !(storage[0x04] & 0x01)) / 0x02 // @1052 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x04] & ~0x00 + 0x0100 * !(storage[0x04] & 0x01)) / 0x02 + 0x1f) / 0x20) // @1055 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x04] & ~0x00 + 0x0100 * !(storage[0x04] & 0x01)) / 0x02 // @1056 stack[0] = memory[0x40:0x60] // @1057 stack[1] = 0x04 // @1059 stack[3] = memory[0x40:0x60] + 0x20 // @105A stack[4] = 0x04 // @105B stack[5] = (storage[0x04] & ~0x00 + 0x0100 * !(storage[0x04] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x0a0a, if !((storage[0x04] & ~0x00 + 0x0100 * !(storage[0x04] & 0x01)) / 0x02) label_1062: // Incoming jump from 0x1061, if not !((storage[0x04] & ~0x00 + 0x0100 * !(storage[0x04] & 0x01)) / 0x02) // Inputs[1] { @1062 stack[-1] } 1062 80 DUP1 1063 60 PUSH1 0x1f 1065 10 LT 1066 61 PUSH2 0x09df 1069 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09df, if 0x1f < stack[-1] label_106A: // Incoming jump from 0x1069, if not 0x1f < stack[-1] // Inputs[4] // { // @106E stack[-2] // @106F storage[stack[-2]] // @1072 stack[-3] // @1074 stack[-1] // } 106A 61 PUSH2 0x0100 106D 80 DUP1 106E 83 DUP4 106F 54 SLOAD 1070 04 DIV 1071 02 MUL 1072 83 DUP4 1073 52 MSTORE 1074 91 SWAP2 1075 60 PUSH1 0x20 1077 01 ADD 1078 91 SWAP2 1079 61 PUSH2 0x0a0a 107C 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1073 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1078 stack[-1] = stack[-1] // @1078 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0a0a label_107D: // Incoming call from 0x064C, returns to 0x0264 // Inputs[2] // { // @1080 storage[0x06] // @108A stack[-1] // } 107D 5B JUMPDEST 107E 60 PUSH1 0x06 1080 54 SLOAD 1081 60 PUSH1 0x01 1083 60 PUSH1 0x01 1085 60 PUSH1 0xa0 1087 1B SHL 1088 03 SUB 1089 16 AND 108A 81 DUP2 108B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1089 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x06] } // Block ends with unconditional jump to stack[-1] label_108C: // Incoming jump from 0x06E5 // Inputs[1] { @108F stack[-5] } 108C 5B JUMPDEST 108D 60 PUSH1 0x00 108F 85 DUP6 1090 11 GT 1091 61 PUSH2 0x10e1 1094 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10e1, if stack[-5] > 0x00 label_1095: // Incoming jump from 0x1094, if not stack[-5] > 0x00 // Inputs[3] // { // @1098 memory[0x40:0x60] // @10D7 memory[0x40:0x60] // @10E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1095 60 PUSH1 0x40 1097 80 DUP1 1098 51 MLOAD 1099 62 PUSH3 0x461bcd 109D 60 PUSH1 0xe5 109F 1B SHL 10A0 81 DUP2 10A1 52 MSTORE 10A2 60 PUSH1 0x20 10A4 60 PUSH1 0x04 10A6 82 DUP3 10A7 01 ADD 10A8 52 MSTORE 10A9 60 PUSH1 0x1d 10AB 60 PUSH1 0x24 10AD 82 DUP3 10AE 01 ADD 10AF 52 MSTORE 10B0 7F PUSH32 0x416d6f756e74206d7573742062652067726561746572207468616e2030000000 10D1 60 PUSH1 0x44 10D3 82 DUP3 10D4 01 ADD 10D5 52 MSTORE 10D6 90 SWAP1 10D7 51 MLOAD 10D8 90 SWAP1 10D9 81 DUP2 10DA 90 SWAP1 10DB 03 SUB 10DC 60 PUSH1 0x64 10DE 01 ADD 10DF 90 SWAP1 10E0 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @10A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10A8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10AF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1d // @10D5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416d6f756e74206d7573742062652067726561746572207468616e2030000000 // @10E0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_10E1: // Incoming jump from 0x1094, if stack[-5] > 0x00 // Inputs[2] // { // @10E4 storage[0x05] // @10EE msg.sender // } 10E1 5B JUMPDEST 10E2 60 PUSH1 0x05 10E4 54 SLOAD 10E5 60 PUSH1 0x01 10E7 60 PUSH1 0x01 10E9 60 PUSH1 0xa0 10EB 1B SHL 10EC 03 SUB 10ED 16 AND 10EE 33 CALLER 10EF 14 EQ 10F0 80 DUP1 10F1 61 PUSH2 0x110b 10F4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @10EF stack[0] = msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] } // Block ends with conditional jump to 0x110b, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] label_10F5: // Incoming jump from 0x10F4, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] // Inputs[2] // { // @10F8 storage[0x05] // @1106 msg.sender // } 10F5 50 POP 10F6 60 PUSH1 0x05 10F8 54 SLOAD 10F9 61 PUSH2 0x110b 10FC 90 SWAP1 10FD 60 PUSH1 0x01 10FF 60 PUSH1 0x01 1101 60 PUSH1 0xa0 1103 1B SHL 1104 03 SUB 1105 16 AND 1106 33 CALLER 1107 61 PUSH2 0x1a59 110A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @10FC stack[-1] = 0x110b // @1105 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x05] // @1106 stack[1] = msg.sender // } // Block ends with call to 0x1a59, returns to 0x110B label_110B: // Incoming return from call to 0x1A59 at 0x110A // Incoming jump from 0x10F4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] // Inputs[1] { @110F stack[-1] } 110B 5B JUMPDEST 110C 61 PUSH2 0x1146 110F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1146, if stack[-1] label_1110: // Incoming jump from 0x110F, if not stack[-1] // Inputs[3] // { // @1112 memory[0x40:0x60] // @1140 memory[0x40:0x60] // @1145 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1110 60 PUSH1 0x40 1112 51 MLOAD 1113 62 PUSH3 0x461bcd 1117 60 PUSH1 0xe5 1119 1B SHL 111A 81 DUP2 111B 52 MSTORE 111C 60 PUSH1 0x04 111E 01 ADD 111F 80 DUP1 1120 80 DUP1 1121 60 PUSH1 0x20 1123 01 ADD 1124 82 DUP3 1125 81 DUP2 1126 03 SUB 1127 82 DUP3 1128 52 MSTORE 1129 60 PUSH1 0x22 112B 81 DUP2 112C 52 MSTORE 112D 60 PUSH1 0x20 112F 01 ADD 1130 80 DUP1 1131 61 PUSH2 0x2d0d 1134 60 PUSH1 0x22 1136 91 SWAP2 1137 39 CODECOPY 1138 60 PUSH1 0x40 113A 01 ADD 113B 91 SWAP2 113C 50 POP 113D 50 POP 113E 60 PUSH1 0x40 1140 51 MLOAD 1141 80 DUP1 1142 91 SWAP2 1143 03 SUB 1144 90 SWAP1 1145 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @111B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1128 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @112C memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x22 // @1137 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x22] = code[0x2d0d:0x2d2f] // @1145 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1146: // Incoming jump from 0x110F, if stack[-1] // Inputs[13] // { // @1149 storage[0x02] // @114D memory[0x40:0x60] // @117C stack[-5] // @1183 stack[-3] // @1186 msg.sender // @1192 memory[0x40:0x60] // @11A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @11AA memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @11E8 stack[-1] // @11FE stack[-2] // @120F msg.data[stack[-2]:stack[-2] + stack[-1]] // @1232 memory[0x40:0x60] // @123B address(storage[0x02] & (0x01 << 0xa0) - 0x01).code.length // } 1146 5B JUMPDEST 1147 60 PUSH1 0x02 1149 54 SLOAD 114A 60 PUSH1 0x40 114C 80 DUP1 114D 51 MLOAD 114E 7F PUSH32 0x4d494e5400000000000000000000000000000000000000000000000000000000 116F 60 PUSH1 0x20 1171 80 DUP1 1172 83 DUP4 1173 01 ADD 1174 91 SWAP2 1175 90 SWAP1 1176 91 SWAP2 1177 52 MSTORE 1178 60 PUSH1 0x24 117A 82 DUP3 117B 01 ADD 117C 89 DUP10 117D 90 SWAP1 117E 52 MSTORE 117F 60 PUSH1 0x44 1181 82 DUP3 1182 01 ADD 1183 87 DUP8 1184 90 SWAP1 1185 52 MSTORE 1186 33 CALLER 1187 60 PUSH1 0x60 1189 90 SWAP1 118A 81 DUP2 118B 1B SHL 118C 60 PUSH1 0x64 118E 84 DUP5 118F 01 ADD 1190 52 MSTORE 1191 83 DUP4 1192 51 MLOAD 1193 60 PUSH1 0x58 1195 81 DUP2 1196 85 DUP6 1197 03 SUB 1198 01 ADD 1199 81 DUP2 119A 52 MSTORE 119B 60 PUSH1 0x78 119D 84 DUP5 119E 01 ADD 119F 94 SWAP5 11A0 85 DUP6 11A1 90 SWAP1 11A2 52 MSTORE 11A3 80 DUP1 11A4 51 MLOAD 11A5 92 SWAP3 11A6 01 ADD 11A7 91 SWAP2 11A8 90 SWAP1 11A9 91 SWAP2 11AA 20 SHA3 11AB 7F PUSH32 0x93bba32b00000000000000000000000000000000000000000000000000000000 11CC 90 SWAP1 11CD 93 SWAP4 11CE 52 MSTORE 11CF 60 PUSH1 0x7c 11D1 82 DUP3 11D2 01 ADD 11D3 83 DUP4 11D4 81 DUP2 11D5 52 MSTORE 11D6 60 PUSH1 0xbc 11D8 83 DUP4 11D9 01 ADD 11DA 88 DUP9 11DB 90 SWAP1 11DC 52 MSTORE 11DD 60 PUSH1 0x9c 11DF 83 DUP4 11E0 01 ADD 11E1 91 SWAP2 11E2 82 DUP3 11E3 52 MSTORE 11E4 60 PUSH1 0xdc 11E6 83 DUP4 11E7 01 ADD 11E8 86 DUP7 11E9 90 SWAP1 11EA 52 MSTORE 11EB 60 PUSH1 0x01 11ED 60 PUSH1 0x01 11EF 60 PUSH1 0xa0 11F1 1B SHL 11F2 03 SUB 11F3 90 SWAP1 11F4 94 SWAP5 11F5 16 AND 11F6 93 SWAP4 11F7 63 PUSH4 0x93bba32b 11FC 93 SWAP4 11FD 92 SWAP3 11FE 87 DUP8 11FF 92 SWAP3 1200 87 DUP8 1201 92 SWAP3 1202 8A DUP11 1203 92 SWAP3 1204 90 SWAP1 1205 91 SWAP2 1206 90 SWAP1 1207 60 PUSH1 0xfc 1209 01 ADD 120A 85 DUP6 120B 85 DUP6 120C 80 DUP1 120D 82 DUP3 120E 84 DUP5 120F 37 CALLDATACOPY 1210 60 PUSH1 0x00 1212 81 DUP2 1213 84 DUP5 1214 01 ADD 1215 52 MSTORE 1216 60 PUSH1 0x1f 1218 19 NOT 1219 60 PUSH1 0x1f 121B 82 DUP3 121C 01 ADD 121D 16 AND 121E 90 SWAP1 121F 50 POP 1220 80 DUP1 1221 83 DUP4 1222 01 ADD 1223 92 SWAP3 1224 50 POP 1225 50 POP 1226 50 POP 1227 95 SWAP6 1228 50 POP 1229 50 POP 122A 50 POP 122B 50 POP 122C 50 POP 122D 50 POP 122E 60 PUSH1 0x00 1230 60 PUSH1 0x40 1232 51 MLOAD 1233 80 DUP1 1234 83 DUP4 1235 03 SUB 1236 81 DUP2 1237 60 PUSH1 0x00 1239 87 DUP8 123A 80 DUP1 123B 3B EXTCODESIZE 123C 15 ISZERO 123D 80 DUP1 123E 15 ISZERO 123F 61 PUSH2 0x1247 1242 57 *JUMPI // Stack delta = +10 // Outputs[23] // { // @1177 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x4d494e5400000000000000000000000000000000000000000000000000000000 // @117E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-5] // @1185 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-3] // @1190 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = msg.sender << 0x60 // @119A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = memory[0x40:0x60] - memory[0x40:0x60] + 0x58 // @11A2 memory[0x40:0x60] = memory[0x40:0x60] + 0x78 // @11CE memory[memory[0x40:0x60] + 0x78:memory[0x40:0x60] + 0x78 + 0x20] = 0x93bba32b00000000000000000000000000000000000000000000000000000000 // @11D5 memory[memory[0x40:0x60] + 0x7c:memory[0x40:0x60] + 0x7c + 0x20] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @11DC memory[memory[0x40:0x60] + 0xbc:memory[0x40:0x60] + 0xbc + 0x20] = stack[-3] // @11E3 memory[memory[0x40:0x60] + 0x9c:memory[0x40:0x60] + 0x9c + 0x20] = 0x60 // @11EA memory[memory[0x40:0x60] + 0xdc:memory[0x40:0x60] + 0xdc + 0x20] = stack[-1] // @11F6 stack[0] = storage[0x02] & (0x01 << 0xa0) - 0x01 // @11FC stack[1] = 0x93bba32b // @120F memory[0xfc + memory[0x40:0x60]:0xfc + memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]] // @1215 memory[0xfc + memory[0x40:0x60] + stack[-1]:0xfc + memory[0x40:0x60] + stack[-1] + 0x20] = 0x00 // @1227 stack[2] = 0xfc + memory[0x40:0x60] + (stack[-1] + 0x1f & ~0x1f) // @122E stack[3] = 0x00 // @1232 stack[4] = memory[0x40:0x60] // @1235 stack[5] = (0xfc + memory[0x40:0x60] + (stack[-1] + 0x1f & ~0x1f)) - memory[0x40:0x60] // @1236 stack[6] = memory[0x40:0x60] // @1237 stack[7] = 0x00 // @1239 stack[8] = storage[0x02] & (0x01 << 0xa0) - 0x01 // @123C stack[9] = !address(storage[0x02] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x1247, if !!address(storage[0x02] & (0x01 << 0xa0) - 0x01).code.length label_1243: // Incoming jump from 0x1242, if not !!address(storage[0x02] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @1246 memory[0x00:0x00] } 1243 60 PUSH1 0x00 1245 80 DUP1 1246 FD *REVERT // Stack delta = +0 // Outputs[1] { @1246 revert(memory[0x00:0x00]); } // Block terminates label_1247: // Incoming jump from 0x1242, if !!address(storage[0x02] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @1249 msg.gas // @124A stack[-7] // @124A stack[-2] // @124A stack[-5] // @124A address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @124A stack[-6] // @124A stack[-4] // @124A stack[-3] // @124A memory[stack[-4]:stack[-4] + stack[-5]] // } 1247 5B JUMPDEST 1248 50 POP 1249 5A GAS 124A F1 CALL 124B 15 ISZERO 124C 80 DUP1 124D 15 ISZERO 124E 61 PUSH2 0x125b 1251 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @124A memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @124B stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x125b, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1252: // Incoming jump from 0x1251, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1252 returndata.length // @1256 returndata[0x00:0x00 + returndata.length] // @1257 returndata.length // @125A memory[0x00:0x00 + returndata.length] // } 1252 3D RETURNDATASIZE 1253 60 PUSH1 0x00 1255 80 DUP1 1256 3E RETURNDATACOPY 1257 3D RETURNDATASIZE 1258 60 PUSH1 0x00 125A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1256 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @125A revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_125B: // Incoming jump from 0x1251, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[3] // { // @1260 storage[0x07] // @1263 stack[-4] // @1268 stack[-3] // } 125B 5B JUMPDEST 125C 50 POP 125D 50 POP 125E 60 PUSH1 0x07 1260 54 SLOAD 1261 60 PUSH1 0x00 1263 92 SWAP3 1264 50 POP 1265 61 PUSH2 0x1276 1268 91 SWAP2 1269 50 POP 126A 60 PUSH1 0x01 126C 63 PUSH4 0xffffffff 1271 61 PUSH2 0x1f91 1274 16 AND 1275 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1260 stack[-2] = storage[0x07] // @1263 stack[-4] = 0x00 // @1268 stack[-3] = 0x1276 // @126A stack[-1] = 0x01 // } // Block ends with call to 0x1f91 & 0xffffffff, returns to 0x1276 label_1276: // Incoming return from call to 0x1F91 at 0x1275 // Inputs[4] // { // @1277 stack[-1] // @1277 stack[-2] // @127E stack[-7] // @1281 storage[0x07] // } 1276 5B JUMPDEST 1277 90 SWAP1 1278 50 POP 1279 60 PUSH1 0x00 127B 61 PUSH2 0x128f 127E 87 DUP8 127F 60 PUSH1 0x07 1281 54 SLOAD 1282 61 PUSH2 0x1f91 1285 90 SWAP1 1286 91 SWAP2 1287 90 SWAP1 1288 63 PUSH4 0xffffffff 128D 16 AND 128E 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1277 stack[-2] = stack[-1] // @1279 stack[-1] = 0x00 // @127B stack[0] = 0x128f // @1286 stack[1] = storage[0x07] // @1287 stack[2] = stack[-7] // } // Block ends with call to 0xffffffff & 0x1f91, returns to 0x128F label_128F: // Incoming return from call to 0x1F91 at 0x128E // Inputs[3] // { // @1292 stack[-1] // @1295 stack[-2] // @129C stack[-3] // } 128F 5B JUMPDEST 1290 60 PUSH1 0x07 1292 81 DUP2 1293 90 SWAP1 1294 55 SSTORE 1295 90 SWAP1 1296 50 POP 1297 61 PUSH2 0x12a7 129A 60 PUSH1 0x0a 129C 83 DUP4 129D 63 PUSH4 0xffffffff 12A2 61 PUSH2 0x1feb 12A5 16 AND 12A6 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1294 storage[0x07] = stack[-1] // @1295 stack[-2] = stack[-1] // @1297 stack[-1] = 0x12a7 // @129A stack[0] = 0x0a // @129C stack[1] = stack[-3] // } // Block ends with call to 0x1feb & 0xffffffff, returns to 0x12A7 label_12A7: // Incoming return from call to 0x1FEB at 0x12A6 // Inputs[7] // { // @12AA stack[-2] // @12B5 memory[0x00:0x40] // @12B6 stack[-1] // @12BF storage[keccak256(memory[0x00:0x40]) + 0x01] // @12DF stack[-6] // @12E9 stack[-5] // @12EE storage[0x11] // } 12A7 5B JUMPDEST 12A8 60 PUSH1 0x00 12AA 82 DUP3 12AB 81 DUP2 12AC 52 MSTORE 12AD 60 PUSH1 0x09 12AF 60 PUSH1 0x20 12B1 52 MSTORE 12B2 60 PUSH1 0x40 12B4 90 SWAP1 12B5 20 SHA3 12B6 81 DUP2 12B7 81 DUP2 12B8 55 SSTORE 12B9 60 PUSH1 0x01 12BB 80 DUP1 12BC 82 DUP3 12BD 01 ADD 12BE 80 DUP1 12BF 54 SLOAD 12C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12D5 19 NOT 12D6 16 AND 12D7 60 PUSH1 0x01 12D9 60 PUSH1 0x01 12DB 60 PUSH1 0xa0 12DD 1B SHL 12DE 03 SUB 12DF 8A DUP11 12E0 16 AND 12E1 17 OR 12E2 90 SWAP1 12E3 55 SSTORE 12E4 60 PUSH1 0x02 12E6 90 SWAP1 12E7 91 SWAP2 12E8 01 ADD 12E9 86 DUP7 12EA 90 SWAP1 12EB 55 SSTORE 12EC 60 PUSH1 0x11 12EE 54 SLOAD 12EF 83 DUP4 12F0 83 DUP4 12F1 03 SUB 12F2 90 SWAP1 12F3 91 SWAP2 12F4 01 ADD 12F5 90 SWAP1 12F6 61 PUSH2 0x12ff 12F9 90 SWAP1 12FA 82 DUP3 12FB 61 PUSH2 0x1f91 12FE 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @12AC memory[0x00:0x20] = stack[-2] // @12B1 memory[0x20:0x40] = 0x09 // @12B8 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @12E3 storage[keccak256(memory[0x00:0x40]) + 0x01] = (stack[-6] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40]) + 0x01]) // @12EB storage[keccak256(memory[0x00:0x40]) + 0x02] = stack[-5] // @12F5 stack[0] = 0x01 + (stack[-1] - stack[-2]) // @12F9 stack[1] = 0x12ff // @12F9 stack[2] = storage[0x11] // @12FA stack[3] = 0x01 + (stack[-1] - stack[-2]) // } // Block ends with call to 0x1f91, returns to 0x12FF label_12FF: // Incoming return from call to 0x1F91 at 0x12FE // Inputs[5] // { // @1302 stack[-1] // @130B stack[-8] // @131A memory[0x00:0x40] // @131B storage[keccak256(memory[0x00:0x40])] // @1320 stack[-2] // } 12FF 5B JUMPDEST 1300 60 PUSH1 0x11 1302 55 SSTORE 1303 60 PUSH1 0x01 1305 60 PUSH1 0x01 1307 60 PUSH1 0xa0 1309 1B SHL 130A 03 SUB 130B 87 DUP8 130C 16 AND 130D 60 PUSH1 0x00 130F 90 SWAP1 1310 81 DUP2 1311 52 MSTORE 1312 60 PUSH1 0x15 1314 60 PUSH1 0x20 1316 52 MSTORE 1317 60 PUSH1 0x40 1319 90 SWAP1 131A 20 SHA3 131B 54 SLOAD 131C 61 PUSH2 0x132b 131F 90 SWAP1 1320 82 DUP3 1321 63 PUSH4 0xffffffff 1326 61 PUSH2 0x1f91 1329 16 AND 132A 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @1302 storage[0x11] = stack[-1] // @1311 memory[0x00:0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @1316 memory[0x20:0x40] = 0x15 // @131F stack[0] = storage[keccak256(memory[0x00:0x40])] // @131F stack[-1] = 0x132b // @1320 stack[1] = stack[-2] // } // Block ends with call to 0x1f91 & 0xffffffff, returns to 0x132B label_132B: // Incoming return from call to 0x1F91 at 0x132A // Inputs[11] // { // @1335 stack[-8] // @1345 memory[0x00:0x40] // @1346 stack[-1] // @134C storage[0x01] // @134E memory[0x40:0x60] // @1376 stack[-4] // @137D stack[-3] // @1380 address(this) // @138A stack[-7] // @138E memory[0x40:0x60] // @13A7 address((0x01 << 0xa0) - 0x01 & storage[0x01]).code.length // } 132B 5B JUMPDEST 132C 60 PUSH1 0x01 132E 60 PUSH1 0x01 1330 60 PUSH1 0xa0 1332 1B SHL 1333 03 SUB 1334 80 DUP1 1335 89 DUP10 1336 16 AND 1337 60 PUSH1 0x00 1339 90 SWAP1 133A 81 DUP2 133B 52 MSTORE 133C 60 PUSH1 0x15 133E 60 PUSH1 0x20 1340 52 MSTORE 1341 60 PUSH1 0x40 1343 80 DUP1 1344 82 DUP3 1345 20 SHA3 1346 93 SWAP4 1347 90 SWAP1 1348 93 SWAP4 1349 55 SSTORE 134A 60 PUSH1 0x01 134C 54 SLOAD 134D 83 DUP4 134E 51 MLOAD 134F 7F PUSH32 0x1742cedb00000000000000000000000000000000000000000000000000000000 1370 81 DUP2 1371 52 MSTORE 1372 60 PUSH1 0x04 1374 81 DUP2 1375 01 ADD 1376 88 DUP9 1377 90 SWAP1 1378 52 MSTORE 1379 60 PUSH1 0x24 137B 81 DUP2 137C 01 ADD 137D 87 DUP8 137E 90 SWAP1 137F 52 MSTORE 1380 30 ADDRESS 1381 60 PUSH1 0x44 1383 82 DUP3 1384 01 ADD 1385 52 MSTORE 1386 60 PUSH1 0x64 1388 81 DUP2 1389 01 ADD 138A 8B DUP12 138B 90 SWAP1 138C 52 MSTORE 138D 93 SWAP4 138E 51 MLOAD 138F 92 SWAP3 1390 16 AND 1391 92 SWAP3 1392 63 PUSH4 0x1742cedb 1397 92 SWAP3 1398 60 PUSH1 0x84 139A 80 DUP1 139B 83 DUP4 139C 01 ADD 139D 93 SWAP4 139E 92 SWAP3 139F 82 DUP3 13A0 90 SWAP1 13A1 03 SUB 13A2 01 ADD 13A3 81 DUP2 13A4 83 DUP4 13A5 87 DUP8 13A6 80 DUP1 13A7 3B EXTCODESIZE 13A8 15 ISZERO 13A9 80 DUP1 13AA 15 ISZERO 13AB 61 PUSH2 0x13b3 13AE 57 *JUMPI // Stack delta = +9 // Outputs[18] // { // @133B memory[0x00:0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @1340 memory[0x20:0x40] = 0x15 // @1349 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1371 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1742cedb00000000000000000000000000000000000000000000000000000000 // @1378 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-4] // @137F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-3] // @1385 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = address(this) // @138C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = stack[-7] // @1391 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x01] // @1397 stack[0] = 0x1742cedb // @1397 stack[3] = memory[0x40:0x60] // @139D stack[1] = memory[0x40:0x60] + 0x84 // @139E stack[2] = 0x00 // @13A2 stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x84 // @13A3 stack[5] = memory[0x40:0x60] // @13A4 stack[6] = 0x00 // @13A5 stack[7] = (0x01 << 0xa0) - 0x01 & storage[0x01] // @13A8 stack[8] = !address((0x01 << 0xa0) - 0x01 & storage[0x01]).code.length // } // Block ends with conditional jump to 0x13b3, if !!address((0x01 << 0xa0) - 0x01 & storage[0x01]).code.length label_13AF: // Incoming jump from 0x13AE, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x01]).code.length // Inputs[1] { @13B2 memory[0x00:0x00] } 13AF 60 PUSH1 0x00 13B1 80 DUP1 13B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @13B2 revert(memory[0x00:0x00]); } // Block terminates label_13B3: // Incoming jump from 0x13AE, if !!address((0x01 << 0xa0) - 0x01 & storage[0x01]).code.length // Inputs[9] // { // @13B5 msg.gas // @13B6 stack[-6] // @13B6 stack[-4] // @13B6 stack[-7] // @13B6 stack[-3] // @13B6 stack[-5] // @13B6 memory[stack[-4]:stack[-4] + stack[-5]] // @13B6 stack[-2] // @13B6 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 13B3 5B JUMPDEST 13B4 50 POP 13B5 5A GAS 13B6 F1 CALL 13B7 15 ISZERO 13B8 80 DUP1 13B9 15 ISZERO 13BA 61 PUSH2 0x13c7 13BD 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @13B6 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @13B7 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x13c7, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_13BE: // Incoming jump from 0x13BD, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @13BE returndata.length // @13C2 returndata[0x00:0x00 + returndata.length] // @13C3 returndata.length // @13C6 memory[0x00:0x00 + returndata.length] // } 13BE 3D RETURNDATASIZE 13BF 60 PUSH1 0x00 13C1 80 DUP1 13C2 3E RETURNDATACOPY 13C3 3D RETURNDATASIZE 13C4 60 PUSH1 0x00 13C6 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @13C2 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @13C6 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_13C7: // Incoming jump from 0x13BD, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @13CE stack[-5] } 13C7 5B JUMPDEST 13C8 50 POP 13C9 50 POP 13CA 50 POP 13CB 50 POP 13CC 60 PUSH1 0x01 13CE 81 DUP2 13CF 11 GT 13D0 15 ISZERO 13D1 61 PUSH2 0x141d 13D4 57 *JUMPI // Stack delta = -4 // Block ends with conditional jump to 0x141d, if !(stack[-5] > 0x01) label_13D5: // Incoming jump from 0x13D4, if not !(stack[-5] > 0x01) // Inputs[6] // { // @13D8 memory[0x40:0x60] // @13D9 stack[-2] // @13DD memory[0x40:0x60] // @13E6 stack[-7] // @13EC stack[-3] // @1418 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 13D5 60 PUSH1 0x40 13D7 80 DUP1 13D8 51 MLOAD 13D9 83 DUP4 13DA 81 DUP2 13DB 52 MSTORE 13DC 90 SWAP1 13DD 51 MLOAD 13DE 60 PUSH1 0x01 13E0 60 PUSH1 0x01 13E2 60 PUSH1 0xa0 13E4 1B SHL 13E5 03 SUB 13E6 89 DUP10 13E7 16 AND 13E8 91 SWAP2 13E9 60 PUSH1 0x00 13EB 91 SWAP2 13EC 86 DUP7 13ED 91 SWAP2 13EE 7F PUSH32 0xdeaa91b6123d068f5821d0fb0678463d1a8a6079fe8af5de3ce5e896dcf9133d 140F 91 SWAP2 1410 90 SWAP1 1411 81 DUP2 1412 90 SWAP1 1413 03 SUB 1414 60 PUSH1 0x20 1416 01 ADD 1417 90 SWAP1 1418 A4 LOG4 1419 61 PUSH2 0x1018 141C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @13DB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @1418 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0xdeaa91b6123d068f5821d0fb0678463d1a8a6079fe8af5de3ce5e896dcf9133d, stack[-3], 0x00, stack[-7] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to 0x1018 label_141D: // Incoming jump from 0x13D4, if !(stack[-5] > 0x01) // Inputs[5] // { // @1420 memory[0x40:0x60] // @1421 stack[-3] // @142B stack[-7] // @1455 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @145E stack[-9] // } 141D 5B JUMPDEST 141E 60 PUSH1 0x40 1420 51 MLOAD 1421 83 DUP4 1422 90 SWAP1 1423 60 PUSH1 0x01 1425 60 PUSH1 0x01 1427 60 PUSH1 0xa0 1429 1B SHL 142A 03 SUB 142B 89 DUP10 142C 16 AND 142D 90 SWAP1 142E 60 PUSH1 0x00 1430 90 SWAP1 1431 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1452 90 SWAP1 1453 82 DUP3 1454 90 SWAP1 1455 A4 LOG4 1456 50 POP 1457 50 POP 1458 50 POP 1459 50 POP 145A 50 POP 145B 50 POP 145C 50 POP 145D 50 POP 145E 56 *JUMP // Stack delta = -9 // Outputs[1] { @1455 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-3]]); } // Block ends with unconditional jump to stack[-9] label_145F: // Incoming jump from 0x0720 // Inputs[2] // { // @1468 stack[-2] // @146A msg.sender // } 145F 5B JUMPDEST 1460 60 PUSH1 0x01 1462 60 PUSH1 0x01 1464 60 PUSH1 0xa0 1466 1B SHL 1467 03 SUB 1468 82 DUP3 1469 16 AND 146A 33 CALLER 146B 14 EQ 146C 15 ISZERO 146D 61 PUSH2 0x14bd 1470 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14bd, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) label_1471: // Incoming jump from 0x1470, if not !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @1474 memory[0x40:0x60] // @14B3 memory[0x40:0x60] // @14BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1471 60 PUSH1 0x40 1473 80 DUP1 1474 51 MLOAD 1475 62 PUSH3 0x461bcd 1479 60 PUSH1 0xe5 147B 1B SHL 147C 81 DUP2 147D 52 MSTORE 147E 60 PUSH1 0x20 1480 60 PUSH1 0x04 1482 82 DUP3 1483 01 ADD 1484 52 MSTORE 1485 60 PUSH1 0x19 1487 60 PUSH1 0x24 1489 82 DUP3 148A 01 ADD 148B 52 MSTORE 148C 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 14AD 60 PUSH1 0x44 14AF 82 DUP3 14B0 01 ADD 14B1 52 MSTORE 14B2 90 SWAP1 14B3 51 MLOAD 14B4 90 SWAP1 14B5 81 DUP2 14B6 90 SWAP1 14B7 03 SUB 14B8 60 PUSH1 0x64 14BA 01 ADD 14BB 90 SWAP1 14BC FD *REVERT // Stack delta = +0 // Outputs[5] // { // @147D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1484 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @148B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @14B1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @14BC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_14BD: // Incoming jump from 0x1470, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[10] // { // @14BE msg.sender // @14CF memory[0x00:0x40] // @14D8 stack[-2] // @14E3 memory[0x00:0x40] // @14E5 storage[keccak256(memory[0x00:0x40])] // @14EA stack[-1] // @14F4 memory[0x40:0x60] // @14F9 memory[0x40:0x60] // @1527 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @152A stack[-3] // } 14BD 5B JUMPDEST 14BE 33 CALLER 14BF 60 PUSH1 0x00 14C1 81 DUP2 14C2 81 DUP2 14C3 52 MSTORE 14C4 60 PUSH1 0x13 14C6 60 PUSH1 0x20 14C8 90 SWAP1 14C9 81 DUP2 14CA 52 MSTORE 14CB 60 PUSH1 0x40 14CD 80 DUP1 14CE 83 DUP4 14CF 20 SHA3 14D0 60 PUSH1 0x01 14D2 60 PUSH1 0x01 14D4 60 PUSH1 0xa0 14D6 1B SHL 14D7 03 SUB 14D8 87 DUP8 14D9 16 AND 14DA 80 DUP1 14DB 85 DUP6 14DC 52 MSTORE 14DD 90 SWAP1 14DE 83 DUP4 14DF 52 MSTORE 14E0 92 SWAP3 14E1 81 DUP2 14E2 90 SWAP1 14E3 20 SHA3 14E4 80 DUP1 14E5 54 SLOAD 14E6 60 PUSH1 0xff 14E8 19 NOT 14E9 16 AND 14EA 86 DUP7 14EB 15 ISZERO 14EC 15 ISZERO 14ED 90 SWAP1 14EE 81 DUP2 14EF 17 OR 14F0 90 SWAP1 14F1 91 SWAP2 14F2 55 SSTORE 14F3 81 DUP2 14F4 51 MLOAD 14F5 90 SWAP1 14F6 81 DUP2 14F7 52 MSTORE 14F8 90 SWAP1 14F9 51 MLOAD 14FA 92 SWAP3 14FB 93 SWAP4 14FC 92 SWAP3 14FD 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 151E 92 SWAP3 151F 91 SWAP2 1520 81 DUP2 1521 90 SWAP1 1522 03 SUB 1523 90 SWAP1 1524 91 SWAP2 1525 01 ADD 1526 90 SWAP1 1527 A3 LOG3 1528 50 POP 1529 50 POP 152A 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @14C3 memory[0x00:0x20] = msg.sender // @14CA memory[0x20:0x40] = 0x13 // @14DC memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @14DF memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @14F2 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @14F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @1527 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-3] label_152B: // Incoming call from 0x0735, returns to 0x0736 // Inputs[1] { @154D stack[-1] } 152B 5B JUMPDEST 152C 7F PUSH32 0x27500df900000000000000000000000000000000000000000000000000000000 154D 81 DUP2 154E 56 *JUMP // Stack delta = +1 // Outputs[1] { @152C stack[0] = 0x27500df900000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to stack[-1] label_154F: // Incoming jump from 0x0D84 // Incoming jump from 0x0830 // Inputs[4] // { // @1553 stack[-4] // @1554 stack[-3] // @1555 stack[-2] // @1556 stack[-1] // } 154F 5B JUMPDEST 1550 61 PUSH2 0x0934 1553 84 DUP5 1554 84 DUP5 1555 84 DUP5 1556 84 DUP5 1557 61 PUSH2 0x21bb 155A 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1550 stack[0] = 0x0934 // @1553 stack[1] = stack[-4] // @1554 stack[2] = stack[-3] // @1555 stack[3] = stack[-2] // @1556 stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x21bb label_155B: // Incoming jump from 0x08AD // Inputs[2] // { // @155E storage[0x05] // @1568 msg.sender // } 155B 5B JUMPDEST 155C 60 PUSH1 0x05 155E 54 SLOAD 155F 60 PUSH1 0x01 1561 60 PUSH1 0x01 1563 60 PUSH1 0xa0 1565 1B SHL 1566 03 SUB 1567 16 AND 1568 33 CALLER 1569 14 EQ 156A 61 PUSH2 0x15ba 156D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15ba, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] label_156E: // Incoming jump from 0x156D, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] // Inputs[3] // { // @1571 memory[0x40:0x60] // @15B0 memory[0x40:0x60] // @15B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 156E 60 PUSH1 0x40 1570 80 DUP1 1571 51 MLOAD 1572 62 PUSH3 0x461bcd 1576 60 PUSH1 0xe5 1578 1B SHL 1579 81 DUP2 157A 52 MSTORE 157B 60 PUSH1 0x20 157D 60 PUSH1 0x04 157F 82 DUP3 1580 01 ADD 1581 52 MSTORE 1582 60 PUSH1 0x12 1584 60 PUSH1 0x24 1586 82 DUP3 1587 01 ADD 1588 52 MSTORE 1589 7F PUSH32 0x53656e646572206e6f742063726561746f720000000000000000000000000000 15AA 60 PUSH1 0x44 15AC 82 DUP3 15AD 01 ADD 15AE 52 MSTORE 15AF 90 SWAP1 15B0 51 MLOAD 15B1 90 SWAP1 15B2 81 DUP2 15B3 90 SWAP1 15B4 03 SUB 15B5 60 PUSH1 0x64 15B7 01 ADD 15B8 90 SWAP1 15B9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @157A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1581 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1588 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @15AE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53656e646572206e6f742063726561746f720000000000000000000000000000 // @15B9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_15BA: // Incoming jump from 0x156D, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] // Inputs[2] // { // @15C0 stack[-2] // @15C1 stack[-1] // } 15BA 5B JUMPDEST 15BB 61 PUSH2 0x15c6 15BE 60 PUSH1 0x0f 15C0 83 DUP4 15C1 83 DUP4 15C2 61 PUSH2 0x2c22 15C5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @15BB stack[0] = 0x15c6 // @15BE stack[1] = 0x0f // @15C0 stack[2] = stack[-2] // @15C1 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x2c22 15C6 5B JUMPDEST 15C7 50 POP 15C8 50 POP 15C9 60 PUSH1 0x10 15CB 80 DUP1 15CC 54 SLOAD 15CD 60 PUSH1 0xff 15CF 19 NOT 15D0 16 AND 15D1 60 PUSH1 0x01 15D3 17 OR 15D4 90 SWAP1 15D5 55 SSTORE 15D6 50 POP 15D7 56 *JUMP label_15D8: // Incoming jump from 0x08D7 // Inputs[3] // { // @15DB stack[-1] // @15E6 memory[0x00:0x40] // @15E7 storage[keccak256(memory[0x00:0x40])] // } 15D8 5B JUMPDEST 15D9 60 PUSH1 0x00 15DB 81 DUP2 15DC 81 DUP2 15DD 52 MSTORE 15DE 60 PUSH1 0x08 15E0 60 PUSH1 0x20 15E2 52 MSTORE 15E3 60 PUSH1 0x40 15E5 90 SWAP1 15E6 20 SHA3 15E7 54 SLOAD 15E8 60 PUSH1 0x60 15EA 90 SWAP1 15EB 60 PUSH1 0xff 15ED 16 AND 15EE 15 ISZERO 15EF 15 ISZERO 15F0 60 PUSH1 0x01 15F2 14 EQ 15F3 15 ISZERO 15F4 61 PUSH2 0x163b 15F7 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @15DD memory[0x00:0x20] = stack[-1] // @15E2 memory[0x20:0x40] = 0x08 // @15EA stack[0] = 0x60 // } // Block ends with conditional jump to 0x163b, if !(0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])])) label_15F8: // Incoming jump from 0x15F7, if not !(0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])])) // Inputs[3] // { // @15FB memory[0x40:0x60] // @1631 memory[0x40:0x60] // @163A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 15F8 60 PUSH1 0x40 15FA 80 DUP1 15FB 51 MLOAD 15FC 62 PUSH3 0x461bcd 1600 60 PUSH1 0xe5 1602 1B SHL 1603 81 DUP2 1604 52 MSTORE 1605 60 PUSH1 0x20 1607 60 PUSH1 0x04 1609 82 DUP3 160A 01 ADD 160B 52 MSTORE 160C 60 PUSH1 0x14 160E 60 PUSH1 0x24 1610 82 DUP3 1611 01 ADD 1612 52 MSTORE 1613 73 PUSH20 0x151bdad95b88191bd95cc81b9bdd08195e1a5cdd 1628 60 PUSH1 0x62 162A 1B SHL 162B 60 PUSH1 0x44 162D 82 DUP3 162E 01 ADD 162F 52 MSTORE 1630 90 SWAP1 1631 51 MLOAD 1632 90 SWAP1 1633 81 DUP2 1634 90 SWAP1 1635 03 SUB 1636 60 PUSH1 0x64 1638 01 ADD 1639 90 SWAP1 163A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1604 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @160B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1612 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @162F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x151bdad95b88191bd95cc81b9bdd08195e1a5cdd << 0x62 // @163A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_163B: // Incoming jump from 0x15F7, if !(0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])])) // Inputs[1] { @1642 stack[-2] } 163B 5B JUMPDEST 163C 60 PUSH1 0x00 163E 80 DUP1 163F 61 PUSH2 0x1647 1642 84 DUP5 1643 61 PUSH2 0x1d78 1646 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @163C stack[0] = 0x00 // @163E stack[1] = 0x00 // @163F stack[2] = 0x1647 // @1642 stack[3] = stack[-2] // } // Block ends with call to 0x1d78, returns to 0x1647 label_1647: // Incoming return from call to 0x1D78 at 0x1646 // Inputs[5] // { // @1648 stack[-1] // @1648 stack[-4] // @1649 stack[-6] // @164B stack[-2] // @164C stack[-5] // } 1647 5B JUMPDEST 1648 92 SWAP3 1649 94 SWAP5 164A 50 POP 164B 91 SWAP2 164C 92 SWAP3 164D 50 POP 164E 50 POP 164F 50 POP 1650 60 PUSH1 0x01 1652 60 PUSH1 0x01 1654 60 PUSH1 0xa0 1656 1B SHL 1657 03 SUB 1658 82 DUP3 1659 16 AND 165A 61 PUSH2 0x16a1 165D 57 *JUMPI // Stack delta = -4 // Outputs[2] // { // @1649 stack[-6] = stack[-4] // @164C stack[-5] = stack[-1] // } // Block ends with conditional jump to 0x16a1, if stack[-4] & (0x01 << 0xa0) - 0x01 label_165E: // Incoming jump from 0x165D, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1661 memory[0x40:0x60] // @1697 memory[0x40:0x60] // @16A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 165E 60 PUSH1 0x40 1660 80 DUP1 1661 51 MLOAD 1662 62 PUSH3 0x461bcd 1666 60 PUSH1 0xe5 1668 1B SHL 1669 81 DUP2 166A 52 MSTORE 166B 60 PUSH1 0x20 166D 60 PUSH1 0x04 166F 82 DUP3 1670 01 ADD 1671 52 MSTORE 1672 60 PUSH1 0x14 1674 60 PUSH1 0x24 1676 82 DUP3 1677 01 ADD 1678 52 MSTORE 1679 73 PUSH20 0x151bdad95b88191bd95cc81b9bdd08195e1a5cdd 168E 60 PUSH1 0x62 1690 1B SHL 1691 60 PUSH1 0x44 1693 82 DUP3 1694 01 ADD 1695 52 MSTORE 1696 90 SWAP1 1697 51 MLOAD 1698 90 SWAP1 1699 81 DUP2 169A 90 SWAP1 169B 03 SUB 169C 60 PUSH1 0x64 169E 01 ADD 169F 90 SWAP1 16A0 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @166A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1671 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1678 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @1695 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x151bdad95b88191bd95cc81b9bdd08195e1a5cdd << 0x62 // @16A0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_16A1: // Incoming jump from 0x165D, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @16A4 storage[0x10] } 16A1 5B JUMPDEST 16A2 60 PUSH1 0x10 16A4 54 SLOAD 16A5 60 PUSH1 0xff 16A7 16 AND 16A8 61 PUSH2 0x179f 16AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x179f, if 0xff & storage[0x10] label_16AC: // Incoming jump from 0x16AB, if not 0xff & storage[0x10] // Inputs[4] // { // @16AF storage[0x01] // @16B3 memory[0x40:0x60] // @16DF memory[0x40:0x60] // @1704 address(storage[0x01] & (0x01 << 0xa0) - 0x01).code.length // } 16AC 60 PUSH1 0x01 16AE 80 DUP1 16AF 54 SLOAD 16B0 60 PUSH1 0x40 16B2 80 DUP1 16B3 51 MLOAD 16B4 7F PUSH32 0x5d63483400000000000000000000000000000000000000000000000000000000 16D5 81 DUP2 16D6 52 MSTORE 16D7 60 PUSH1 0x04 16D9 81 DUP2 16DA 01 ADD 16DB 93 SWAP4 16DC 90 SWAP1 16DD 93 SWAP4 16DE 52 MSTORE 16DF 51 MLOAD 16E0 60 PUSH1 0x01 16E2 60 PUSH1 0x01 16E4 60 PUSH1 0xa0 16E6 1B SHL 16E7 03 SUB 16E8 90 SWAP1 16E9 91 SWAP2 16EA 16 AND 16EB 91 SWAP2 16EC 63 PUSH4 0x5d634834 16F1 91 SWAP2 16F2 60 PUSH1 0x24 16F4 80 DUP1 16F5 83 DUP4 16F6 01 ADD 16F7 92 SWAP3 16F8 60 PUSH1 0x00 16FA 92 SWAP3 16FB 91 SWAP2 16FC 90 SWAP1 16FD 82 DUP3 16FE 90 SWAP1 16FF 03 SUB 1700 01 ADD 1701 81 DUP2 1702 86 DUP7 1703 80 DUP1 1704 3B EXTCODESIZE 1705 15 ISZERO 1706 80 DUP1 1707 15 ISZERO 1708 61 PUSH2 0x1710 170B 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @16D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5d63483400000000000000000000000000000000000000000000000000000000 // @16DE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x01 // @16EB stack[0] = storage[0x01] & (0x01 << 0xa0) - 0x01 // @16F1 stack[1] = 0x5d634834 // @16F7 stack[2] = memory[0x40:0x60] + 0x24 // @16FA stack[3] = 0x00 // @16FB stack[4] = memory[0x40:0x60] // @1700 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @1701 stack[6] = memory[0x40:0x60] // @1702 stack[7] = storage[0x01] & (0x01 << 0xa0) - 0x01 // @1705 stack[8] = !address(storage[0x01] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x1710, if !!address(storage[0x01] & (0x01 << 0xa0) - 0x01).code.length label_170C: // Incoming jump from 0x170B, if not !!address(storage[0x01] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @170F memory[0x00:0x00] } 170C 60 PUSH1 0x00 170E 80 DUP1 170F FD *REVERT // Stack delta = +0 // Outputs[1] { @170F revert(memory[0x00:0x00]); } // Block terminates label_1710: // Incoming jump from 0x170B, if !!address(storage[0x01] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @1712 msg.gas // @1713 stack[-6] // @1713 stack[-5] // @1713 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1713 stack[-2] // @1713 stack[-3] // @1713 stack[-4] // @1713 memory[stack[-3]:stack[-3] + stack[-4]] // } 1710 5B JUMPDEST 1711 50 POP 1712 5A GAS 1713 FA STATICCALL 1714 15 ISZERO 1715 80 DUP1 1716 15 ISZERO 1717 61 PUSH2 0x1724 171A 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1713 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1714 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1724, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_171B: // Incoming jump from 0x171A, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @171B returndata.length // @171F returndata[0x00:0x00 + returndata.length] // @1720 returndata.length // @1723 memory[0x00:0x00 + returndata.length] // } 171B 3D RETURNDATASIZE 171C 60 PUSH1 0x00 171E 80 DUP1 171F 3E RETURNDATACOPY 1720 3D RETURNDATASIZE 1721 60 PUSH1 0x00 1723 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @171F memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1723 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1724: // Incoming jump from 0x171A, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @172B memory[0x40:0x60] // @172C returndata.length // @1730 returndata[0x00:0x00 + returndata.length] // @1733 returndata.length // } 1724 5B JUMPDEST 1725 50 POP 1726 50 POP 1727 50 POP 1728 50 POP 1729 60 PUSH1 0x40 172B 51 MLOAD 172C 3D RETURNDATASIZE 172D 60 PUSH1 0x00 172F 82 DUP3 1730 3E RETURNDATACOPY 1731 60 PUSH1 0x1f 1733 3D RETURNDATASIZE 1734 90 SWAP1 1735 81 DUP2 1736 01 ADD 1737 60 PUSH1 0x1f 1739 19 NOT 173A 16 AND 173B 82 DUP3 173C 01 ADD 173D 60 PUSH1 0x40 173F 52 MSTORE 1740 60 PUSH1 0x20 1742 81 DUP2 1743 10 LT 1744 15 ISZERO 1745 61 PUSH2 0x174d 1748 57 *JUMPI // Stack delta = -2 // Outputs[4] // { // @172B stack[-4] = memory[0x40:0x60] // @1730 memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1734 stack[-3] = returndata.length // @173F memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // } // Block ends with conditional jump to 0x174d, if !(returndata.length < 0x20) label_1749: // Incoming jump from 0x1748, if not !(returndata.length < 0x20) // Inputs[1] { @174C memory[0x00:0x00] } 1749 60 PUSH1 0x00 174B 80 DUP1 174C FD *REVERT // Stack delta = +0 // Outputs[1] { @174C revert(memory[0x00:0x00]); } // Block terminates label_174D: // Incoming jump from 0x1748, if !(returndata.length < 0x20) // Inputs[3] // { // @174E stack[-2] // @174F stack[-1] // @1753 memory[stack[-2]:stack[-2] + 0x20] // } 174D 5B JUMPDEST 174E 81 DUP2 174F 01 ADD 1750 90 SWAP1 1751 80 DUP1 1752 80 DUP1 1753 51 MLOAD 1754 64 PUSH5 0x0100000000 175A 81 DUP2 175B 11 GT 175C 15 ISZERO 175D 61 PUSH2 0x1765 1760 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1750 stack[-1] = stack[-2] // @1750 stack[-2] = stack[-2] + stack[-1] // @1751 stack[0] = stack[-2] // @1753 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x1765, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_1761: // Incoming jump from 0x1760, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @1764 memory[0x00:0x00] } 1761 60 PUSH1 0x00 1763 80 DUP1 1764 FD *REVERT // Stack delta = +0 // Outputs[1] { @1764 revert(memory[0x00:0x00]); } // Block terminates label_1765: // Incoming jump from 0x1760, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @1766 stack[-3] // @1767 stack[-1] // @176C stack[-4] // } 1765 5B JUMPDEST 1766 82 DUP3 1767 01 ADD 1768 60 PUSH1 0x20 176A 81 DUP2 176B 01 ADD 176C 84 DUP5 176D 81 DUP2 176E 11 GT 176F 15 ISZERO 1770 61 PUSH2 0x1778 1773 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1767 stack[-1] = stack[-3] + stack[-1] // @176B stack[0] = stack[-3] + stack[-1] + 0x20 // } // Block ends with conditional jump to 0x1778, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_1774: // Incoming jump from 0x1773, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @1777 memory[0x00:0x00] } 1774 60 PUSH1 0x00 1776 80 DUP1 1777 FD *REVERT // Stack delta = +0 // Outputs[1] { @1777 revert(memory[0x00:0x00]); } // Block terminates label_1778: // Incoming jump from 0x1773, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @1779 stack[-2] // @177A memory[stack[-2]:stack[-2] + 0x20] // @1783 stack[-1] // @1786 stack[-5] // } 1778 5B JUMPDEST 1779 81 DUP2 177A 51 MLOAD 177B 64 PUSH5 0x0100000000 1781 81 DUP2 1782 11 GT 1783 82 DUP3 1784 82 DUP3 1785 01 ADD 1786 87 DUP8 1787 10 LT 1788 17 OR 1789 15 ISZERO 178A 61 PUSH2 0x1792 178D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @177A stack[0] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1792, if !((stack[-5] < memory[stack[-2]:stack[-2] + 0x20] + stack[-1]) | (memory[stack[-2]:stack[-2] + 0x20] > 0x0100000000)) label_178E: // Incoming jump from 0x178D, if not !((stack[-5] < memory[stack[-2]:stack[-2] + 0x20] + stack[-1]) | (memory[stack[-2]:stack[-2] + 0x20] > 0x0100000000)) // Inputs[1] { @1791 memory[0x00:0x00] } 178E 60 PUSH1 0x00 1790 80 DUP1 1791 FD *REVERT // Stack delta = +0 // Outputs[1] { @1791 revert(memory[0x00:0x00]); } // Block terminates label_1792: // Incoming jump from 0x178D, if !((stack[-5] < memory[stack[-2]:stack[-2] + 0x20] + stack[-1]) | (memory[stack[-2]:stack[-2] + 0x20] > 0x0100000000)) // Inputs[4] // { // @1795 stack[-3] // @1795 stack[-6] // @1796 stack[-5] // @1797 stack[-4] // } 1792 5B JUMPDEST 1793 50 POP 1794 50 POP 1795 92 SWAP3 1796 91 SWAP2 1797 90 SWAP1 1798 50 POP 1799 50 POP 179A 50 POP 179B 61 PUSH2 0x182b 179E 56 *JUMP // Stack delta = -5 // Outputs[1] { @1795 stack[-6] = stack[-3] } // Block ends with unconditional jump to 0x182b label_179F: // Incoming jump from 0x16AB, if 0xff & storage[0x10] // Inputs[2] // { // @17A3 storage[0x0f] // @17A7 memory[0x40:0x60] // } 179F 5B JUMPDEST 17A0 60 PUSH1 0x0f 17A2 80 DUP1 17A3 54 SLOAD 17A4 60 PUSH1 0x40 17A6 80 DUP1 17A7 51 MLOAD 17A8 60 PUSH1 0x20 17AA 60 PUSH1 0x02 17AC 60 PUSH1 0x01 17AE 85 DUP6 17AF 16 AND 17B0 15 ISZERO 17B1 61 PUSH2 0x0100 17B4 02 MUL 17B5 60 PUSH1 0x00 17B7 19 NOT 17B8 01 ADD 17B9 90 SWAP1 17BA 94 SWAP5 17BB 16 AND 17BC 93 SWAP4 17BD 90 SWAP1 17BE 93 SWAP4 17BF 04 DIV 17C0 60 PUSH1 0x1f 17C2 81 DUP2 17C3 01 ADD 17C4 84 DUP5 17C5 90 SWAP1 17C6 04 DIV 17C7 84 DUP5 17C8 02 MUL 17C9 82 DUP3 17CA 01 ADD 17CB 84 DUP5 17CC 01 ADD 17CD 90 SWAP1 17CE 92 SWAP3 17CF 52 MSTORE 17D0 81 DUP2 17D1 81 DUP2 17D2 52 MSTORE 17D3 92 SWAP3 17D4 91 SWAP2 17D5 83 DUP4 17D6 01 ADD 17D7 82 DUP3 17D8 82 DUP3 17D9 80 DUP1 17DA 15 ISZERO 17DB 61 PUSH2 0x1825 17DE 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @17CE stack[2] = (storage[0x0f] & ~0x00 + 0x0100 * !(storage[0x0f] & 0x01)) / 0x02 // @17CF memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x0f] & ~0x00 + 0x0100 * !(storage[0x0f] & 0x01)) / 0x02 + 0x1f) / 0x20) // @17D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x0f] & ~0x00 + 0x0100 * !(storage[0x0f] & 0x01)) / 0x02 // @17D3 stack[0] = memory[0x40:0x60] // @17D4 stack[1] = 0x0f // @17D6 stack[3] = memory[0x40:0x60] + 0x20 // @17D7 stack[4] = 0x0f // @17D8 stack[5] = (storage[0x0f] & ~0x00 + 0x0100 * !(storage[0x0f] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x1825, if !((storage[0x0f] & ~0x00 + 0x0100 * !(storage[0x0f] & 0x01)) / 0x02) label_17DF: // Incoming jump from 0x17DE, if not !((storage[0x0f] & ~0x00 + 0x0100 * !(storage[0x0f] & 0x01)) / 0x02) // Inputs[1] { @17DF stack[-1] } 17DF 80 DUP1 17E0 60 PUSH1 0x1f 17E2 10 LT 17E3 61 PUSH2 0x17fa 17E6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17fa, if 0x1f < stack[-1] label_17E7: // Incoming jump from 0x17E6, if not 0x1f < stack[-1] // Inputs[4] // { // @17EB stack[-2] // @17EC storage[stack[-2]] // @17EF stack[-3] // @17F1 stack[-1] // } 17E7 61 PUSH2 0x0100 17EA 80 DUP1 17EB 83 DUP4 17EC 54 SLOAD 17ED 04 DIV 17EE 02 MUL 17EF 83 DUP4 17F0 52 MSTORE 17F1 91 SWAP2 17F2 60 PUSH1 0x20 17F4 01 ADD 17F5 91 SWAP2 17F6 61 PUSH2 0x1825 17F9 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @17F0 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @17F5 stack[-1] = stack[-1] // @17F5 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1825 label_17FA: // Incoming jump from 0x17E6, if 0x1f < stack[-1] // Inputs[5] // { // @17FB stack[-3] // @17FC stack[-1] // @17FE stack[-2] // @1806 memory[0x00:0x20] // @180A storage[keccak256(memory[0x00:0x20])] // } 17FA 5B JUMPDEST 17FB 82 DUP3 17FC 01 ADD 17FD 91 SWAP2 17FE 90 SWAP1 17FF 60 PUSH1 0x00 1801 52 MSTORE 1802 60 PUSH1 0x20 1804 60 PUSH1 0x00 1806 20 SHA3 1807 90 SWAP1 1808 5B JUMPDEST 1809 81 DUP2 180A 54 SLOAD 180B 81 DUP2 180C 52 MSTORE 180D 90 SWAP1 180E 60 PUSH1 0x01 1810 01 ADD 1811 90 SWAP1 1812 60 PUSH1 0x20 1814 01 ADD 1815 80 DUP1 1816 83 DUP4 1817 11 GT 1818 61 PUSH2 0x1808 181B 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @17FD stack[-3] = stack[-3] + stack[-1] // @1801 memory[0x00:0x20] = stack[-2] // @180C memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1811 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1814 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1808, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_181C: // Incoming jump from 0x181B, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x181B, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @181C stack[-3] // @181D stack[-1] // } 181C 82 DUP3 181D 90 SWAP1 181E 03 SUB 181F 60 PUSH1 0x1f 1821 16 AND 1822 82 DUP3 1823 01 ADD 1824 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1824 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1824 stack[-1] = stack[-3] // } // Block continues label_1825: // Incoming jump from 0x17DE, if !((storage[0x0f] & ~0x00 + 0x0100 * !(storage[0x0f] & 0x01)) / 0x02) // Incoming jump from 0x1824 // Incoming jump from 0x17F9 1825 5B JUMPDEST 1826 50 POP 1827 50 POP 1828 50 POP 1829 50 POP 182A 50 POP // Stack delta = -5 // Block continues label_182B: // Incoming jump from 0x182A // Incoming jump from 0x179E // Inputs[1] { @182F address(this) } 182B 5B JUMPDEST 182C 61 PUSH2 0x1834 182F 30 ADDRESS 1830 61 PUSH2 0x220e 1833 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @182C stack[0] = 0x1834 // @182F stack[1] = address(this) // } // Block ends with call to 0x220e, returns to 0x1834 label_1834: // Incoming return from call to 0x220E at 0x1833 // Inputs[1] { @1838 stack[-3] } 1834 5B JUMPDEST 1835 61 PUSH2 0x183d 1838 83 DUP4 1839 61 PUSH2 0x2302 183C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1835 stack[0] = 0x183d // @1838 stack[1] = stack[-3] // } // Block ends with call to 0x2302, returns to 0x183D label_183D: // Incoming return from call to 0x2302 at 0x183C // Inputs[1] { @1841 stack[-7] } 183D 5B JUMPDEST 183E 61 PUSH2 0x1846 1841 87 DUP8 1842 61 PUSH2 0x241f 1845 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @183E stack[0] = 0x1846 // @1841 stack[1] = stack[-7] // } // Block ends with call to 0x241f, returns to 0x1846 label_1846: // Incoming return from call to 0x241F at 0x1845 // Inputs[3] // { // @1849 memory[0x40:0x60] // @184E stack[-4] // @1850 memory[stack[-4]:stack[-4] + 0x20] // } 1846 5B JUMPDEST 1847 60 PUSH1 0x40 1849 51 MLOAD 184A 60 PUSH1 0x20 184C 01 ADD 184D 80 DUP1 184E 85 DUP6 184F 80 DUP1 1850 51 MLOAD 1851 90 SWAP1 1852 60 PUSH1 0x20 1854 01 ADD 1855 90 SWAP1 1856 80 DUP1 1857 83 DUP4 1858 83 DUP4 1859 5B JUMPDEST 185A 60 PUSH1 0x20 185C 83 DUP4 185D 10 LT 185E 61 PUSH2 0x1878 1861 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @184C stack[0] = 0x20 + memory[0x40:0x60] // @184D stack[1] = 0x20 + memory[0x40:0x60] // @1855 stack[2] = 0x20 + stack[-4] // @1855 stack[3] = memory[stack[-4]:stack[-4] + 0x20] // @1856 stack[4] = memory[stack[-4]:stack[-4] + 0x20] // @1857 stack[5] = 0x20 + memory[0x40:0x60] // @1858 stack[6] = 0x20 + stack[-4] // } // Block ends with conditional jump to 0x1878, if memory[stack[-4]:stack[-4] + 0x20] < 0x20 label_1862: // Incoming jump from 0x1861, if not stack[-3] < 0x20 // Incoming jump from 0x1861, if not memory[stack[-4]:stack[-4] + 0x20] < 0x20 // Inputs[4] // { // @1862 stack[-1] // @1863 memory[stack[-1]:stack[-1] + 0x20] // @1864 stack[-2] // @186A stack[-3] // } 1862 80 DUP1 1863 51 MLOAD 1864 82 DUP3 1865 52 MSTORE 1866 60 PUSH1 0x1f 1868 19 NOT 1869 90 SWAP1 186A 92 SWAP3 186B 01 ADD 186C 91 SWAP2 186D 60 PUSH1 0x20 186F 91 SWAP2 1870 82 DUP3 1871 01 ADD 1872 91 SWAP2 1873 01 ADD 1874 61 PUSH2 0x1859 1877 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1865 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @186C stack[-3] = stack[-3] + ~0x1f // @1872 stack[-2] = 0x20 + stack[-2] // @1873 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1859 label_1878: // Incoming jump from 0x1861, if stack[-3] < 0x20 // Incoming jump from 0x1861, if memory[stack[-4]:stack[-4] + 0x20] < 0x20 // Inputs[10] // { // @1879 stack[-1] // @1879 memory[stack[-1]:stack[-1] + 0x20] // @187A stack[-2] // @187B memory[stack[-2]:stack[-2] + 0x20] // @187E stack[-3] // @1893 stack[-10] // @1894 memory[stack[-10]:stack[-10] + 0x20] // @1895 stack[-4] // @1897 stack[-6] // @189C stack[-5] // } 1878 5B JUMPDEST 1879 51 MLOAD 187A 81 DUP2 187B 51 MLOAD 187C 60 PUSH1 0x20 187E 93 SWAP4 187F 84 DUP5 1880 03 SUB 1881 61 PUSH2 0x0100 1884 0A EXP 1885 60 PUSH1 0x00 1887 19 NOT 1888 01 ADD 1889 80 DUP1 188A 19 NOT 188B 90 SWAP1 188C 92 SWAP3 188D 16 AND 188E 91 SWAP2 188F 16 AND 1890 17 OR 1891 90 SWAP1 1892 52 MSTORE 1893 87 DUP8 1894 51 MLOAD 1895 91 SWAP2 1896 90 SWAP1 1897 93 SWAP4 1898 01 ADD 1899 92 SWAP3 189A 87 DUP8 189B 01 ADD 189C 91 SWAP2 189D 50 POP 189E 80 DUP1 189F 83 DUP4 18A0 83 DUP4 18A1 5B JUMPDEST 18A2 60 PUSH1 0x20 18A4 83 DUP4 18A5 10 LT 18A6 61 PUSH2 0x18c0 18A9 57 *JUMPI // Stack delta = +0 // Outputs[7] // { // @1892 memory[stack[-2]:stack[-2] + 0x20] = (~0x00 + 0x0100 ** (0x20 - stack[-3]) & memory[stack[-2]:stack[-2] + 0x20]) | (memory[stack[-1]:stack[-1] + 0x20] & ~(~0x00 + 0x0100 ** (0x20 - stack[-3]))) // @1895 stack[-4] = memory[stack[-10]:stack[-10] + 0x20] // @1899 stack[-6] = stack[-6] + stack[-4] // @189C stack[-5] = stack[-10] + 0x20 // @189E stack[-3] = memory[stack[-10]:stack[-10] + 0x20] // @189F stack[-2] = stack[-6] + stack[-4] // @18A0 stack[-1] = stack[-10] + 0x20 // } // Block ends with conditional jump to 0x18c0, if memory[stack[-10]:stack[-10] + 0x20] < 0x20 label_18AA: // Incoming jump from 0x18A9, if not stack[-3] < 0x20 // Incoming jump from 0x18A9, if not memory[stack[-10]:stack[-10] + 0x20] < 0x20 // Inputs[4] // { // @18AA stack[-1] // @18AB memory[stack[-1]:stack[-1] + 0x20] // @18AC stack[-2] // @18B2 stack[-3] // } 18AA 80 DUP1 18AB 51 MLOAD 18AC 82 DUP3 18AD 52 MSTORE 18AE 60 PUSH1 0x1f 18B0 19 NOT 18B1 90 SWAP1 18B2 92 SWAP3 18B3 01 ADD 18B4 91 SWAP2 18B5 60 PUSH1 0x20 18B7 91 SWAP2 18B8 82 DUP3 18B9 01 ADD 18BA 91 SWAP2 18BB 01 ADD 18BC 61 PUSH2 0x18a1 18BF 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @18AD memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @18B4 stack[-3] = stack[-3] + ~0x1f // @18BA stack[-2] = 0x20 + stack[-2] // @18BB stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x18a1 label_18C0: // Incoming jump from 0x18A9, if stack[-3] < 0x20 // Incoming jump from 0x18A9, if memory[stack[-10]:stack[-10] + 0x20] < 0x20 // Inputs[10] // { // @18C3 stack[-3] // @18CE stack[-1] // @18CF memory[stack[-1]:stack[-1] + 0x20] // @18D2 stack[-2] // @18D3 memory[stack[-2]:stack[-2] + 0x20] // @18E0 stack[-4] // @18E0 stack[-5] // @18E2 stack[-6] // @18EF stack[-9] // @18F1 memory[stack[-9]:stack[-9] + 0x20] // } 18C0 5B JUMPDEST 18C1 60 PUSH1 0x01 18C3 83 DUP4 18C4 60 PUSH1 0x20 18C6 03 SUB 18C7 61 PUSH2 0x0100 18CA 0A EXP 18CB 03 SUB 18CC 80 DUP1 18CD 19 NOT 18CE 82 DUP3 18CF 51 MLOAD 18D0 16 AND 18D1 81 DUP2 18D2 84 DUP5 18D3 51 MLOAD 18D4 16 AND 18D5 80 DUP1 18D6 82 DUP3 18D7 17 OR 18D8 85 DUP6 18D9 52 MSTORE 18DA 50 POP 18DB 50 POP 18DC 50 POP 18DD 50 POP 18DE 50 POP 18DF 50 POP 18E0 90 SWAP1 18E1 50 POP 18E2 01 ADD 18E3 80 DUP1 18E4 60 PUSH1 0x2f 18E6 60 PUSH1 0xf8 18E8 1B SHL 18E9 81 DUP2 18EA 52 MSTORE 18EB 50 POP 18EC 60 PUSH1 0x01 18EE 01 ADD 18EF 83 DUP4 18F0 80 DUP1 18F1 51 MLOAD 18F2 90 SWAP1 18F3 60 PUSH1 0x20 18F5 01 ADD 18F6 90 SWAP1 18F7 80 DUP1 18F8 83 DUP4 18F9 83 DUP4 18FA 5B JUMPDEST 18FB 60 PUSH1 0x20 18FD 83 DUP4 18FE 10 LT 18FF 61 PUSH2 0x1919 1902 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @18D9 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @18EA memory[stack[-4] + stack[-6]:stack[-4] + stack[-6] + 0x20] = 0x2f << 0xf8 // @18EE stack[-6] = 0x01 + stack[-4] + stack[-6] // @18F6 stack[-5] = 0x20 + stack[-9] // @18F6 stack[-4] = memory[stack[-9]:stack[-9] + 0x20] // @18F7 stack[-3] = memory[stack[-9]:stack[-9] + 0x20] // @18F8 stack[-2] = 0x01 + stack[-4] + stack[-6] // @18F9 stack[-1] = 0x20 + stack[-9] // } // Block ends with conditional jump to 0x1919, if memory[stack[-9]:stack[-9] + 0x20] < 0x20 label_1903: // Incoming jump from 0x1902, if not stack[-3] < 0x20 // Incoming jump from 0x1902, if not memory[stack[-9]:stack[-9] + 0x20] < 0x20 // Inputs[4] // { // @1903 stack[-1] // @1904 memory[stack[-1]:stack[-1] + 0x20] // @1905 stack[-2] // @190B stack[-3] // } 1903 80 DUP1 1904 51 MLOAD 1905 82 DUP3 1906 52 MSTORE 1907 60 PUSH1 0x1f 1909 19 NOT 190A 90 SWAP1 190B 92 SWAP3 190C 01 ADD 190D 91 SWAP2 190E 60 PUSH1 0x20 1910 91 SWAP2 1911 82 DUP3 1912 01 ADD 1913 91 SWAP2 1914 01 ADD 1915 61 PUSH2 0x18fa 1918 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1906 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @190D stack[-3] = stack[-3] + ~0x1f // @1913 stack[-2] = 0x20 + stack[-2] // @1914 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x18fa label_1919: // Incoming jump from 0x1902, if stack[-3] < 0x20 // Incoming jump from 0x1902, if memory[stack[-9]:stack[-9] + 0x20] < 0x20 // Inputs[10] // { // @191C stack[-3] // @1927 stack[-1] // @1928 memory[stack[-1]:stack[-1] + 0x20] // @192B stack[-2] // @192C memory[stack[-2]:stack[-2] + 0x20] // @1939 stack[-4] // @1939 stack[-5] // @193B stack[-6] // @1948 stack[-8] // @194A memory[stack[-8]:stack[-8] + 0x20] // } 1919 5B JUMPDEST 191A 60 PUSH1 0x01 191C 83 DUP4 191D 60 PUSH1 0x20 191F 03 SUB 1920 61 PUSH2 0x0100 1923 0A EXP 1924 03 SUB 1925 80 DUP1 1926 19 NOT 1927 82 DUP3 1928 51 MLOAD 1929 16 AND 192A 81 DUP2 192B 84 DUP5 192C 51 MLOAD 192D 16 AND 192E 80 DUP1 192F 82 DUP3 1930 17 OR 1931 85 DUP6 1932 52 MSTORE 1933 50 POP 1934 50 POP 1935 50 POP 1936 50 POP 1937 50 POP 1938 50 POP 1939 90 SWAP1 193A 50 POP 193B 01 ADD 193C 80 DUP1 193D 60 PUSH1 0x2f 193F 60 PUSH1 0xf8 1941 1B SHL 1942 81 DUP2 1943 52 MSTORE 1944 50 POP 1945 60 PUSH1 0x01 1947 01 ADD 1948 82 DUP3 1949 80 DUP1 194A 51 MLOAD 194B 90 SWAP1 194C 60 PUSH1 0x20 194E 01 ADD 194F 90 SWAP1 1950 80 DUP1 1951 83 DUP4 1952 83 DUP4 1953 5B JUMPDEST 1954 60 PUSH1 0x20 1956 83 DUP4 1957 10 LT 1958 61 PUSH2 0x1972 195B 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @1932 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @1943 memory[stack[-4] + stack[-6]:stack[-4] + stack[-6] + 0x20] = 0x2f << 0xf8 // @1947 stack[-6] = 0x01 + stack[-4] + stack[-6] // @194F stack[-5] = 0x20 + stack[-8] // @194F stack[-4] = memory[stack[-8]:stack[-8] + 0x20] // @1950 stack[-3] = memory[stack[-8]:stack[-8] + 0x20] // @1951 stack[-2] = 0x01 + stack[-4] + stack[-6] // @1952 stack[-1] = 0x20 + stack[-8] // } // Block ends with conditional jump to 0x1972, if memory[stack[-8]:stack[-8] + 0x20] < 0x20 label_195C: // Incoming jump from 0x195B, if not stack[-3] < 0x20 // Incoming jump from 0x195B, if not memory[stack[-8]:stack[-8] + 0x20] < 0x20 // Inputs[4] // { // @195C stack[-1] // @195D memory[stack[-1]:stack[-1] + 0x20] // @195E stack[-2] // @1964 stack[-3] // } 195C 80 DUP1 195D 51 MLOAD 195E 82 DUP3 195F 52 MSTORE 1960 60 PUSH1 0x1f 1962 19 NOT 1963 90 SWAP1 1964 92 SWAP3 1965 01 ADD 1966 91 SWAP2 1967 60 PUSH1 0x20 1969 91 SWAP2 196A 82 DUP3 196B 01 ADD 196C 91 SWAP2 196D 01 ADD 196E 61 PUSH2 0x1953 1971 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @195F memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1966 stack[-3] = stack[-3] + ~0x1f // @196C stack[-2] = 0x20 + stack[-2] // @196D stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1953 label_1972: // Incoming jump from 0x195B, if stack[-3] < 0x20 // Incoming jump from 0x195B, if memory[stack[-8]:stack[-8] + 0x20] < 0x20 // Inputs[10] // { // @1973 memory[stack[-1]:stack[-1] + 0x20] // @1973 stack[-1] // @1974 stack[-2] // @1975 memory[stack[-2]:stack[-2] + 0x20] // @1978 stack[-3] // @19B2 stack[-6] // @19B3 stack[-4] // @19BB memory[0x40:0x60] // @19CC stack[-16] // @19CD stack[-15] // } 1972 5B JUMPDEST 1973 51 MLOAD 1974 81 DUP2 1975 51 MLOAD 1976 60 PUSH1 0x20 1978 93 SWAP4 1979 90 SWAP1 197A 93 SWAP4 197B 03 SUB 197C 61 PUSH2 0x0100 197F 0A EXP 1980 60 PUSH1 0x00 1982 19 NOT 1983 01 ADD 1984 80 DUP1 1985 19 NOT 1986 90 SWAP1 1987 91 SWAP2 1988 16 AND 1989 92 SWAP3 198A 16 AND 198B 91 SWAP2 198C 90 SWAP1 198D 91 SWAP2 198E 17 OR 198F 90 SWAP1 1990 52 MSTORE 1991 7F PUSH32 0x2f76330000000000000000000000000000000000000000000000000000000000 19B2 92 SWAP3 19B3 01 ADD 19B4 91 SWAP2 19B5 82 DUP3 19B6 52 MSTORE 19B7 50 POP 19B8 60 PUSH1 0x40 19BA 80 DUP1 19BB 51 MLOAD 19BC 80 DUP1 19BD 83 DUP4 19BE 03 SUB 19BF 60 PUSH1 0x1c 19C1 19 NOT 19C2 01 ADD 19C3 81 DUP2 19C4 52 MSTORE 19C5 60 PUSH1 0x03 19C7 90 SWAP1 19C8 92 SWAP3 19C9 01 ADD 19CA 90 SWAP1 19CB 52 MSTORE 19CC 99 SWAP10 19CD 98 SWAP9 19CE 50 POP 19CF 50 POP 19D0 50 POP 19D1 50 POP 19D2 50 POP 19D3 50 POP 19D4 50 POP 19D5 50 POP 19D6 50 POP 19D7 56 *JUMP // Stack delta = -15 // Outputs[5] // { // @1990 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-2]:stack[-2] + 0x20] & ~0x00 + 0x0100 ** (0x20 - stack[-3])) | (memory[stack[-1]:stack[-1] + 0x20] & ~(~0x00 + 0x0100 ** (0x20 - stack[-3]))) // @19B6 memory[stack[-6] + stack[-4]:stack[-6] + stack[-4] + 0x20] = 0x2f76330000000000000000000000000000000000000000000000000000000000 // @19C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0x1c + ((stack[-6] + stack[-4]) - memory[0x40:0x60]) // @19CB memory[0x40:0x60] = stack[-6] + stack[-4] + 0x03 // @19CC stack[-16] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-16] label_19D8: // Incoming jump from 0x08EC // Inputs[1] { @19DE address(this) } 19D8 5B JUMPDEST 19D9 60 PUSH1 0x60 19DB 61 PUSH2 0x19e3 19DE 30 ADDRESS 19DF 61 PUSH2 0x220e 19E2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @19D9 stack[0] = 0x60 // @19DB stack[1] = 0x19e3 // @19DE stack[2] = address(this) // } // Block ends with call to 0x220e, returns to 0x19E3 label_19E3: // Incoming return from call to 0x220E at 0x19E2 // Inputs[3] // { // @19E6 memory[0x40:0x60] // @19F5 stack[-1] // @19F7 memory[stack[-1]:stack[-1] + 0x20] // } 19E3 5B JUMPDEST 19E4 60 PUSH1 0x40 19E6 51 MLOAD 19E7 60 PUSH1 0x20 19E9 01 ADD 19EA 80 DUP1 19EB 60 PUSH1 0x30 19ED 61 PUSH2 0x2e08 19F0 82 DUP3 19F1 39 CODECOPY 19F2 60 PUSH1 0x30 19F4 01 ADD 19F5 82 DUP3 19F6 80 DUP1 19F7 51 MLOAD 19F8 90 SWAP1 19F9 60 PUSH1 0x20 19FB 01 ADD 19FC 90 SWAP1 19FD 80 DUP1 19FE 83 DUP4 19FF 83 DUP4 1A00 5B JUMPDEST 1A01 60 PUSH1 0x20 1A03 83 DUP4 1A04 10 LT 1A05 61 PUSH2 0x1a1f 1A08 57 *JUMPI // Stack delta = +7 // Outputs[8] // { // @19E9 stack[0] = 0x20 + memory[0x40:0x60] // @19F1 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x30] = code[0x2e08:0x2e38] // @19F4 stack[1] = 0x30 + 0x20 + memory[0x40:0x60] // @19FC stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @19FC stack[2] = 0x20 + stack[-1] // @19FD stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @19FE stack[5] = 0x30 + 0x20 + memory[0x40:0x60] // @19FF stack[6] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x1a1f, if memory[stack[-1]:stack[-1] + 0x20] < 0x20 label_1A09: // Incoming jump from 0x1A08, if not memory[stack[-1]:stack[-1] + 0x20] < 0x20 // Incoming jump from 0x1A08, if not stack[-3] < 0x20 // Inputs[4] // { // @1A09 stack[-1] // @1A0A memory[stack[-1]:stack[-1] + 0x20] // @1A0B stack[-2] // @1A11 stack[-3] // } 1A09 80 DUP1 1A0A 51 MLOAD 1A0B 82 DUP3 1A0C 52 MSTORE 1A0D 60 PUSH1 0x1f 1A0F 19 NOT 1A10 90 SWAP1 1A11 92 SWAP3 1A12 01 ADD 1A13 91 SWAP2 1A14 60 PUSH1 0x20 1A16 91 SWAP2 1A17 82 DUP3 1A18 01 ADD 1A19 91 SWAP2 1A1A 01 ADD 1A1B 61 PUSH2 0x1a00 1A1E 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1A0C memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1A13 stack[-3] = stack[-3] + ~0x1f // @1A19 stack[-2] = 0x20 + stack[-2] // @1A1A stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1a00 label_1A1F: // Incoming jump from 0x1A08, if memory[stack[-1]:stack[-1] + 0x20] < 0x20 // Incoming jump from 0x1A08, if stack[-3] < 0x20 // Inputs[11] // { // @1A22 stack[-3] // @1A2D stack[-1] // @1A2E memory[stack[-1]:stack[-1] + 0x20] // @1A31 stack[-2] // @1A32 memory[stack[-2]:stack[-2] + 0x20] // @1A3F stack[-4] // @1A3F stack[-5] // @1A41 stack[-6] // @1A42 stack[-8] // @1A47 memory[0x40:0x60] // @1A54 stack[-9] // } 1A1F 5B JUMPDEST 1A20 60 PUSH1 0x01 1A22 83 DUP4 1A23 60 PUSH1 0x20 1A25 03 SUB 1A26 61 PUSH2 0x0100 1A29 0A EXP 1A2A 03 SUB 1A2B 80 DUP1 1A2C 19 NOT 1A2D 82 DUP3 1A2E 51 MLOAD 1A2F 16 AND 1A30 81 DUP2 1A31 84 DUP5 1A32 51 MLOAD 1A33 16 AND 1A34 80 DUP1 1A35 82 DUP3 1A36 17 OR 1A37 85 DUP6 1A38 52 MSTORE 1A39 50 POP 1A3A 50 POP 1A3B 50 POP 1A3C 50 POP 1A3D 50 POP 1A3E 50 POP 1A3F 90 SWAP1 1A40 50 POP 1A41 01 ADD 1A42 91 SWAP2 1A43 50 POP 1A44 50 POP 1A45 60 PUSH1 0x40 1A47 51 MLOAD 1A48 60 PUSH1 0x20 1A4A 81 DUP2 1A4B 83 DUP4 1A4C 03 SUB 1A4D 03 SUB 1A4E 81 DUP2 1A4F 52 MSTORE 1A50 90 SWAP1 1A51 60 PUSH1 0x40 1A53 52 MSTORE 1A54 90 SWAP1 1A55 50 POP // Stack delta = -8 // Outputs[4] // { // @1A38 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @1A4F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (stack[-4] + stack[-6]) - memory[0x40:0x60] - 0x20 // @1A53 memory[0x40:0x60] = stack[-4] + stack[-6] // @1A54 stack[-9] = memory[0x40:0x60] // } // Block continues label_1A56: // Incoming jump from 0x1A55 // Incoming return from call to 0x2C9C at 0x2CCE // Inputs[2] // { // @1A57 stack[-2] // @1A57 stack[-1] // } 1A56 5B JUMPDEST 1A57 90 SWAP1 1A58 56 *JUMP // Stack delta = -1 // Outputs[1] { @1A57 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_1A59: // Incoming call from 0x110A, returns to 0x110B // Incoming call from 0x259A, returns to 0x259B // Incoming call from 0x0BA4, returns to 0x0BA5 // Incoming jump from 0x0927 // Inputs[6] // { // @1A62 stack[-2] // @1A75 memory[0x00:0x40] // @1A76 stack[-1] // @1A80 memory[0x00:0x40] // @1A81 storage[keccak256(memory[0x00:0x40])] // @1A85 stack[-3] // } 1A59 5B JUMPDEST 1A5A 60 PUSH1 0x01 1A5C 60 PUSH1 0x01 1A5E 60 PUSH1 0xa0 1A60 1B SHL 1A61 03 SUB 1A62 91 SWAP2 1A63 82 DUP3 1A64 16 AND 1A65 60 PUSH1 0x00 1A67 90 SWAP1 1A68 81 DUP2 1A69 52 MSTORE 1A6A 60 PUSH1 0x13 1A6C 60 PUSH1 0x20 1A6E 90 SWAP1 1A6F 81 DUP2 1A70 52 MSTORE 1A71 60 PUSH1 0x40 1A73 80 DUP1 1A74 83 DUP4 1A75 20 SHA3 1A76 93 SWAP4 1A77 90 SWAP1 1A78 94 SWAP5 1A79 16 AND 1A7A 82 DUP3 1A7B 52 MSTORE 1A7C 91 SWAP2 1A7D 90 SWAP1 1A7E 91 SWAP2 1A7F 52 MSTORE 1A80 20 SHA3 1A81 54 SLOAD 1A82 60 PUSH1 0xff 1A84 16 AND 1A85 90 SWAP1 1A86 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @1A69 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1A70 memory[0x20:0x40] = 0x13 // @1A7B memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1A7F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1A85 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1A87: // Incoming jump from 0x0D64 // Incoming jump from 0x0933 // Incoming jump from 0x21C6 // Inputs[2] // { // @1A8A stack[-4] // @1A8B stack[-3] // } 1A87 5B JUMPDEST 1A88 60 PUSH1 0x01 1A8A 84 DUP5 1A8B 84 DUP5 1A8C 03 SUB 1A8D 01 ADD 1A8E 60 PUSH1 0x64 1A90 81 DUP2 1A91 11 GT 1A92 15 ISZERO 1A93 61 PUSH2 0x1ae3 1A96 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A8D stack[0] = stack[-3] - stack[-4] + 0x01 } // Block ends with conditional jump to 0x1ae3, if !(stack[-3] - stack[-4] + 0x01 > 0x64) label_1A97: // Incoming jump from 0x1A96, if not !(stack[-3] - stack[-4] + 0x01 > 0x64) // Inputs[3] // { // @1A9A memory[0x40:0x60] // @1AD9 memory[0x40:0x60] // @1AE2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1A97 60 PUSH1 0x40 1A99 80 DUP1 1A9A 51 MLOAD 1A9B 62 PUSH3 0x461bcd 1A9F 60 PUSH1 0xe5 1AA1 1B SHL 1AA2 81 DUP2 1AA3 52 MSTORE 1AA4 60 PUSH1 0x20 1AA6 60 PUSH1 0x04 1AA8 82 DUP3 1AA9 01 ADD 1AAA 52 MSTORE 1AAB 60 PUSH1 0x15 1AAD 60 PUSH1 0x24 1AAF 82 DUP3 1AB0 01 ADD 1AB1 52 MSTORE 1AB2 7F PUSH32 0x4c656e677468206d757374206265203c3d203130300000000000000000000000 1AD3 60 PUSH1 0x44 1AD5 82 DUP3 1AD6 01 ADD 1AD7 52 MSTORE 1AD8 90 SWAP1 1AD9 51 MLOAD 1ADA 90 SWAP1 1ADB 81 DUP2 1ADC 90 SWAP1 1ADD 03 SUB 1ADE 60 PUSH1 0x64 1AE0 01 ADD 1AE1 90 SWAP1 1AE2 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1AA3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1AAA memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1AB1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x15 // @1AD7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4c656e677468206d757374206265203c3d203130300000000000000000000000 // @1AE2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1AE3: // Incoming jump from 0x1A96, if !(stack[-3] - stack[-4] + 0x01 > 0x64) // Inputs[1] { @1AE7 stack[-1] } 1AE3 5B JUMPDEST 1AE4 60 PUSH1 0x00 1AE6 5B JUMPDEST 1AE7 81 DUP2 1AE8 81 DUP2 1AE9 10 LT 1AEA 15 ISZERO 1AEB 61 PUSH2 0x1bfb 1AEE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1AE4 stack[0] = 0x00 } // Block ends with conditional jump to 0x1bfb, if !(0x00 < stack[-1]) label_1AEF: // Incoming jump from 0x1AEE, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x1AEE, if not !(0x00 < stack[-1]) // Inputs[2] // { // @1AEF stack[-6] // @1AF0 stack[-1] // } 1AEF 85 DUP6 1AF0 81 DUP2 1AF1 01 ADD 1AF2 60 PUSH1 0x00 1AF4 61 PUSH2 0x1afc 1AF7 82 DUP3 1AF8 61 PUSH2 0x0dda 1AFB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1AF1 stack[0] = stack[-1] + stack[-6] // @1AF2 stack[1] = 0x00 // @1AF4 stack[2] = 0x1afc // @1AF7 stack[3] = stack[-1] + stack[-6] // } // Block ends with call to 0x0dda, returns to 0x1AFC label_1AFC: // Incoming return from call to 0x0DDA at 0x1AFB // Incoming return from call to 0x0DDA at 0x1AFB // Inputs[3] // { // @1AFD stack[-2] // @1AFD stack[-1] // @1B09 stack[-7] // } 1AFC 5B JUMPDEST 1AFD 90 SWAP1 1AFE 50 POP 1AFF 80 DUP1 1B00 60 PUSH1 0x01 1B02 60 PUSH1 0x01 1B04 60 PUSH1 0xa0 1B06 1B SHL 1B07 03 SUB 1B08 16 AND 1B09 86 DUP7 1B0A 60 PUSH1 0x01 1B0C 60 PUSH1 0x01 1B0E 60 PUSH1 0xa0 1B10 1B SHL 1B11 03 SUB 1B12 16 AND 1B13 14 EQ 1B14 61 PUSH2 0x1b64 1B17 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1AFD stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1b64, if (0x01 << 0xa0) - 0x01 & stack[-7] == (0x01 << 0xa0) - 0x01 & stack[-1] label_1B18: // Incoming jump from 0x1B17, if not (0x01 << 0xa0) - 0x01 & stack[-7] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[3] // { // @1B1B memory[0x40:0x60] // @1B5A memory[0x40:0x60] // @1B63 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1B18 60 PUSH1 0x40 1B1A 80 DUP1 1B1B 51 MLOAD 1B1C 62 PUSH3 0x461bcd 1B20 60 PUSH1 0xe5 1B22 1B SHL 1B23 81 DUP2 1B24 52 MSTORE 1B25 60 PUSH1 0x20 1B27 60 PUSH1 0x04 1B29 82 DUP3 1B2A 01 ADD 1B2B 52 MSTORE 1B2C 60 PUSH1 0x16 1B2E 60 PUSH1 0x24 1B30 82 DUP3 1B31 01 ADD 1B32 52 MSTORE 1B33 7F PUSH32 0x46726f6d2061646472657373206e6f74206f776e657200000000000000000000 1B54 60 PUSH1 0x44 1B56 82 DUP3 1B57 01 ADD 1B58 52 MSTORE 1B59 90 SWAP1 1B5A 51 MLOAD 1B5B 90 SWAP1 1B5C 81 DUP2 1B5D 90 SWAP1 1B5E 03 SUB 1B5F 60 PUSH1 0x64 1B61 01 ADD 1B62 90 SWAP1 1B63 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1B24 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B2B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1B32 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x16 // @1B58 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x46726f6d2061646472657373206e6f74206f776e657200000000000000000000 // @1B63 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1B64: // Incoming jump from 0x1B17, if (0x01 << 0xa0) - 0x01 & stack[-7] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[2] // { // @1B68 msg.sender // @1B69 stack[-2] // } 1B64 5B JUMPDEST 1B65 61 PUSH2 0x1b6e 1B68 33 CALLER 1B69 83 DUP4 1B6A 61 PUSH2 0x24ff 1B6D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B65 stack[0] = 0x1b6e // @1B68 stack[1] = msg.sender // @1B69 stack[2] = stack[-2] // } // Block ends with call to 0x24ff, returns to 0x1B6E label_1B6E: // Incoming return from call to 0x24FF at 0x1B6D // Inputs[1] { @1B72 stack[-1] } 1B6E 5B JUMPDEST 1B6F 61 PUSH2 0x1ba9 1B72 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1ba9, if stack[-1] label_1B73: // Incoming jump from 0x1B72, if not stack[-1] // Inputs[3] // { // @1B75 memory[0x40:0x60] // @1BA3 memory[0x40:0x60] // @1BA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1B73 60 PUSH1 0x40 1B75 51 MLOAD 1B76 62 PUSH3 0x461bcd 1B7A 60 PUSH1 0xe5 1B7C 1B SHL 1B7D 81 DUP2 1B7E 52 MSTORE 1B7F 60 PUSH1 0x04 1B81 01 ADD 1B82 80 DUP1 1B83 80 DUP1 1B84 60 PUSH1 0x20 1B86 01 ADD 1B87 82 DUP3 1B88 81 DUP2 1B89 03 SUB 1B8A 82 DUP3 1B8B 52 MSTORE 1B8C 60 PUSH1 0x31 1B8E 81 DUP2 1B8F 52 MSTORE 1B90 60 PUSH1 0x20 1B92 01 ADD 1B93 80 DUP1 1B94 61 PUSH2 0x2dd7 1B97 60 PUSH1 0x31 1B99 91 SWAP2 1B9A 39 CODECOPY 1B9B 60 PUSH1 0x40 1B9D 01 ADD 1B9E 91 SWAP2 1B9F 50 POP 1BA0 50 POP 1BA1 60 PUSH1 0x40 1BA3 51 MLOAD 1BA4 80 DUP1 1BA5 91 SWAP2 1BA6 03 SUB 1BA7 90 SWAP1 1BA8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1B7E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B8B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1B8F memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x31 // @1B9A memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x31] = code[0x2dd7:0x2e08] // @1BA8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1BA9: // Incoming jump from 0x1B72, if stack[-1] // Inputs[7] // { // @1BAD stack[-2] // @1BBB memory[0x00:0x40] // @1BBD storage[keccak256(memory[0x00:0x40])] // @1BE1 memory[0x00:0x40] // @1BE3 storage[keccak256(memory[0x00:0x40])] // @1BEF stack[-5] // @1BF6 stack[-3] // } 1BA9 5B JUMPDEST 1BAA 50 POP 1BAB 60 PUSH1 0x00 1BAD 90 SWAP1 1BAE 81 DUP2 1BAF 52 MSTORE 1BB0 60 PUSH1 0x12 1BB2 60 PUSH1 0x20 1BB4 90 SWAP1 1BB5 81 DUP2 1BB6 52 MSTORE 1BB7 60 PUSH1 0x40 1BB9 80 DUP1 1BBA 83 DUP4 1BBB 20 SHA3 1BBC 80 DUP1 1BBD 54 SLOAD 1BBE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BD3 19 NOT 1BD4 90 SWAP1 1BD5 81 DUP2 1BD6 16 AND 1BD7 90 SWAP1 1BD8 91 SWAP2 1BD9 55 SSTORE 1BDA 60 PUSH1 0x14 1BDC 90 SWAP1 1BDD 92 SWAP3 1BDE 52 MSTORE 1BDF 90 SWAP1 1BE0 91 SWAP2 1BE1 20 SHA3 1BE2 80 DUP1 1BE3 54 SLOAD 1BE4 90 SWAP1 1BE5 91 SWAP2 1BE6 16 AND 1BE7 60 PUSH1 0x01 1BE9 60 PUSH1 0x01 1BEB 60 PUSH1 0xa0 1BED 1B SHL 1BEE 03 SUB 1BEF 85 DUP6 1BF0 16 AND 1BF1 17 OR 1BF2 90 SWAP1 1BF3 55 SSTORE 1BF4 60 PUSH1 0x01 1BF6 01 ADD 1BF7 61 PUSH2 0x1ae6 1BFA 56 *JUMP // Stack delta = -2 // Outputs[6] // { // @1BAF memory[0x00:0x20] = stack[-2] // @1BB6 memory[0x20:0x40] = 0x12 // @1BD9 storage[keccak256(memory[0x00:0x40])] = ~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // @1BDE memory[0x20:0x40] = 0x14 // @1BF3 storage[keccak256(memory[0x00:0x40])] = (stack[-5] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @1BF6 stack[-3] = 0x01 + stack[-3] // } // Block ends with unconditional jump to 0x1ae6 label_1BFB: // Incoming jump from 0x1AEE, if !(stack[-1] < stack[-2]) // Incoming jump from 0x1AEE, if !(0x00 < stack[-1]) // Inputs[4] // { // @1C05 stack[-4] // @1C14 memory[0x00:0x40] // @1C15 storage[keccak256(memory[0x00:0x40])] // @1C1A stack[-2] // } 1BFB 5B JUMPDEST 1BFC 50 POP 1BFD 60 PUSH1 0x01 1BFF 60 PUSH1 0x01 1C01 60 PUSH1 0xa0 1C03 1B SHL 1C04 03 SUB 1C05 83 DUP4 1C06 16 AND 1C07 60 PUSH1 0x00 1C09 90 SWAP1 1C0A 81 DUP2 1C0B 52 MSTORE 1C0C 60 PUSH1 0x15 1C0E 60 PUSH1 0x20 1C10 52 MSTORE 1C11 60 PUSH1 0x40 1C13 90 SWAP1 1C14 20 SHA3 1C15 54 SLOAD 1C16 61 PUSH2 0x1c25 1C19 90 SWAP1 1C1A 82 DUP3 1C1B 63 PUSH4 0xffffffff 1C20 61 PUSH2 0x1d2f 1C23 16 AND 1C24 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1C0B memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1C10 memory[0x20:0x40] = 0x15 // @1C19 stack[-1] = 0x1c25 // @1C19 stack[0] = storage[keccak256(memory[0x00:0x40])] // @1C1A stack[1] = stack[-2] // } // Block ends with unconditional jump to 0x1d2f & 0xffffffff 1C25 5B JUMPDEST 1C26 60 PUSH1 0x01 1C28 60 PUSH1 0x01 1C2A 60 PUSH1 0xa0 1C2C 1B SHL 1C2D 03 SUB 1C2E 80 DUP1 1C2F 85 DUP6 1C30 16 AND 1C31 60 PUSH1 0x00 1C33 90 SWAP1 1C34 81 DUP2 1C35 52 MSTORE 1C36 60 PUSH1 0x15 1C38 60 PUSH1 0x20 1C3A 52 MSTORE 1C3B 60 PUSH1 0x40 1C3D 90 SWAP1 1C3E 20 SHA3 1C3F 91 SWAP2 1C40 90 SWAP1 1C41 91 SWAP2 1C42 55 SSTORE 1C43 82 DUP3 1C44 16 AND 1C45 15 ISZERO 1C46 61 PUSH2 0x1c8c 1C49 57 *JUMPI 1C4A 60 PUSH1 0x01 1C4C 60 PUSH1 0x01 1C4E 60 PUSH1 0xa0 1C50 1B SHL 1C51 03 SUB 1C52 82 DUP3 1C53 16 AND 1C54 60 PUSH1 0x00 1C56 90 SWAP1 1C57 81 DUP2 1C58 52 MSTORE 1C59 60 PUSH1 0x15 1C5B 60 PUSH1 0x20 1C5D 52 MSTORE 1C5E 60 PUSH1 0x40 1C60 90 SWAP1 1C61 20 SHA3 1C62 54 SLOAD 1C63 61 PUSH2 0x1c72 1C66 90 SWAP1 1C67 82 DUP3 1C68 63 PUSH4 0xffffffff 1C6D 61 PUSH2 0x1f91 1C70 16 AND 1C71 56 *JUMP 1C72 5B JUMPDEST 1C73 60 PUSH1 0x01 1C75 60 PUSH1 0x01 1C77 60 PUSH1 0xa0 1C79 1B SHL 1C7A 03 SUB 1C7B 83 DUP4 1C7C 16 AND 1C7D 60 PUSH1 0x00 1C7F 90 SWAP1 1C80 81 DUP2 1C81 52 MSTORE 1C82 60 PUSH1 0x15 1C84 60 PUSH1 0x20 1C86 52 MSTORE 1C87 60 PUSH1 0x40 1C89 90 SWAP1 1C8A 20 SHA3 1C8B 55 SSTORE 1C8C 5B JUMPDEST 1C8D 60 PUSH1 0x01 1C8F 81 DUP2 1C90 11 GT 1C91 15 ISZERO 1C92 61 PUSH2 0x1ce6 1C95 57 *JUMPI 1C96 81 DUP2 1C97 60 PUSH1 0x01 1C99 60 PUSH1 0x01 1C9B 60 PUSH1 0xa0 1C9D 1B SHL 1C9E 03 SUB 1C9F 16 AND 1CA0 83 DUP4 1CA1 60 PUSH1 0x01 1CA3 60 PUSH1 0x01 1CA5 60 PUSH1 0xa0 1CA7 1B SHL 1CA8 03 SUB 1CA9 16 AND 1CAA 86 DUP7 1CAB 7F PUSH32 0xdeaa91b6123d068f5821d0fb0678463d1a8a6079fe8af5de3ce5e896dcf9133d 1CCC 87 DUP8 1CCD 60 PUSH1 0x40 1CCF 51 MLOAD 1CD0 80 DUP1 1CD1 82 DUP3 1CD2 81 DUP2 1CD3 52 MSTORE 1CD4 60 PUSH1 0x20 1CD6 01 ADD 1CD7 91 SWAP2 1CD8 50 POP 1CD9 50 POP 1CDA 60 PUSH1 0x40 1CDC 51 MLOAD 1CDD 80 DUP1 1CDE 91 SWAP2 1CDF 03 SUB 1CE0 90 SWAP1 1CE1 A4 LOG4 1CE2 61 PUSH2 0x1d28 1CE5 56 *JUMP 1CE6 5B JUMPDEST 1CE7 84 DUP5 1CE8 82 DUP3 1CE9 60 PUSH1 0x01 1CEB 60 PUSH1 0x01 1CED 60 PUSH1 0xa0 1CEF 1B SHL 1CF0 03 SUB 1CF1 16 AND 1CF2 84 DUP5 1CF3 60 PUSH1 0x01 1CF5 60 PUSH1 0x01 1CF7 60 PUSH1 0xa0 1CF9 1B SHL 1CFA 03 SUB 1CFB 16 AND 1CFC 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1D1D 60 PUSH1 0x40 1D1F 51 MLOAD 1D20 60 PUSH1 0x40 1D22 51 MLOAD 1D23 80 DUP1 1D24 91 SWAP2 1D25 03 SUB 1D26 90 SWAP1 1D27 A4 LOG4 1D28 5B JUMPDEST 1D29 50 POP 1D2A 50 POP 1D2B 50 POP 1D2C 50 POP 1D2D 50 POP 1D2E 56 *JUMP label_1D2F: // Incoming jump from 0x1C24 // Inputs[3] // { // @1D35 stack[-2] // @1D36 stack[-1] // @1D39 memory[0x40:0x60] // } 1D2F 5B JUMPDEST 1D30 60 PUSH1 0x00 1D32 61 PUSH2 0x1d71 1D35 83 DUP4 1D36 83 DUP4 1D37 60 PUSH1 0x40 1D39 51 MLOAD 1D3A 80 DUP1 1D3B 60 PUSH1 0x40 1D3D 01 ADD 1D3E 60 PUSH1 0x40 1D40 52 MSTORE 1D41 80 DUP1 1D42 60 PUSH1 0x1e 1D44 81 DUP2 1D45 52 MSTORE 1D46 60 PUSH1 0x20 1D48 01 ADD 1D49 7F PUSH32 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 1D6A 81 DUP2 1D6B 52 MSTORE 1D6C 50 POP 1D6D 61 PUSH2 0x25a3 1D70 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @1D30 stack[0] = 0x00 // @1D32 stack[1] = 0x1d71 // @1D35 stack[2] = stack[-2] // @1D36 stack[3] = stack[-1] // @1D39 stack[4] = memory[0x40:0x60] // @1D40 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1D45 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1e // @1D6B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 // } // Block ends with call to 0x25a3, returns to 0x1D71 label_1D71: // Incoming jump from 0x2645, if !stack[-1] // Incoming jump from 0x264F, if stack[-3] == storage[stack[-4]] // Incoming return from call to 0x25A3 at 0x1D70 // Incoming jump from 0x1F9E, if !(stack[-1] + stack[-2] < stack[-2]) // Inputs[3] // { // @1D72 stack[-1] // @1D72 stack[-5] // @1D73 stack[-4] // } 1D71 5B JUMPDEST 1D72 93 SWAP4 1D73 92 SWAP3 1D74 50 POP 1D75 50 POP 1D76 50 POP 1D77 56 *JUMP // Stack delta = -4 // Outputs[1] { @1D72 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1D78: // Incoming call from 0x1646, returns to 0x1647 // Incoming call from 0x0E7F, returns to 0x0E80 // Inputs[3] // { // @1D7B stack[-1] // @1D86 memory[0x00:0x40] // @1D87 storage[keccak256(memory[0x00:0x40])] // } 1D78 5B JUMPDEST 1D79 60 PUSH1 0x00 1D7B 81 DUP2 1D7C 81 DUP2 1D7D 52 MSTORE 1D7E 60 PUSH1 0x08 1D80 60 PUSH1 0x20 1D82 52 MSTORE 1D83 60 PUSH1 0x40 1D85 81 DUP2 1D86 20 SHA3 1D87 54 SLOAD 1D88 81 DUP2 1D89 90 SWAP1 1D8A 81 DUP2 1D8B 90 SWAP1 1D8C 81 DUP2 1D8D 90 SWAP1 1D8E 60 PUSH1 0xff 1D90 16 AND 1D91 15 ISZERO 1D92 15 ISZERO 1D93 60 PUSH1 0x01 1D95 14 EQ 1D96 15 ISZERO 1D97 61 PUSH2 0x1dde 1D9A 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @1D79 stack[0] = 0x00 // @1D7D memory[0x00:0x20] = stack[-1] // @1D82 memory[0x20:0x40] = 0x08 // @1D89 stack[1] = 0x00 // @1D8B stack[2] = 0x00 // @1D8D stack[3] = 0x00 // } // Block ends with conditional jump to 0x1dde, if !(0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])])) label_1D9B: // Incoming jump from 0x1D9A, if not !(0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])])) // Inputs[3] // { // @1D9E memory[0x40:0x60] // @1DD4 memory[0x40:0x60] // @1DDD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1D9B 60 PUSH1 0x40 1D9D 80 DUP1 1D9E 51 MLOAD 1D9F 62 PUSH3 0x461bcd 1DA3 60 PUSH1 0xe5 1DA5 1B SHL 1DA6 81 DUP2 1DA7 52 MSTORE 1DA8 60 PUSH1 0x20 1DAA 60 PUSH1 0x04 1DAC 82 DUP3 1DAD 01 ADD 1DAE 52 MSTORE 1DAF 60 PUSH1 0x14 1DB1 60 PUSH1 0x24 1DB3 82 DUP3 1DB4 01 ADD 1DB5 52 MSTORE 1DB6 73 PUSH20 0x151bdad95b88191bd95cc81b9bdd08195e1a5cdd 1DCB 60 PUSH1 0x62 1DCD 1B SHL 1DCE 60 PUSH1 0x44 1DD0 82 DUP3 1DD1 01 ADD 1DD2 52 MSTORE 1DD3 90 SWAP1 1DD4 51 MLOAD 1DD5 90 SWAP1 1DD6 81 DUP2 1DD7 90 SWAP1 1DD8 03 SUB 1DD9 60 PUSH1 0x64 1DDB 01 ADD 1DDC 90 SWAP1 1DDD FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1DA7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1DAE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1DB5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @1DD2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x151bdad95b88191bd95cc81b9bdd08195e1a5cdd << 0x62 // @1DDD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1DDE: // Incoming jump from 0x1D9A, if !(0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])])) // Inputs[1] { @1DE6 stack[-5] } 1DDE 5B JUMPDEST 1DDF 60 PUSH1 0x00 1DE1 61 PUSH2 0x1df1 1DE4 60 PUSH1 0x0a 1DE6 87 DUP8 1DE7 63 PUSH4 0xffffffff 1DEC 61 PUSH2 0x263a 1DEF 16 AND 1DF0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DDF stack[0] = 0x00 // @1DE1 stack[1] = 0x1df1 // @1DE4 stack[2] = 0x0a // @1DE6 stack[3] = stack[-5] // } // Block ends with call to 0x263a & 0xffffffff, returns to 0x1DF1 label_1DF1: // Incoming return from call to 0x263A at 0x1DF0 // Inputs[2] // { // @1DF2 stack[-2] // @1DF2 stack[-1] // } 1DF1 5B JUMPDEST 1DF2 90 SWAP1 1DF3 50 POP 1DF4 60 PUSH1 0x00 1DF6 81 DUP2 1DF7 15 ISZERO 1DF8 61 PUSH2 0x1e02 1DFB 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1DF2 stack[-2] = stack[-1] // @1DF4 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x1e02, if !stack[-1] label_1DFC: // Incoming jump from 0x1DFB, if not !stack[-1] // Inputs[1] { @1DFD stack[-7] } 1DFC 50 POP 1DFD 85 DUP6 1DFE 61 PUSH2 0x1e07 1E01 56 *JUMP // Stack delta = +0 // Outputs[1] { @1DFD stack[-1] = stack[-7] } // Block ends with unconditional jump to 0x1e07 label_1E02: // Incoming jump from 0x1DFB, if !stack[-1] // Inputs[1] { @1E06 storage[0x0a] } 1E02 5B JUMPDEST 1E03 50 POP 1E04 60 PUSH1 0x0a 1E06 54 SLOAD 1E07 5B JUMPDEST 1E08 61 PUSH2 0x1e0f 1E0B 61 PUSH2 0x2ca0 1E0E 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1E06 stack[-1] = storage[0x0a] // @1E08 stack[0] = 0x1e0f // } // Block ends with call to 0x2ca0, returns to 0x1E0F label_1E0F: // Incoming return from call to 0x2CA0 at 0x1E0E // Incoming return from call to 0x2CA0 at 0x1E0E // Inputs[7] // { // @1E13 stack[-2] // @1E22 memory[0x00:0x40] // @1E24 memory[0x40:0x60] // @1E2C storage[keccak256(memory[0x00:0x40])] // @1E33 storage[keccak256(memory[0x00:0x40]) + 0x01] // @1E47 storage[0x02 + keccak256(memory[0x00:0x40])] // @1E50 stack[-8] // } 1E0F 5B JUMPDEST 1E10 50 POP 1E11 60 PUSH1 0x00 1E13 81 DUP2 1E14 81 DUP2 1E15 52 MSTORE 1E16 60 PUSH1 0x09 1E18 60 PUSH1 0x20 1E1A 90 SWAP1 1E1B 81 DUP2 1E1C 52 MSTORE 1E1D 60 PUSH1 0x40 1E1F 91 SWAP2 1E20 82 DUP3 1E21 90 SWAP1 1E22 20 SHA3 1E23 82 DUP3 1E24 51 MLOAD 1E25 60 PUSH1 0x60 1E27 81 DUP2 1E28 01 ADD 1E29 84 DUP5 1E2A 52 MSTORE 1E2B 81 DUP2 1E2C 54 SLOAD 1E2D 81 DUP2 1E2E 52 MSTORE 1E2F 60 PUSH1 0x01 1E31 82 DUP3 1E32 01 ADD 1E33 54 SLOAD 1E34 60 PUSH1 0x01 1E36 60 PUSH1 0x01 1E38 60 PUSH1 0xa0 1E3A 1B SHL 1E3B 03 SUB 1E3C 16 AND 1E3D 92 SWAP3 1E3E 81 DUP2 1E3F 01 ADD 1E40 92 SWAP3 1E41 90 SWAP1 1E42 92 SWAP3 1E43 52 MSTORE 1E44 60 PUSH1 0x02 1E46 01 ADD 1E47 54 SLOAD 1E48 91 SWAP2 1E49 81 DUP2 1E4A 01 ADD 1E4B 91 SWAP2 1E4C 90 SWAP1 1E4D 91 SWAP2 1E4E 52 MSTORE 1E4F 81 DUP2 1E50 88 DUP9 1E51 10 LT 1E52 80 DUP1 1E53 15 ISZERO 1E54 90 SWAP1 1E55 61 PUSH2 0x1e5f 1E58 57 *JUMPI // Stack delta = +1 // Outputs[8] // { // @1E15 memory[0x00:0x20] = stack[-2] // @1E1C memory[0x20:0x40] = 0x09 // @1E2A memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1E2E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] // @1E43 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40]) + 0x01] // @1E4D stack[-1] = memory[0x40:0x60] // @1E4E memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = storage[0x02 + keccak256(memory[0x00:0x40])] // @1E54 stack[0] = !(stack[-8] < stack[-2]) // } // Block ends with conditional jump to 0x1e5f, if stack[-8] < stack[-2] label_1E59: // Incoming jump from 0x1E58, if not stack[-8] < stack[-2] // Inputs[3] // { // @1E5A stack[-2] // @1E5B memory[stack[-2]:stack[-2] + 0x20] // @1E5C stack[-9] // } 1E59 50 POP 1E5A 80 DUP1 1E5B 51 MLOAD 1E5C 88 DUP9 1E5D 11 GT 1E5E 15 ISZERO 1E5F 5B JUMPDEST 1E60 15 ISZERO 1E61 61 PUSH2 0x1e82 1E64 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1e82, if !!(stack[-9] > memory[stack[-2]:stack[-2] + 0x20]) label_1E65: // Incoming jump from 0x1E64, if not !stack[-1] // Incoming jump from 0x1E64, if not !!(stack[-9] > memory[stack[-2]:stack[-2] + 0x20]) // Inputs[10] // { // @1E67 stack[-1] // @1E69 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] // @1E6B memory[stack[-1]:stack[-1] + 0x20] // @1E71 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] // @1E73 stack[-7] // @1E75 stack[-2] // @1E76 stack[-6] // @1E78 stack[-5] // @1E7A stack[-4] // @1E7F stack[-3] // } 1E65 60 PUSH1 0x20 1E67 81 DUP2 1E68 01 ADD 1E69 51 MLOAD 1E6A 81 DUP2 1E6B 51 MLOAD 1E6C 60 PUSH1 0x40 1E6E 90 SWAP1 1E6F 92 SWAP3 1E70 01 ADD 1E71 51 MLOAD 1E72 90 SWAP1 1E73 97 SWAP8 1E74 50 POP 1E75 91 SWAP2 1E76 95 SWAP6 1E77 50 POP 1E78 93 SWAP4 1E79 50 POP 1E7A 91 SWAP2 1E7B 50 POP 1E7C 61 PUSH2 0x1f8a 1E7F 90 SWAP1 1E80 50 POP 1E81 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @1E73 stack[-7] = memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] // @1E76 stack[-6] = stack[-2] // @1E78 stack[-5] = memory[stack[-1]:stack[-1] + 0x20] // @1E7A stack[-4] = memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] // } // Block ends with unconditional jump to 0x1f8a label_1E82: // Incoming jump from 0x1E64, if !stack[-1] // Incoming jump from 0x1E64, if !!(stack[-9] > memory[stack[-2]:stack[-2] + 0x20]) // Inputs[1] { @1E86 stack[-2] } 1E82 5B JUMPDEST 1E83 60 PUSH1 0x00 1E85 5B JUMPDEST 1E86 82 DUP3 1E87 15 ISZERO 1E88 80 DUP1 1E89 61 PUSH2 0x1e93 1E8C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E83 stack[0] = 0x00 // @1E87 stack[1] = !stack[-2] // } // Block ends with conditional jump to 0x1e93, if !stack[-2] label_1E8D: // Incoming jump from 0x1E8C, if not !stack[-2] // Incoming jump from 0x1E8C, if not !stack[-3] // Inputs[2] // { // @1E90 storage[0x0c] // @1E91 stack[-2] // } 1E8D 50 POP 1E8E 60 PUSH1 0x0c 1E90 54 SLOAD 1E91 81 DUP2 1E92 14 EQ 1E93 5B JUMPDEST 1E94 15 ISZERO 1E95 61 PUSH2 0x1eaf 1E98 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1eaf, if !(stack[-2] == storage[0x0c]) label_1E99: // Incoming jump from 0x1E98, if not !stack[-1] // Incoming jump from 0x1E98, if not !(stack[-2] == storage[0x0c]) // Inputs[5] // { // @1E9C stack[-8] // @1E9F stack[-7] // @1EA2 stack[-6] // @1EA5 stack[-5] // @1EAA stack[-4] // } 1E99 50 POP 1E9A 60 PUSH1 0x00 1E9C 96 SWAP7 1E9D 50 POP 1E9E 86 DUP7 1E9F 95 SWAP6 1EA0 50 POP 1EA1 85 DUP6 1EA2 94 SWAP5 1EA3 50 POP 1EA4 84 DUP5 1EA5 93 SWAP4 1EA6 50 POP 1EA7 61 PUSH2 0x1f8a 1EAA 92 SWAP3 1EAB 50 POP 1EAC 50 POP 1EAD 50 POP 1EAE 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1E9C stack[-8] = 0x00 // @1E9F stack[-7] = 0x00 // @1EA2 stack[-6] = 0x00 // @1EA5 stack[-5] = 0x00 // } // Block ends with unconditional jump to 0x1f8a label_1EAF: // Incoming jump from 0x1E98, if !stack[-1] // Incoming jump from 0x1E98, if !(stack[-2] == storage[0x0c]) // Inputs[2] // { // @1EB0 stack[-3] // @1EB1 stack[-9] // } 1EAF 5B JUMPDEST 1EB0 82 DUP3 1EB1 89 DUP10 1EB2 10 LT 1EB3 15 ISZERO 1EB4 61 PUSH2 0x1f0a 1EB7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f0a, if !(stack[-9] < stack[-3]) label_1EB8: // Incoming jump from 0x1EB7, if not !(stack[-9] < stack[-3]) // Inputs[9] // { // @1EBA stack[-3] // @1EC8 memory[0x00:0x40] // @1ECE storage[0x01 + keccak256(memory[0x00:0x40])] // @1ED9 memory[0x00:0x40] // @1EDB memory[0x40:0x60] // @1EE3 storage[keccak256(memory[0x00:0x40])] // @1EE9 storage[keccak256(memory[0x00:0x40]) + 0x01] // @1EFF storage[keccak256(memory[0x00:0x40]) + 0x02] // @1F04 stack[-2] // } 1EB8 60 PUSH1 0x00 1EBA 92 SWAP3 1EBB 83 DUP4 1EBC 52 MSTORE 1EBD 60 PUSH1 0x0b 1EBF 60 PUSH1 0x20 1EC1 90 SWAP1 1EC2 81 DUP2 1EC3 52 MSTORE 1EC4 60 PUSH1 0x40 1EC6 80 DUP1 1EC7 85 DUP6 1EC8 20 SHA3 1EC9 60 PUSH1 0x01 1ECB 90 SWAP1 1ECC 81 DUP2 1ECD 01 ADD 1ECE 54 SLOAD 1ECF 80 DUP1 1ED0 87 DUP8 1ED1 52 MSTORE 1ED2 60 PUSH1 0x09 1ED4 84 DUP5 1ED5 52 MSTORE 1ED6 95 SWAP6 1ED7 82 DUP3 1ED8 90 SWAP1 1ED9 20 SHA3 1EDA 82 DUP3 1EDB 51 MLOAD 1EDC 60 PUSH1 0x60 1EDE 81 DUP2 1EDF 01 ADD 1EE0 84 DUP5 1EE1 52 MSTORE 1EE2 81 DUP2 1EE3 54 SLOAD 1EE4 81 DUP2 1EE5 52 MSTORE 1EE6 91 SWAP2 1EE7 81 DUP2 1EE8 01 ADD 1EE9 54 SLOAD 1EEA 60 PUSH1 0x01 1EEC 60 PUSH1 0x01 1EEE 60 PUSH1 0xa0 1EF0 1B SHL 1EF1 03 SUB 1EF2 16 AND 1EF3 93 SWAP4 1EF4 82 DUP3 1EF5 01 ADD 1EF6 93 SWAP4 1EF7 90 SWAP1 1EF8 93 SWAP4 1EF9 52 MSTORE 1EFA 60 PUSH1 0x02 1EFC 90 SWAP1 1EFD 92 SWAP3 1EFE 01 ADD 1EFF 54 SLOAD 1F00 90 SWAP1 1F01 82 DUP3 1F02 01 ADD 1F03 52 MSTORE 1F04 91 SWAP2 1F05 50 POP 1F06 61 PUSH2 0x1f82 1F09 56 *JUMP // Stack delta = +0 // Outputs[10] // { // @1EBC memory[0x00:0x20] = stack[-3] // @1EC3 memory[0x20:0x40] = 0x0b // @1ED1 memory[0x00:0x20] = storage[0x01 + keccak256(memory[0x00:0x40])] // @1ED5 memory[0x20:0x40] = 0x09 // @1ED6 stack[-3] = storage[0x01 + keccak256(memory[0x00:0x40])] // @1EE1 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1EE5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] // @1EF9 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40]) + 0x01] // @1F03 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = storage[keccak256(memory[0x00:0x40]) + 0x02] // @1F04 stack[-2] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1f82 label_1F0A: // Incoming jump from 0x1EB7, if !(stack[-9] < stack[-3]) // Inputs[3] // { // @1F0B stack[-2] // @1F0C memory[stack[-2]:stack[-2] + 0x20] // @1F0D stack[-9] // } 1F0A 5B JUMPDEST 1F0B 81 DUP2 1F0C 51 MLOAD 1F0D 89 DUP10 1F0E 11 GT 1F0F 15 ISZERO 1F10 61 PUSH2 0x1f63 1F13 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f63, if !(stack[-9] > memory[stack[-2]:stack[-2] + 0x20]) label_1F14: // Incoming jump from 0x1F13, if not !(stack[-9] > memory[stack[-2]:stack[-2] + 0x20]) // Inputs[9] // { // @1F16 stack[-3] // @1F24 memory[0x00:0x40] // @1F2A storage[0x02 + keccak256(memory[0x00:0x40])] // @1F35 memory[0x00:0x40] // @1F37 memory[0x40:0x60] // @1F3F storage[keccak256(memory[0x00:0x40])] // @1F46 storage[keccak256(memory[0x00:0x40]) + 0x01] // @1F58 storage[keccak256(memory[0x00:0x40]) + 0x02] // @1F5D stack[-2] // } 1F14 60 PUSH1 0x00 1F16 92 SWAP3 1F17 83 DUP4 1F18 52 MSTORE 1F19 60 PUSH1 0x0b 1F1B 60 PUSH1 0x20 1F1D 90 SWAP1 1F1E 81 DUP2 1F1F 52 MSTORE 1F20 60 PUSH1 0x40 1F22 80 DUP1 1F23 85 DUP6 1F24 20 SHA3 1F25 60 PUSH1 0x02 1F27 90 SWAP1 1F28 81 DUP2 1F29 01 ADD 1F2A 54 SLOAD 1F2B 80 DUP1 1F2C 87 DUP8 1F2D 52 MSTORE 1F2E 60 PUSH1 0x09 1F30 84 DUP5 1F31 52 MSTORE 1F32 95 SWAP6 1F33 82 DUP3 1F34 90 SWAP1 1F35 20 SHA3 1F36 82 DUP3 1F37 51 MLOAD 1F38 60 PUSH1 0x60 1F3A 81 DUP2 1F3B 01 ADD 1F3C 84 DUP5 1F3D 52 MSTORE 1F3E 81 DUP2 1F3F 54 SLOAD 1F40 81 DUP2 1F41 52 MSTORE 1F42 60 PUSH1 0x01 1F44 82 DUP3 1F45 01 ADD 1F46 54 SLOAD 1F47 60 PUSH1 0x01 1F49 60 PUSH1 0x01 1F4B 60 PUSH1 0xa0 1F4D 1B SHL 1F4E 03 SUB 1F4F 16 AND 1F50 94 SWAP5 1F51 81 DUP2 1F52 01 ADD 1F53 94 SWAP5 1F54 90 SWAP1 1F55 94 SWAP5 1F56 52 MSTORE 1F57 01 ADD 1F58 54 SLOAD 1F59 90 SWAP1 1F5A 82 DUP3 1F5B 01 ADD 1F5C 52 MSTORE 1F5D 91 SWAP2 1F5E 50 POP 1F5F 61 PUSH2 0x1f82 1F62 56 *JUMP // Stack delta = +0 // Outputs[10] // { // @1F18 memory[0x00:0x20] = stack[-3] // @1F1F memory[0x20:0x40] = 0x0b // @1F2D memory[0x00:0x20] = storage[0x02 + keccak256(memory[0x00:0x40])] // @1F31 memory[0x20:0x40] = 0x09 // @1F32 stack[-3] = storage[0x02 + keccak256(memory[0x00:0x40])] // @1F3D memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1F41 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] // @1F56 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40]) + 0x01] // @1F5C memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = storage[keccak256(memory[0x00:0x40]) + 0x02] // @1F5D stack[-2] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1f82 label_1F63: // Incoming jump from 0x1F13, if !(stack[-9] > memory[stack[-2]:stack[-2] + 0x20]) // Inputs[10] // { // @1F67 stack[-2] // @1F69 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @1F6B memory[stack[-2]:stack[-2] + 0x20] // @1F71 memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @1F73 stack[-8] // @1F75 stack[-3] // @1F76 stack[-7] // @1F78 stack[-6] // @1F7A stack[-5] // @1F7F stack[-4] // } 1F63 5B JUMPDEST 1F64 50 POP 1F65 60 PUSH1 0x20 1F67 81 DUP2 1F68 01 ADD 1F69 51 MLOAD 1F6A 81 DUP2 1F6B 51 MLOAD 1F6C 60 PUSH1 0x40 1F6E 90 SWAP1 1F6F 92 SWAP3 1F70 01 ADD 1F71 51 MLOAD 1F72 90 SWAP1 1F73 97 SWAP8 1F74 50 POP 1F75 91 SWAP2 1F76 95 SWAP6 1F77 50 POP 1F78 93 SWAP4 1F79 50 POP 1F7A 91 SWAP2 1F7B 50 POP 1F7C 61 PUSH2 0x1f8a 1F7F 90 SWAP1 1F80 50 POP 1F81 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1F73 stack[-8] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @1F76 stack[-7] = stack[-3] // @1F78 stack[-6] = memory[stack[-2]:stack[-2] + 0x20] // @1F7A stack[-5] = memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } // Block ends with unconditional jump to 0x1f8a label_1F82: // Incoming jump from 0x1F62 // Incoming jump from 0x1F09 // Inputs[1] { @1F85 stack[-1] } 1F82 5B JUMPDEST 1F83 60 PUSH1 0x01 1F85 01 ADD 1F86 61 PUSH2 0x1e85 1F89 56 *JUMP // Stack delta = +0 // Outputs[1] { @1F85 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x1e85 label_1F8A: // Incoming jump from 0x1E81 // Incoming jump from 0x1EAE // Incoming jump from 0x1F81 // Inputs[6] // { // @1F8B stack[-3] // @1F8B stack[-1] // @1F8C stack[-5] // @1F8E stack[-2] // @1F8E stack[-4] // @1F8F stack[-6] // } 1F8A 5B JUMPDEST 1F8B 91 SWAP2 1F8C 93 SWAP4 1F8D 50 POP 1F8E 91 SWAP2 1F8F 93 SWAP4 1F90 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @1F8B stack[-3] = stack[-1] // @1F8C stack[-5] = stack[-3] // @1F8E stack[-4] = stack[-2] // @1F8F stack[-6] = stack[-4] // } // Block ends with unconditional jump to stack[-6] label_1F91: // Incoming call from 0x128E, returns to 0x128F // Incoming call from 0x12FE, returns to 0x12FF // Incoming call from 0x1275, returns to 0x1276 // Incoming call from 0x132A, returns to 0x132B // Inputs[2] // { // @1F94 stack[-2] // @1F95 stack[-1] // } 1F91 5B JUMPDEST 1F92 60 PUSH1 0x00 1F94 82 DUP3 1F95 82 DUP3 1F96 01 ADD 1F97 83 DUP4 1F98 81 DUP2 1F99 10 LT 1F9A 15 ISZERO 1F9B 61 PUSH2 0x1d71 1F9E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1F92 stack[0] = 0x00 // @1F96 stack[1] = stack[-1] + stack[-2] // } // Block ends with conditional jump to 0x1d71, if !(stack[-1] + stack[-2] < stack[-2]) label_1F9F: // Incoming jump from 0x1F9E, if not !(stack[-1] + stack[-2] < stack[-2]) // Inputs[3] // { // @1FA2 memory[0x40:0x60] // @1FE1 memory[0x40:0x60] // @1FEA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1F9F 60 PUSH1 0x40 1FA1 80 DUP1 1FA2 51 MLOAD 1FA3 62 PUSH3 0x461bcd 1FA7 60 PUSH1 0xe5 1FA9 1B SHL 1FAA 81 DUP2 1FAB 52 MSTORE 1FAC 60 PUSH1 0x20 1FAE 60 PUSH1 0x04 1FB0 82 DUP3 1FB1 01 ADD 1FB2 52 MSTORE 1FB3 60 PUSH1 0x1b 1FB5 60 PUSH1 0x24 1FB7 82 DUP3 1FB8 01 ADD 1FB9 52 MSTORE 1FBA 7F PUSH32 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 1FDB 60 PUSH1 0x44 1FDD 82 DUP3 1FDE 01 ADD 1FDF 52 MSTORE 1FE0 90 SWAP1 1FE1 51 MLOAD 1FE2 90 SWAP1 1FE3 81 DUP2 1FE4 90 SWAP1 1FE5 03 SUB 1FE6 60 PUSH1 0x64 1FE8 01 ADD 1FE9 90 SWAP1 1FEA FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1FAB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1FB2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1FB9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1b // @1FDF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 // @1FEA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1FEB: // Incoming call from 0x12A6, returns to 0x12A7 // Inputs[1] { @1FEC stack[-1] } 1FEB 5B JUMPDEST 1FEC 80 DUP1 1FED 61 PUSH2 0x203d 1FF0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x203d, if stack[-1] label_1FF1: // Incoming jump from 0x1FF0, if not stack[-1] // Inputs[3] // { // @1FF4 memory[0x40:0x60] // @2033 memory[0x40:0x60] // @203C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1FF1 60 PUSH1 0x40 1FF3 80 DUP1 1FF4 51 MLOAD 1FF5 62 PUSH3 0x461bcd 1FF9 60 PUSH1 0xe5 1FFB 1B SHL 1FFC 81 DUP2 1FFD 52 MSTORE 1FFE 60 PUSH1 0x20 2000 60 PUSH1 0x04 2002 82 DUP3 2003 01 ADD 2004 52 MSTORE 2005 60 PUSH1 0x0c 2007 60 PUSH1 0x24 2009 82 DUP3 200A 01 ADD 200B 52 MSTORE 200C 7F PUSH32 0x4b657920697320656d7074790000000000000000000000000000000000000000 202D 60 PUSH1 0x44 202F 82 DUP3 2030 01 ADD 2031 52 MSTORE 2032 90 SWAP1 2033 51 MLOAD 2034 90 SWAP1 2035 81 DUP2 2036 90 SWAP1 2037 03 SUB 2038 60 PUSH1 0x64 203A 01 ADD 203B 90 SWAP1 203C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1FFD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2004 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @200B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @2031 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4b657920697320656d7074790000000000000000000000000000000000000000 // @203C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_203D: // Incoming jump from 0x1FF0, if stack[-1] // Inputs[2] // { // @2041 stack[-2] // @2042 stack[-1] // } 203D 5B JUMPDEST 203E 61 PUSH2 0x2047 2041 82 DUP3 2042 82 DUP3 2043 61 PUSH2 0x263a 2046 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @203E stack[0] = 0x2047 // @2041 stack[1] = stack[-2] // @2042 stack[2] = stack[-1] // } // Block ends with call to 0x263a, returns to 0x2047 label_2047: // Incoming return from call to 0x263A at 0x2046 // Inputs[1] { @2048 stack[-1] } 2047 5B JUMPDEST 2048 15 ISZERO 2049 61 PUSH2 0x2099 204C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2099, if !stack[-1] label_204D: // Incoming jump from 0x204C, if not !stack[-1] // Inputs[3] // { // @2050 memory[0x40:0x60] // @208F memory[0x40:0x60] // @2098 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 204D 60 PUSH1 0x40 204F 80 DUP1 2050 51 MLOAD 2051 62 PUSH3 0x461bcd 2055 60 PUSH1 0xe5 2057 1B SHL 2058 81 DUP2 2059 52 MSTORE 205A 60 PUSH1 0x20 205C 60 PUSH1 0x04 205E 82 DUP3 205F 01 ADD 2060 52 MSTORE 2061 60 PUSH1 0x1f 2063 60 PUSH1 0x24 2065 82 DUP3 2066 01 ADD 2067 52 MSTORE 2068 7F PUSH32 0x4578697374696e67206b65792063616e6e6f7420626520696e73657274656400 2089 60 PUSH1 0x44 208B 82 DUP3 208C 01 ADD 208D 52 MSTORE 208E 90 SWAP1 208F 51 MLOAD 2090 90 SWAP1 2091 81 DUP2 2092 90 SWAP1 2093 03 SUB 2094 60 PUSH1 0x64 2096 01 ADD 2097 90 SWAP1 2098 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2059 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2060 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2067 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @208D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4578697374696e67206b65792063616e6e6f7420626520696e73657274656400 // @2098 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2099: // Incoming jump from 0x204C, if !stack[-1] // Inputs[2] // { // @209A stack[-2] // @209B storage[stack[-2]] // } 2099 5B JUMPDEST 209A 81 DUP2 209B 54 SLOAD 209C 60 PUSH1 0x00 209E 90 SWAP1 209F 5B JUMPDEST 20A0 80 DUP1 20A1 15 ISZERO 20A2 61 PUSH2 0x20e3 20A5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @209E stack[0] = 0x00 // @209E stack[1] = storage[stack[-2]] // } // Block ends with conditional jump to 0x20e3, if !storage[stack[-2]] label_20A6: // Incoming jump from 0x20A5, if not !stack[-1] // Incoming jump from 0x20A5, if not !storage[stack[-2]] // Inputs[3] // { // @20A6 stack[-1] // @20A7 stack[-2] // @20AA stack[-3] // } 20A6 80 DUP1 20A7 91 SWAP2 20A8 50 POP 20A9 80 DUP1 20AA 83 DUP4 20AB 10 LT 20AC 15 ISZERO 20AD 61 PUSH2 0x20c9 20B0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @20A7 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x20c9, if !(stack[-3] < stack[-1]) label_20B1: // Incoming jump from 0x20B0, if not !(stack[-3] < stack[-1]) // Inputs[4] // { // @20B3 stack[-1] // @20B9 stack[-4] // @20C2 memory[0x00:0x40] // @20C4 storage[keccak256(memory[0x00:0x40]) + 0x01] // } 20B1 60 PUSH1 0x00 20B3 90 SWAP1 20B4 81 DUP2 20B5 52 MSTORE 20B6 60 PUSH1 0x01 20B8 80 DUP1 20B9 85 DUP6 20BA 01 ADD 20BB 60 PUSH1 0x20 20BD 52 MSTORE 20BE 60 PUSH1 0x40 20C0 90 SWAP1 20C1 91 SWAP2 20C2 20 SHA3 20C3 01 ADD 20C4 54 SLOAD 20C5 61 PUSH2 0x20de 20C8 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @20B5 memory[0x00:0x20] = stack[-1] // @20BD memory[0x20:0x40] = stack[-4] + 0x01 // @20C4 stack[-1] = storage[keccak256(memory[0x00:0x40]) + 0x01] // } // Block ends with unconditional jump to 0x20de label_20C9: // Incoming jump from 0x20B0, if !(stack[-3] < stack[-1]) // Inputs[4] // { // @20CC stack[-1] // @20D1 stack[-4] // @20D9 memory[0x00:0x40] // @20DD storage[0x02 + keccak256(memory[0x00:0x40])] // } 20C9 5B JUMPDEST 20CA 60 PUSH1 0x00 20CC 90 SWAP1 20CD 81 DUP2 20CE 52 MSTORE 20CF 60 PUSH1 0x01 20D1 84 DUP5 20D2 01 ADD 20D3 60 PUSH1 0x20 20D5 52 MSTORE 20D6 60 PUSH1 0x40 20D8 90 SWAP1 20D9 20 SHA3 20DA 60 PUSH1 0x02 20DC 01 ADD 20DD 54 SLOAD 20DE 5B JUMPDEST 20DF 61 PUSH2 0x209f 20E2 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @20CE memory[0x00:0x20] = stack[-1] // @20D5 memory[0x20:0x40] = stack[-4] + 0x01 // @20DD stack[-1] = storage[0x02 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x209f label_20E3: // Incoming jump from 0x20A5, if !stack[-1] // Incoming jump from 0x20A5, if !storage[stack[-2]] // Inputs[10] // { // @20E7 memory[0x40:0x60] // @20EE stack[-2] // @210A stack[-3] // @210D stack[-4] // @2116 memory[0x00:0x40] // @2118 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @211B memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @2123 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] // @212A memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] // @2131 storage[keccak256(memory[0x00:0x40]) + 0x03] // } 20E3 5B JUMPDEST 20E4 60 PUSH1 0x40 20E6 80 DUP1 20E7 51 MLOAD 20E8 60 PUSH1 0x80 20EA 81 DUP2 20EB 01 ADD 20EC 82 DUP3 20ED 52 MSTORE 20EE 83 DUP4 20EF 81 DUP2 20F0 52 MSTORE 20F1 60 PUSH1 0x00 20F3 60 PUSH1 0x20 20F5 80 DUP1 20F6 83 DUP4 20F7 01 ADD 20F8 82 DUP3 20F9 81 DUP2 20FA 52 MSTORE 20FB 83 DUP4 20FC 85 DUP6 20FD 01 ADD 20FE 83 DUP4 20FF 81 DUP2 2100 52 MSTORE 2101 60 PUSH1 0x01 2103 60 PUSH1 0x60 2105 86 DUP7 2106 01 ADD 2107 81 DUP2 2108 81 DUP2 2109 52 MSTORE 210A 8A DUP11 210B 86 DUP7 210C 52 MSTORE 210D 8B DUP12 210E 82 DUP3 210F 01 ADD 2110 90 SWAP1 2111 94 SWAP5 2112 52 MSTORE 2113 95 SWAP6 2114 90 SWAP1 2115 93 SWAP4 2116 20 SHA3 2117 93 SWAP4 2118 51 MLOAD 2119 84 DUP5 211A 55 SSTORE 211B 51 MLOAD 211C 93 SWAP4 211D 83 DUP4 211E 01 ADD 211F 93 SWAP4 2120 90 SWAP1 2121 93 SWAP4 2122 55 SSTORE 2123 51 MLOAD 2124 60 PUSH1 0x02 2126 82 DUP3 2127 01 ADD 2128 55 SSTORE 2129 90 SWAP1 212A 51 MLOAD 212B 60 PUSH1 0x03 212D 90 SWAP1 212E 91 SWAP2 212F 01 ADD 2130 80 DUP1 2131 54 SLOAD 2132 60 PUSH1 0xff 2134 19 NOT 2135 16 AND 2136 91 SWAP2 2137 15 ISZERO 2138 15 ISZERO 2139 91 SWAP2 213A 90 SWAP1 213B 91 SWAP2 213C 17 OR 213D 90 SWAP1 213E 55 SSTORE 213F 81 DUP2 2140 61 PUSH2 0x214b 2143 57 *JUMPI // Stack delta = +0 // Outputs[11] // { // @20ED memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @20F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @20FA memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @2100 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = 0x00 // @2109 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x01 // @210C memory[0x00:0x20] = stack[-3] // @2112 memory[0x20:0x40] = 0x01 + stack[-4] // @211A storage[keccak256(memory[0x00:0x40])] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2122 storage[keccak256(memory[0x00:0x40]) + 0x01] = memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @2128 storage[keccak256(memory[0x00:0x40]) + 0x02] = memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] // @213E storage[keccak256(memory[0x00:0x40]) + 0x03] = !!memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] | (~0xff & storage[keccak256(memory[0x00:0x40]) + 0x03]) // } // Block ends with conditional jump to 0x214b, if stack[-2] label_2144: // Incoming jump from 0x2143, if not stack[-2] // Inputs[2] // { // @2144 stack[-3] // @2145 stack[-4] // } 2144 82 DUP3 2145 84 DUP5 2146 55 SSTORE 2147 61 PUSH2 0x2185 214A 56 *JUMP // Stack delta = +0 // Outputs[1] { @2146 storage[stack[-4]] = stack[-3] } // Block ends with unconditional jump to 0x2185 label_214B: // Incoming jump from 0x2143, if stack[-2] // Inputs[2] // { // @214C stack[-2] // @214D stack[-3] // } 214B 5B JUMPDEST 214C 81 DUP2 214D 83 DUP4 214E 10 LT 214F 15 ISZERO 2150 61 PUSH2 0x216e 2153 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x216e, if !(stack[-3] < stack[-2]) label_2154: // Incoming jump from 0x2153, if not !(stack[-3] < stack[-2]) // Inputs[4] // { // @2156 stack[-2] // @215C stack[-4] // @2165 memory[0x00:0x40] // @2167 stack[-3] // } 2154 60 PUSH1 0x00 2156 82 DUP3 2157 81 DUP2 2158 52 MSTORE 2159 60 PUSH1 0x01 215B 80 DUP1 215C 86 DUP7 215D 01 ADD 215E 60 PUSH1 0x20 2160 52 MSTORE 2161 60 PUSH1 0x40 2163 90 SWAP1 2164 91 SWAP2 2165 20 SHA3 2166 01 ADD 2167 83 DUP4 2168 90 SWAP1 2169 55 SSTORE 216A 61 PUSH2 0x2185 216D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2158 memory[0x00:0x20] = stack[-2] // @2160 memory[0x20:0x40] = stack[-4] + 0x01 // @2169 storage[keccak256(memory[0x00:0x40]) + 0x01] = stack[-3] // } // Block ends with unconditional jump to 0x2185 label_216E: // Incoming jump from 0x2153, if !(stack[-3] < stack[-2]) // Inputs[7] // { // @2171 stack[-2] // @2176 stack[-4] // @217E memory[0x00:0x40] // @2182 stack[-3] // @218B storage[stack[-4] + 0x02] // @219D memory[0x00:0x40] // @21AD memory[0x00:0x20] // } 216E 5B JUMPDEST 216F 60 PUSH1 0x00 2171 82 DUP3 2172 81 DUP2 2173 52 MSTORE 2174 60 PUSH1 0x01 2176 85 DUP6 2177 01 ADD 2178 60 PUSH1 0x20 217A 52 MSTORE 217B 60 PUSH1 0x40 217D 90 SWAP1 217E 20 SHA3 217F 60 PUSH1 0x02 2181 01 ADD 2182 83 DUP4 2183 90 SWAP1 2184 55 SSTORE 2185 5B JUMPDEST 2186 60 PUSH1 0x02 2188 84 DUP5 2189 01 ADD 218A 80 DUP1 218B 54 SLOAD 218C 60 PUSH1 0x00 218E 85 DUP6 218F 81 DUP2 2190 52 MSTORE 2191 60 PUSH1 0x03 2193 87 DUP8 2194 01 ADD 2195 60 PUSH1 0x20 2197 90 SWAP1 2198 81 DUP2 2199 52 MSTORE 219A 60 PUSH1 0x40 219C 82 DUP3 219D 20 SHA3 219E 83 DUP4 219F 90 SWAP1 21A0 55 SSTORE 21A1 60 PUSH1 0x01 21A3 83 DUP4 21A4 01 ADD 21A5 84 DUP5 21A6 55 SSTORE 21A7 92 SWAP3 21A8 81 DUP2 21A9 52 MSTORE 21AA 91 SWAP2 21AB 90 SWAP1 21AC 91 SWAP2 21AD 20 SHA3 21AE 01 ADD 21AF 83 DUP4 21B0 90 SWAP1 21B1 55 SSTORE 21B2 61 PUSH2 0x0934 21B5 84 DUP5 21B6 84 DUP5 21B7 61 PUSH2 0x2669 21BA 56 *JUMP // Stack delta = +3 // Outputs[12] // { // @2173 memory[0x00:0x20] = stack[-2] // @217A memory[0x20:0x40] = stack[-4] + 0x01 // @2184 storage[0x02 + keccak256(memory[0x00:0x40])] = stack[-3] // @2190 memory[0x00:0x20] = stack[-3] // @2199 memory[0x20:0x40] = stack[-4] + 0x03 // @21A0 storage[keccak256(memory[0x00:0x40])] = storage[stack[-4] + 0x02] // @21A6 storage[stack[-4] + 0x02] = storage[stack[-4] + 0x02] + 0x01 // @21A9 memory[0x00:0x20] = stack[-4] + 0x02 // @21B1 storage[keccak256(memory[0x00:0x20]) + storage[stack[-4] + 0x02]] = stack[-3] // @21B2 stack[0] = 0x0934 // @21B5 stack[1] = stack[-4] // @21B6 stack[2] = stack[-3] // } // Block ends with call to 0x2669, returns to 0x0934 label_21BB: // Incoming jump from 0x155A // Inputs[3] // { // @21BF stack[-2] // @21C1 stack[-4] // @21C2 stack[-3] // } 21BB 5B JUMPDEST 21BC 61 PUSH2 0x21c7 21BF 82 DUP3 21C0 83 DUP4 21C1 86 DUP7 21C2 86 DUP7 21C3 61 PUSH2 0x1a87 21C6 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @21BC stack[0] = 0x21c7 // @21BF stack[1] = stack[-2] // @21C0 stack[2] = stack[-2] // @21C1 stack[3] = stack[-4] // @21C2 stack[4] = stack[-3] // } // Block ends with unconditional jump to 0x1a87 21C7 5B JUMPDEST 21C8 61 PUSH2 0x21d3 21CB 84 DUP5 21CC 84 DUP5 21CD 84 DUP5 21CE 84 DUP5 21CF 61 PUSH2 0x28d4 21D2 56 *JUMP 21D3 5B JUMPDEST 21D4 61 PUSH2 0x0934 21D7 57 *JUMPI 21D8 60 PUSH1 0x40 21DA 51 MLOAD 21DB 62 PUSH3 0x461bcd 21DF 60 PUSH1 0xe5 21E1 1B SHL 21E2 81 DUP2 21E3 52 MSTORE 21E4 60 PUSH1 0x04 21E6 01 ADD 21E7 80 DUP1 21E8 80 DUP1 21E9 60 PUSH1 0x20 21EB 01 ADD 21EC 82 DUP3 21ED 81 DUP2 21EE 03 SUB 21EF 82 DUP3 21F0 52 MSTORE 21F1 60 PUSH1 0x32 21F3 81 DUP2 21F4 52 MSTORE 21F5 60 PUSH1 0x20 21F7 01 ADD 21F8 80 DUP1 21F9 61 PUSH2 0x2cdb 21FC 60 PUSH1 0x32 21FE 91 SWAP2 21FF 39 CODECOPY 2200 60 PUSH1 0x40 2202 01 ADD 2203 91 SWAP2 2204 50 POP 2205 50 POP 2206 60 PUSH1 0x40 2208 51 MLOAD 2209 80 DUP1 220A 91 SWAP2 220B 03 SUB 220C 90 SWAP1 220D FD *REVERT label_220E: // Incoming call from 0x1833, returns to 0x1834 // Incoming call from 0x19E2, returns to 0x19E3 // Inputs[2] // { // @2212 memory[0x40:0x60] // @2229 code.length // } 220E 5B JUMPDEST 220F 60 PUSH1 0x40 2211 80 DUP1 2212 51 MLOAD 2213 60 PUSH1 0x28 2215 80 DUP1 2216 82 DUP3 2217 52 MSTORE 2218 60 PUSH1 0x60 221A 82 DUP3 221B 81 DUP2 221C 01 ADD 221D 90 SWAP1 221E 93 SWAP4 221F 52 MSTORE 2220 82 DUP3 2221 91 SWAP2 2222 90 SWAP1 2223 60 PUSH1 0x20 2225 82 DUP3 2226 01 ADD 2227 81 DUP2 2228 80 DUP1 2229 38 CODESIZE 222A 83 DUP4 222B 39 CODECOPY 222C 01 ADD 222D 90 SWAP1 222E 50 POP 222F 50 POP 2230 90 SWAP1 2231 50 POP 2232 60 PUSH1 0x00 2234 5B JUMPDEST 2235 60 PUSH1 0x14 2237 81 DUP2 2238 10 LT 2239 15 ISZERO 223A 61 PUSH2 0x22fb 223D 57 *JUMPI // Stack delta = +3 // Outputs[6] // { // @2217 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x28 // @221E stack[0] = 0x60 // @221F memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @222B memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x28] = code[code.length:code.length + 0x28] // @2230 stack[1] = memory[0x40:0x60] // @2232 stack[2] = 0x00 // } // Block ends with conditional jump to 0x22fb, if !(0x00 < 0x14) label_223E: // Incoming jump from 0x223D, if not !(stack[-1] < 0x14) // Incoming jump from 0x223D, if not !(0x00 < 0x14) // Inputs[2] // { // @2240 stack[-1] // @224A stack[-4] // } 223E 60 PUSH1 0x00 2240 81 DUP2 2241 60 PUSH1 0x13 2243 03 SUB 2244 60 PUSH1 0x08 2246 02 MUL 2247 60 PUSH1 0x02 2249 0A EXP 224A 85 DUP6 224B 60 PUSH1 0x01 224D 60 PUSH1 0x01 224F 60 PUSH1 0xa0 2251 1B SHL 2252 03 SUB 2253 16 AND 2254 81 DUP2 2255 61 PUSH2 0x225a 2258 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @223E stack[0] = 0x00 // @2249 stack[1] = 0x02 ** (0x08 * (0x13 - stack[-1])) // @2253 stack[2] = (0x01 << 0xa0) - 0x01 & stack[-4] // } // Block ends with conditional jump to 0x225a, if 0x02 ** (0x08 * (0x13 - stack[-1])) label_2259: // Incoming jump from 0x2258, if not 0x02 ** (0x08 * (0x13 - stack[-1])) 2259 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2259 assert(); } // Block terminates label_225A: // Incoming jump from 0x2258, if 0x02 ** (0x08 * (0x13 - stack[-1])) // Inputs[3] // { // @225B stack[-1] // @225B stack[-2] // @225F stack[-3] // } 225A 5B JUMPDEST 225B 04 DIV 225C 60 PUSH1 0xf8 225E 1B SHL 225F 90 SWAP1 2260 50 POP 2261 60 PUSH1 0x00 2263 60 PUSH1 0x10 2265 82 DUP3 2266 60 PUSH1 0xf8 2268 1C SHR 2269 60 PUSH1 0xff 226B 16 AND 226C 81 DUP2 226D 61 PUSH2 0x2272 2270 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @225F stack[-3] = stack[-1] / stack[-2] << 0xf8 // @2261 stack[-2] = 0x00 // @2263 stack[-1] = 0x10 // @226B stack[0] = 0xff & ((stack[-1] / stack[-2] << 0xf8) >> 0xf8) // } // Block ends with conditional jump to 0x2272, if 0x10 label_2271: // Incoming jump from 0x2270, if not 0x10 2271 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2271 assert(); } // Block terminates label_2272: // Incoming jump from 0x2270, if 0x10 // Inputs[4] // { // @2273 stack[-1] // @2273 stack[-2] // @2277 stack[-3] // @2282 stack[-4] // } 2272 5B JUMPDEST 2273 04 DIV 2274 60 PUSH1 0xf8 2276 1B SHL 2277 90 SWAP1 2278 50 POP 2279 60 PUSH1 0x00 227B 81 DUP2 227C 60 PUSH1 0xf8 227E 1C SHR 227F 60 PUSH1 0x10 2281 02 MUL 2282 83 DUP4 2283 60 PUSH1 0xf8 2285 1C SHR 2286 03 SUB 2287 60 PUSH1 0xf8 2289 1B SHL 228A 90 SWAP1 228B 50 POP 228C 61 PUSH2 0x2294 228F 82 DUP3 2290 61 PUSH2 0x2a44 2293 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @2277 stack[-3] = stack[-1] / stack[-2] << 0xf8 // @228A stack[-2] = (stack[-4] >> 0xf8) - 0x10 * ((stack[-1] / stack[-2] << 0xf8) >> 0xf8) << 0xf8 // @228C stack[-1] = 0x2294 // @228F stack[0] = stack[-1] / stack[-2] << 0xf8 // } // Block ends with call to 0x2a44, returns to 0x2294 label_2294: // Incoming return from call to 0x2A44 at 0x2293 // Inputs[3] // { // @2295 stack[-6] // @2296 stack[-5] // @229B memory[stack[-6]:stack[-6] + 0x20] // } 2294 5B JUMPDEST 2295 85 DUP6 2296 85 DUP6 2297 60 PUSH1 0x02 2299 02 MUL 229A 81 DUP2 229B 51 MLOAD 229C 81 DUP2 229D 10 LT 229E 61 PUSH2 0x22a3 22A1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2295 stack[0] = stack[-6] // @2299 stack[1] = 0x02 * stack[-5] // } // Block ends with conditional jump to 0x22a3, if 0x02 * stack[-5] < memory[stack[-6]:stack[-6] + 0x20] label_22A2: // Incoming jump from 0x22A1, if not 0x02 * stack[-5] < memory[stack[-6]:stack[-6] + 0x20] 22A2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @22A2 assert(); } // Block terminates label_22A3: // Incoming jump from 0x22A1, if 0x02 * stack[-5] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[4] // { // @22A6 stack[-1] // @22A7 stack[-2] // @22A8 stack[-3] // @22BE stack[-4] // } 22A3 5B JUMPDEST 22A4 60 PUSH1 0x20 22A6 01 ADD 22A7 01 ADD 22A8 90 SWAP1 22A9 60 PUSH1 0x01 22AB 60 PUSH1 0x01 22AD 60 PUSH1 0xf8 22AF 1B SHL 22B0 03 SUB 22B1 19 NOT 22B2 16 AND 22B3 90 SWAP1 22B4 81 DUP2 22B5 60 PUSH1 0x00 22B7 1A BYTE 22B8 90 SWAP1 22B9 53 MSTORE8 22BA 50 POP 22BB 61 PUSH2 0x22c3 22BE 81 DUP2 22BF 61 PUSH2 0x2a44 22C2 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @22B9 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @22BB stack[-3] = 0x22c3 // @22BE stack[-2] = stack[-4] // } // Block ends with call to 0x2a44, returns to 0x22C3 label_22C3: // Incoming return from call to 0x2A44 at 0x22C2 // Inputs[3] // { // @22C4 stack[-6] // @22C5 stack[-5] // @22CD memory[stack[-6]:stack[-6] + 0x20] // } 22C3 5B JUMPDEST 22C4 85 DUP6 22C5 85 DUP6 22C6 60 PUSH1 0x02 22C8 02 MUL 22C9 60 PUSH1 0x01 22CB 01 ADD 22CC 81 DUP2 22CD 51 MLOAD 22CE 81 DUP2 22CF 10 LT 22D0 61 PUSH2 0x22d5 22D3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @22C4 stack[0] = stack[-6] // @22CB stack[1] = 0x01 + 0x02 * stack[-5] // } // Block ends with conditional jump to 0x22d5, if 0x01 + 0x02 * stack[-5] < memory[stack[-6]:stack[-6] + 0x20] label_22D4: // Incoming jump from 0x22D3, if not 0x01 + 0x02 * stack[-5] < memory[stack[-6]:stack[-6] + 0x20] 22D4 FE *ASSERT // Stack delta = +0 // Outputs[1] { @22D4 assert(); } // Block terminates label_22D5: // Incoming jump from 0x22D3, if 0x01 + 0x02 * stack[-5] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[6] // { // @22D8 stack[-1] // @22D9 stack[-2] // @22DA stack[-3] // @22F0 stack[-5] // @22F1 stack[-7] // @22F8 stack[-6] // } 22D5 5B JUMPDEST 22D6 60 PUSH1 0x20 22D8 01 ADD 22D9 01 ADD 22DA 90 SWAP1 22DB 60 PUSH1 0x01 22DD 60 PUSH1 0x01 22DF 60 PUSH1 0xf8 22E1 1B SHL 22E2 03 SUB 22E3 19 NOT 22E4 16 AND 22E5 90 SWAP1 22E6 81 DUP2 22E7 60 PUSH1 0x00 22E9 1A BYTE 22EA 90 SWAP1 22EB 53 MSTORE8 22EC 50 POP 22ED 50 POP 22EE 60 PUSH1 0x01 22F0 90 SWAP1 22F1 92 SWAP3 22F2 01 ADD 22F3 91 SWAP2 22F4 50 POP 22F5 61 PUSH2 0x2234 22F8 90 SWAP1 22F9 50 POP 22FA 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @22EB memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @22F3 stack[-7] = stack[-7] + 0x01 // } // Block ends with unconditional jump to 0x2234 label_22FB: // Incoming jump from 0x223D, if !(stack[-1] < 0x14) // Incoming jump from 0x223D, if !(0x00 < 0x14) // Inputs[3] // { // @22FD stack[-2] // @22FD stack[-5] // @22FE stack[-4] // } 22FB 5B JUMPDEST 22FC 50 POP 22FD 92 SWAP3 22FE 91 SWAP2 22FF 50 POP 2300 50 POP 2301 56 *JUMP // Stack delta = -4 // Outputs[1] { @22FD stack[-5] = stack[-2] } // Block ends with unconditional jump to stack[-5] label_2302: // Incoming call from 0x183C, returns to 0x183D // Inputs[2] // { // @2306 memory[0x40:0x60] // @231E code.length // } 2302 5B JUMPDEST 2303 60 PUSH1 0x40 2305 80 DUP1 2306 51 MLOAD 2307 60 PUSH1 0x20 2309 80 DUP1 230A 82 DUP3 230B 52 MSTORE 230C 81 DUP2 230D 83 DUP4 230E 01 ADD 230F 90 SWAP1 2310 92 SWAP3 2311 52 MSTORE 2312 60 PUSH1 0x60 2314 91 SWAP2 2315 82 DUP3 2316 91 SWAP2 2317 90 SWAP1 2318 60 PUSH1 0x20 231A 82 DUP3 231B 01 ADD 231C 81 DUP2 231D 80 DUP1 231E 38 CODESIZE 231F 83 DUP4 2320 39 CODECOPY 2321 01 ADD 2322 90 SWAP1 2323 50 POP 2324 50 POP 2325 90 SWAP1 2326 50 POP 2327 60 PUSH1 0x00 2329 80 DUP1 232A 5B JUMPDEST 232B 60 PUSH1 0x20 232D 81 DUP2 232E 10 LT 232F 15 ISZERO 2330 61 PUSH2 0x2398 2333 57 *JUMPI // Stack delta = +4 // Outputs[7] // { // @230B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @2311 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @2314 stack[0] = 0x60 // @2320 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = code[code.length:code.length + 0x20] // @2325 stack[1] = memory[0x40:0x60] // @2327 stack[2] = 0x00 // @2329 stack[3] = 0x00 // } // Block ends with conditional jump to 0x2398, if !(0x00 < 0x20) label_2334: // Incoming jump from 0x2333, if not !(0x00 < 0x20) // Incoming jump from 0x2333, if not !(stack[-1] < 0x20) // Inputs[2] // { // @2336 stack[-1] // @233B stack[-5] // } 2334 60 PUSH1 0x08 2336 81 DUP2 2337 02 MUL 2338 60 PUSH1 0x02 233A 0A EXP 233B 85 DUP6 233C 02 MUL 233D 7F PUSH32 0xff00000000000000000000000000000000000000000000000000000000000000 235E 81 DUP2 235F 16 AND 2360 15 ISZERO 2361 61 PUSH2 0x238f 2364 57 *JUMPI // Stack delta = +1 // Outputs[1] { @233C stack[0] = stack[-5] * 0x02 ** (stack[-1] * 0x08) } // Block ends with conditional jump to 0x238f, if !(stack[-5] * 0x02 ** (stack[-1] * 0x08) & 0xff00000000000000000000000000000000000000000000000000000000000000) label_2365: // Incoming jump from 0x2364, if not !(stack[-5] * 0x02 ** (stack[-1] * 0x08) & 0xff00000000000000000000000000000000000000000000000000000000000000) // Inputs[4] // { // @2365 stack[-1] // @2366 stack[-4] // @2367 stack[-3] // @2369 memory[stack[-4]:stack[-4] + 0x20] // } 2365 80 DUP1 2366 84 DUP5 2367 84 DUP5 2368 81 DUP2 2369 51 MLOAD 236A 81 DUP2 236B 10 LT 236C 61 PUSH2 0x2371 236F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2365 stack[0] = stack[-1] // @2366 stack[1] = stack[-4] // @2367 stack[2] = stack[-3] // } // Block ends with conditional jump to 0x2371, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_2370: // Incoming jump from 0x236F, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 2370 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2370 assert(); } // Block terminates label_2371: // Incoming jump from 0x236F, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[5] // { // @2374 stack[-1] // @2375 stack[-2] // @2376 stack[-3] // @238B stack[-4] // @238C stack[-6] // } 2371 5B JUMPDEST 2372 60 PUSH1 0x20 2374 01 ADD 2375 01 ADD 2376 90 SWAP1 2377 60 PUSH1 0x01 2379 60 PUSH1 0x01 237B 60 PUSH1 0xf8 237D 1B SHL 237E 03 SUB 237F 19 NOT 2380 16 AND 2381 90 SWAP1 2382 81 DUP2 2383 60 PUSH1 0x00 2385 1A BYTE 2386 90 SWAP1 2387 53 MSTORE8 2388 50 POP 2389 60 PUSH1 0x01 238B 90 SWAP1 238C 92 SWAP3 238D 01 ADD 238E 91 SWAP2 // Stack delta = -3 // Outputs[3] // { // @2387 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @238E stack[-6] = stack[-6] + 0x01 // @238E stack[-4] = stack[-4] // } // Block continues label_238F: // Incoming jump from 0x2364, if !(stack[-5] * 0x02 ** (stack[-1] * 0x08) & 0xff00000000000000000000000000000000000000000000000000000000000000) // Incoming jump from 0x238E // Inputs[1] { @2393 stack[-2] } 238F 5B JUMPDEST 2390 50 POP 2391 60 PUSH1 0x01 2393 01 ADD 2394 61 PUSH2 0x232a 2397 56 *JUMP // Stack delta = -1 // Outputs[1] { @2393 stack[-2] = 0x01 + stack[-2] } // Block ends with unconditional jump to 0x232a label_2398: // Incoming jump from 0x2333, if !(0x00 < 0x20) // Incoming jump from 0x2333, if !(stack[-1] < 0x20) // Inputs[2] // { // @239C stack[-2] // @239F memory[0x40:0x60] // } 2398 5B JUMPDEST 2399 50 POP 239A 60 PUSH1 0x60 239C 81 DUP2 239D 60 PUSH1 0x40 239F 51 MLOAD 23A0 90 SWAP1 23A1 80 DUP1 23A2 82 DUP3 23A3 52 MSTORE 23A4 80 DUP1 23A5 60 PUSH1 0x1f 23A7 01 ADD 23A8 60 PUSH1 0x1f 23AA 19 NOT 23AB 16 AND 23AC 60 PUSH1 0x20 23AE 01 ADD 23AF 82 DUP3 23B0 01 ADD 23B1 60 PUSH1 0x40 23B3 52 MSTORE 23B4 80 DUP1 23B5 15 ISZERO 23B6 61 PUSH2 0x23c6 23B9 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @239A stack[-1] = 0x60 // @23A0 stack[1] = stack[-2] // @23A0 stack[0] = memory[0x40:0x60] // @23A3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @23B3 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-2]) // } // Block ends with conditional jump to 0x23c6, if !stack[-2] label_23BA: // Incoming jump from 0x23B9, if not !stack[-2] // Inputs[5] // { // @23BC stack[-2] // @23BE stack[-1] // @23C0 code.length // @23C8 stack[-3] // @23CD stack[-4] // } 23BA 60 PUSH1 0x20 23BC 82 DUP3 23BD 01 ADD 23BE 81 DUP2 23BF 80 DUP1 23C0 38 CODESIZE 23C1 83 DUP4 23C2 39 CODECOPY 23C3 01 ADD 23C4 90 SWAP1 23C5 50 POP 23C6 5B JUMPDEST 23C7 50 POP 23C8 90 SWAP1 23C9 50 POP 23CA 60 PUSH1 0x00 23CC 5B JUMPDEST 23CD 82 DUP3 23CE 81 DUP2 23CF 10 LT 23D0 15 ISZERO 23D1 61 PUSH2 0x2416 23D4 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @23C2 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = code[code.length:code.length + stack[-1]] // @23C8 stack[-3] = stack[-2] // @23CA stack[-2] = 0x00 // } // Block ends with conditional jump to 0x2416, if !(0x00 < stack[-4]) label_23D5: // Incoming jump from 0x23D4, if not !(0x00 < stack[-4]) // Incoming jump from 0x23D4, if not !(0x00 < stack[-4]) // Incoming jump from 0x23D4, if not !(stack[-1] < stack[-3]) // Inputs[3] // { // @23D5 stack[-4] // @23D6 stack[-1] // @23D8 memory[stack[-4]:stack[-4] + 0x20] // } 23D5 83 DUP4 23D6 81 DUP2 23D7 81 DUP2 23D8 51 MLOAD 23D9 81 DUP2 23DA 10 LT 23DB 61 PUSH2 0x23e0 23DE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @23D5 stack[0] = stack[-4] // @23D6 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x23e0, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] label_23DF: // Incoming jump from 0x23DE, if not stack[-1] < memory[stack[-4]:stack[-4] + 0x20] 23DF FE *ASSERT // Stack delta = +0 // Outputs[1] { @23DF assert(); } // Block terminates label_23E0: // Incoming jump from 0x23DE, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[6] // { // @23E3 stack[-1] // @23E4 stack[-2] // @23E5 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] // @23EC stack[-4] // @23ED stack[-3] // @23EF memory[stack[-4]:stack[-4] + 0x20] // } 23E0 5B JUMPDEST 23E1 60 PUSH1 0x20 23E3 01 ADD 23E4 01 ADD 23E5 51 MLOAD 23E6 60 PUSH1 0xf8 23E8 1C SHR 23E9 60 PUSH1 0xf8 23EB 1B SHL 23EC 82 DUP3 23ED 82 DUP3 23EE 81 DUP2 23EF 51 MLOAD 23F0 81 DUP2 23F1 10 LT 23F2 61 PUSH2 0x23f7 23F5 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @23EB stack[-2] = (memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] >> 0xf8) << 0xf8 // @23EC stack[-1] = stack[-4] // @23ED stack[0] = stack[-3] // } // Block ends with conditional jump to 0x23f7, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_23F6: // Incoming jump from 0x23F5, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 23F6 FE *ASSERT // Stack delta = +0 // Outputs[1] { @23F6 assert(); } // Block terminates label_23F7: // Incoming jump from 0x23F5, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @23FA stack[-1] // @23FB stack[-2] // @23FC stack[-3] // @2411 stack[-4] // } 23F7 5B JUMPDEST 23F8 60 PUSH1 0x20 23FA 01 ADD 23FB 01 ADD 23FC 90 SWAP1 23FD 60 PUSH1 0x01 23FF 60 PUSH1 0x01 2401 60 PUSH1 0xf8 2403 1B SHL 2404 03 SUB 2405 19 NOT 2406 16 AND 2407 90 SWAP1 2408 81 DUP2 2409 60 PUSH1 0x00 240B 1A BYTE 240C 90 SWAP1 240D 53 MSTORE8 240E 50 POP 240F 60 PUSH1 0x01 2411 01 ADD 2412 61 PUSH2 0x23cc 2415 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @240D memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @2411 stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x23cc label_2416: // Incoming jump from 0x23D4, if !(0x00 < stack[-4]) // Incoming jump from 0x23D4, if !(stack[-1] < stack[-3]) // Incoming jump from 0x23D4, if !(0x00 < stack[-4]) // Inputs[3] // { // @2418 stack[-7] // @2418 stack[-2] // @2419 stack[-6] // } 2416 5B JUMPDEST 2417 50 POP 2418 94 SWAP5 2419 93 SWAP4 241A 50 POP 241B 50 POP 241C 50 POP 241D 50 POP 241E 56 *JUMP // Stack delta = -6 // Outputs[1] { @2418 stack[-7] = stack[-2] } // Block ends with unconditional jump to stack[-7] label_241F: // Incoming call from 0x1845, returns to 0x1846 // Inputs[1] { @2422 stack[-1] } 241F 5B JUMPDEST 2420 60 PUSH1 0x60 2422 81 DUP2 2423 80 DUP1 2424 61 PUSH2 0x2462 2427 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2420 stack[0] = 0x60 // @2422 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2462, if stack[-1] label_2428: // Incoming jump from 0x2427, if not stack[-1] // Inputs[1] { @242D memory[0x40:0x60] } 2428 50 POP 2429 50 POP 242A 60 PUSH1 0x40 242C 80 DUP1 242D 51 MLOAD 242E 80 DUP1 242F 82 DUP3 2430 01 ADD 2431 90 SWAP1 2432 91 SWAP2 2433 52 MSTORE 2434 60 PUSH1 0x01 2436 81 DUP2 2437 52 MSTORE 2438 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 2459 60 PUSH1 0x20 245B 82 DUP3 245C 01 ADD 245D 52 MSTORE 245E 61 PUSH2 0x0970 2461 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2432 stack[-2] = memory[0x40:0x60] // @2433 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @2437 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @245D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x3000000000000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to 0x0970 label_2462: // Incoming jump from 0x2427, if stack[-1] // Inputs[1] { @2463 stack[-1] } 2462 5B JUMPDEST 2463 80 DUP1 2464 60 PUSH1 0x00 2466 5B JUMPDEST 2467 81 DUP2 2468 15 ISZERO 2469 61 PUSH2 0x247a 246C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2463 stack[0] = stack[-1] // @2464 stack[1] = 0x00 // } // Block ends with conditional jump to 0x247a, if !stack[-1] label_246D: // Incoming jump from 0x246C, if not !stack[-1] // Incoming jump from 0x246C, if not !stack[-2] // Inputs[2] // { // @246F stack[-1] // @2472 stack[-2] // } 246D 60 PUSH1 0x01 246F 01 ADD 2470 60 PUSH1 0x0a 2472 82 DUP3 2473 04 DIV 2474 91 SWAP2 2475 50 POP 2476 61 PUSH2 0x2466 2479 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @246F stack[-1] = 0x01 + stack[-1] // @2474 stack[-2] = stack[-2] / 0x0a // } // Block ends with unconditional jump to 0x2466 label_247A: // Incoming jump from 0x246C, if !stack[-1] // Incoming jump from 0x246C, if !stack[-2] // Inputs[2] // { // @247D stack[-1] // @2480 memory[0x40:0x60] // } 247A 5B JUMPDEST 247B 60 PUSH1 0x60 247D 81 DUP2 247E 60 PUSH1 0x40 2480 51 MLOAD 2481 90 SWAP1 2482 80 DUP1 2483 82 DUP3 2484 52 MSTORE 2485 80 DUP1 2486 60 PUSH1 0x1f 2488 01 ADD 2489 60 PUSH1 0x1f 248B 19 NOT 248C 16 AND 248D 60 PUSH1 0x20 248F 01 ADD 2490 82 DUP3 2491 01 ADD 2492 60 PUSH1 0x40 2494 52 MSTORE 2495 80 DUP1 2496 15 ISZERO 2497 61 PUSH2 0x24a7 249A 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @247B stack[0] = 0x60 // @2481 stack[1] = memory[0x40:0x60] // @2481 stack[2] = stack[-1] // @2484 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @2494 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x24a7, if !stack[-1] label_249B: // Incoming jump from 0x249A, if not !stack[-1] // Inputs[6] // { // @249D stack[-2] // @249F stack[-1] // @24A1 code.length // @24A9 stack[-3] // @24AE stack[-4] // @24B1 stack[-6] // } 249B 60 PUSH1 0x20 249D 82 DUP3 249E 01 ADD 249F 81 DUP2 24A0 80 DUP1 24A1 38 CODESIZE 24A2 83 DUP4 24A3 39 CODECOPY 24A4 01 ADD 24A5 90 SWAP1 24A6 50 POP 24A7 5B JUMPDEST 24A8 50 POP 24A9 90 SWAP1 24AA 50 POP 24AB 60 PUSH1 0x00 24AD 19 NOT 24AE 82 DUP3 24AF 01 ADD 24B0 5B JUMPDEST 24B1 84 DUP5 24B2 15 ISZERO 24B3 61 PUSH2 0x24f5 24B6 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @24A3 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = code[code.length:code.length + stack[-1]] // @24A9 stack[-3] = stack[-2] // @24AF stack[-2] = stack[-4] + ~0x00 // } // Block ends with conditional jump to 0x24f5, if !stack[-6] label_24B7: // Incoming jump from 0x24B6, if not !stack[-6] // Incoming jump from 0x24B6, if not !stack[-6] // Incoming jump from 0x24B6, if not !stack[-5] // Inputs[4] // { // @24B9 stack[-5] // @24C1 stack[-2] // @24C2 stack[-1] // @24CB memory[stack[-2]:stack[-2] + 0x20] // } 24B7 60 PUSH1 0x0a 24B9 85 DUP6 24BA 06 MOD 24BB 60 PUSH1 0x30 24BD 01 ADD 24BE 60 PUSH1 0xf8 24C0 1B SHL 24C1 82 DUP3 24C2 82 DUP3 24C3 80 DUP1 24C4 60 PUSH1 0x01 24C6 90 SWAP1 24C7 03 SUB 24C8 93 SWAP4 24C9 50 POP 24CA 81 DUP2 24CB 51 MLOAD 24CC 81 DUP2 24CD 10 LT 24CE 61 PUSH2 0x24d3 24D1 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @24C0 stack[0] = 0x30 + stack[-5] % 0x0a << 0xf8 // @24C1 stack[1] = stack[-2] // @24C2 stack[2] = stack[-1] // @24C8 stack[-1] = stack[-1] - 0x01 // } // Block ends with conditional jump to 0x24d3, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_24D2: // Incoming jump from 0x24D1, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 24D2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @24D2 assert(); } // Block terminates label_24D3: // Incoming jump from 0x24D1, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @24D6 stack[-1] // @24D7 stack[-2] // @24D8 stack[-3] // @24ED stack[-8] // } 24D3 5B JUMPDEST 24D4 60 PUSH1 0x20 24D6 01 ADD 24D7 01 ADD 24D8 90 SWAP1 24D9 60 PUSH1 0x01 24DB 60 PUSH1 0x01 24DD 60 PUSH1 0xf8 24DF 1B SHL 24E0 03 SUB 24E1 19 NOT 24E2 16 AND 24E3 90 SWAP1 24E4 81 DUP2 24E5 60 PUSH1 0x00 24E7 1A BYTE 24E8 90 SWAP1 24E9 53 MSTORE8 24EA 50 POP 24EB 60 PUSH1 0x0a 24ED 85 DUP6 24EE 04 DIV 24EF 94 SWAP5 24F0 50 POP 24F1 61 PUSH2 0x24b0 24F4 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @24E9 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @24EF stack[-8] = stack[-8] / 0x0a // } // Block ends with unconditional jump to 0x24b0 label_24F5: // Incoming jump from 0x24B6, if !stack[-6] // Incoming jump from 0x24B6, if !stack[-6] // Incoming jump from 0x24B6, if !stack[-5] // Inputs[3] // { // @24F7 stack[-2] // @24F7 stack[-8] // @24F8 stack[-7] // } 24F5 5B JUMPDEST 24F6 50 POP 24F7 95 SWAP6 24F8 94 SWAP5 24F9 50 POP 24FA 50 POP 24FB 50 POP 24FC 50 POP 24FD 50 POP 24FE 56 *JUMP // Stack delta = -7 // Outputs[1] { @24F7 stack[-8] = stack[-2] } // Block ends with unconditional jump to stack[-8] label_24FF: // Incoming call from 0x1B6D, returns to 0x1B6E // Inputs[1] { @2506 stack[-1] } 24FF 5B JUMPDEST 2500 60 PUSH1 0x00 2502 80 DUP1 2503 61 PUSH2 0x250b 2506 83 DUP4 2507 61 PUSH2 0x0dda 250A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2500 stack[0] = 0x00 // @2502 stack[1] = 0x00 // @2503 stack[2] = 0x250b // @2506 stack[3] = stack[-1] // } // Block ends with call to 0x0dda, returns to 0x250B label_250B: // Incoming return from call to 0x0DDA at 0x250A // Incoming return from call to 0x0DDA at 0x250A // Inputs[2] // { // @250C stack[-1] // @250C stack[-2] // } 250B 5B JUMPDEST 250C 90 SWAP1 250D 50 POP 250E 60 PUSH1 0x01 2510 60 PUSH1 0x01 2512 60 PUSH1 0xa0 2514 1B SHL 2515 03 SUB 2516 81 DUP2 2517 16 AND 2518 61 PUSH2 0x2552 251B 57 *JUMPI // Stack delta = -1 // Outputs[1] { @250C stack[-2] = stack[-1] } // Block ends with conditional jump to 0x2552, if stack[-1] & (0x01 << 0xa0) - 0x01 label_251C: // Incoming jump from 0x251B, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @251E memory[0x40:0x60] // @254C memory[0x40:0x60] // @2551 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 251C 60 PUSH1 0x40 251E 51 MLOAD 251F 62 PUSH3 0x461bcd 2523 60 PUSH1 0xe5 2525 1B SHL 2526 81 DUP2 2527 52 MSTORE 2528 60 PUSH1 0x04 252A 01 ADD 252B 80 DUP1 252C 80 DUP1 252D 60 PUSH1 0x20 252F 01 ADD 2530 82 DUP3 2531 81 DUP2 2532 03 SUB 2533 82 DUP3 2534 52 MSTORE 2535 60 PUSH1 0x2c 2537 81 DUP2 2538 52 MSTORE 2539 60 PUSH1 0x20 253B 01 ADD 253C 80 DUP1 253D 61 PUSH2 0x2d2f 2540 60 PUSH1 0x2c 2542 91 SWAP2 2543 39 CODECOPY 2544 60 PUSH1 0x40 2546 01 ADD 2547 91 SWAP2 2548 50 POP 2549 50 POP 254A 60 PUSH1 0x40 254C 51 MLOAD 254D 80 DUP1 254E 91 SWAP2 254F 03 SUB 2550 90 SWAP1 2551 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2527 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2534 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2538 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @2543 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x2d2f:0x2d5b] // @2551 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2552: // Incoming jump from 0x251B, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @2553 stack[-1] // @255D stack[-4] // } 2552 5B JUMPDEST 2553 80 DUP1 2554 60 PUSH1 0x01 2556 60 PUSH1 0x01 2558 60 PUSH1 0xa0 255A 1B SHL 255B 03 SUB 255C 16 AND 255D 84 DUP5 255E 60 PUSH1 0x01 2560 60 PUSH1 0x01 2562 60 PUSH1 0xa0 2564 1B SHL 2565 03 SUB 2566 16 AND 2567 14 EQ 2568 80 DUP1 2569 61 PUSH2 0x258b 256C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2567 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1] } // Block ends with conditional jump to 0x258b, if (0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1] label_256D: // Incoming jump from 0x256C, if not (0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[2] // { // @256E stack[-5] // @257B stack[-4] // } 256D 50 POP 256E 83 DUP4 256F 60 PUSH1 0x01 2571 60 PUSH1 0x01 2573 60 PUSH1 0xa0 2575 1B SHL 2576 03 SUB 2577 16 AND 2578 61 PUSH2 0x2580 257B 84 DUP5 257C 61 PUSH2 0x0a12 257F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2577 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] // @2578 stack[0] = 0x2580 // @257B stack[1] = stack[-4] // } // Block ends with call to 0x0a12, returns to 0x2580 label_2580: // Incoming return from call to 0x0A12 at 0x257F // Inputs[2] // { // @2589 stack[-1] // @258A stack[-2] // } 2580 5B JUMPDEST 2581 60 PUSH1 0x01 2583 60 PUSH1 0x01 2585 60 PUSH1 0xa0 2587 1B SHL 2588 03 SUB 2589 16 AND 258A 14 EQ // Stack delta = -1 // Outputs[1] { @258A stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_258B: // Incoming jump from 0x258A // Incoming jump from 0x256C, if (0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[1] { @258C stack[-1] } 258B 5B JUMPDEST 258C 80 DUP1 258D 61 PUSH2 0x259b 2590 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x259b, if stack[-1] label_2591: // Incoming jump from 0x2590, if not stack[-1] // Inputs[2] // { // @2595 stack[-2] // @2596 stack[-5] // } 2591 50 POP 2592 61 PUSH2 0x259b 2595 81 DUP2 2596 85 DUP6 2597 61 PUSH2 0x1a59 259A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2592 stack[-1] = 0x259b // @2595 stack[0] = stack[-2] // @2596 stack[1] = stack[-5] // } // Block ends with call to 0x1a59, returns to 0x259B label_259B: // Incoming jump from 0x2590, if stack[-1] // Incoming return from call to 0x1A59 at 0x259A // Inputs[3] // { // @259C stack[-1] // @259C stack[-6] // @259D stack[-5] // } 259B 5B JUMPDEST 259C 94 SWAP5 259D 93 SWAP4 259E 50 POP 259F 50 POP 25A0 50 POP 25A1 50 POP 25A2 56 *JUMP // Stack delta = -5 // Outputs[1] { @259C stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_25A3: // Incoming call from 0x1D70, returns to 0x1D71 // Inputs[3] // { // @25A6 stack[-1] // @25A7 stack[-3] // @25A8 stack[-2] // } 25A3 5B JUMPDEST 25A4 60 PUSH1 0x00 25A6 81 DUP2 25A7 84 DUP5 25A8 84 DUP5 25A9 11 GT 25AA 15 ISZERO 25AB 61 PUSH2 0x2632 25AE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @25A4 stack[0] = 0x00 // @25A6 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2632, if !(stack[-2] > stack[-3]) label_25AF: // Incoming jump from 0x25AE, if not !(stack[-2] > stack[-3]) // Inputs[4] // { // @25B1 memory[0x40:0x60] // @25C8 stack[-1] // @25CB memory[stack[-1]:stack[-1] + 0x20] // @25D4 memory[stack[-1]:stack[-1] + 0x20] // } 25AF 60 PUSH1 0x40 25B1 51 MLOAD 25B2 62 PUSH3 0x461bcd 25B6 60 PUSH1 0xe5 25B8 1B SHL 25B9 81 DUP2 25BA 52 MSTORE 25BB 60 PUSH1 0x04 25BD 01 ADD 25BE 80 DUP1 25BF 80 DUP1 25C0 60 PUSH1 0x20 25C2 01 ADD 25C3 82 DUP3 25C4 81 DUP2 25C5 03 SUB 25C6 82 DUP3 25C7 52 MSTORE 25C8 83 DUP4 25C9 81 DUP2 25CA 81 DUP2 25CB 51 MLOAD 25CC 81 DUP2 25CD 52 MSTORE 25CE 60 PUSH1 0x20 25D0 01 ADD 25D1 91 SWAP2 25D2 50 POP 25D3 80 DUP1 25D4 51 MLOAD 25D5 90 SWAP1 25D6 60 PUSH1 0x20 25D8 01 ADD 25D9 90 SWAP1 25DA 80 DUP1 25DB 83 DUP4 25DC 83 DUP4 25DD 60 PUSH1 0x00 25DF 5B JUMPDEST 25E0 83 DUP4 25E1 81 DUP2 25E2 10 LT 25E3 15 ISZERO 25E4 61 PUSH2 0x25f7 25E7 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @25BA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @25BD stack[0] = 0x04 + memory[0x40:0x60] // @25BE stack[1] = 0x04 + memory[0x40:0x60] // @25C7 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @25CD memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @25D1 stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @25D9 stack[3] = 0x20 + stack[-1] // @25D9 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @25DA stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @25DB stack[6] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @25DC stack[7] = 0x20 + stack[-1] // @25DD stack[8] = 0x00 // } // Block ends with conditional jump to 0x25f7, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_25E8: // Incoming jump from 0x25E7, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x25E7, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @25E8 stack[-2] // @25E9 stack[-1] // @25EB memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @25EC stack[-3] // } 25E8 81 DUP2 25E9 81 DUP2 25EA 01 ADD 25EB 51 MLOAD 25EC 83 DUP4 25ED 82 DUP3 25EE 01 ADD 25EF 52 MSTORE 25F0 60 PUSH1 0x20 25F2 01 ADD 25F3 61 PUSH2 0x25df 25F6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @25EF memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @25F2 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x25df label_25F7: // Incoming jump from 0x25E7, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x25E7, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @25FC stack[-6] // @25FC stack[-5] // @25FE stack[-7] // } 25F7 5B JUMPDEST 25F8 50 POP 25F9 50 POP 25FA 50 POP 25FB 50 POP 25FC 90 SWAP1 25FD 50 POP 25FE 90 SWAP1 25FF 81 DUP2 2600 01 ADD 2601 90 SWAP1 2602 60 PUSH1 0x1f 2604 16 AND 2605 80 DUP1 2606 15 ISZERO 2607 61 PUSH2 0x2624 260A 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2601 stack[-7] = stack[-5] + stack[-7] // @2604 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x2624, if !(0x1f & stack[-5]) label_260B: // Incoming jump from 0x260A, if not !(0x1f & stack[-5]) // Inputs[6] // { // @260B stack[-1] // @260C stack[-2] // @260F memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2626 stack[-5] // @262C memory[0x40:0x60] // @2631 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 260B 80 DUP1 260C 82 DUP3 260D 03 SUB 260E 80 DUP1 260F 51 MLOAD 2610 60 PUSH1 0x01 2612 83 DUP4 2613 60 PUSH1 0x20 2615 03 SUB 2616 61 PUSH2 0x0100 2619 0A EXP 261A 03 SUB 261B 19 NOT 261C 16 AND 261D 81 DUP2 261E 52 MSTORE 261F 60 PUSH1 0x20 2621 01 ADD 2622 91 SWAP2 2623 50 POP 2624 5B JUMPDEST 2625 50 POP 2626 92 SWAP3 2627 50 POP 2628 50 POP 2629 50 POP 262A 60 PUSH1 0x40 262C 51 MLOAD 262D 80 DUP1 262E 91 SWAP2 262F 03 SUB 2630 90 SWAP1 2631 FD *REVERT // Stack delta = -5 // Outputs[2] // { // @261E memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2631 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]); // } // Block terminates label_2632: // Incoming jump from 0x25AE, if !(stack[-2] > stack[-3]) // Inputs[3] // { // @2636 stack[-4] // @2636 stack[-5] // @2638 stack[-6] // } 2632 5B JUMPDEST 2633 50 POP 2634 50 POP 2635 50 POP 2636 90 SWAP1 2637 03 SUB 2638 90 SWAP1 2639 56 *JUMP // Stack delta = -5 // Outputs[1] { @2638 stack[-6] = stack[-5] - stack[-4] } // Block ends with unconditional jump to stack[-6] label_263A: // Incoming call from 0x1DF0, returns to 0x1DF1 // Incoming call from 0x2046, returns to 0x2047 // Inputs[1] { @263D stack[-1] } 263A 5B JUMPDEST 263B 60 PUSH1 0x00 263D 81 DUP2 263E 15 ISZERO 263F 80 DUP1 2640 15 ISZERO 2641 90 SWAP1 2642 61 PUSH2 0x1d71 2645 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @263B stack[0] = 0x00 // @2641 stack[1] = !!stack[-1] // } // Block ends with conditional jump to 0x1d71, if !stack[-1] label_2646: // Incoming jump from 0x2645, if not !stack[-1] // Inputs[3] // { // @2647 stack[-4] // @2648 storage[stack[-4]] // @2649 stack[-3] // } 2646 50 POP 2647 82 DUP3 2648 54 SLOAD 2649 82 DUP3 264A 14 EQ 264B 80 DUP1 264C 61 PUSH2 0x1d71 264F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @264A stack[-1] = stack[-3] == storage[stack[-4]] } // Block ends with conditional jump to 0x1d71, if stack[-3] == storage[stack[-4]] label_2650: // Incoming jump from 0x264F, if not stack[-3] == storage[stack[-4]] // Inputs[5] // { // @2654 stack[-3] // @2659 stack[-4] // @2663 memory[0x00:0x40] // @2664 storage[keccak256(memory[0x00:0x40])] // @2667 stack[-5] // } 2650 50 POP 2651 50 POP 2652 60 PUSH1 0x00 2654 90 SWAP1 2655 81 DUP2 2656 52 MSTORE 2657 60 PUSH1 0x01 2659 91 SWAP2 265A 90 SWAP1 265B 91 SWAP2 265C 01 ADD 265D 60 PUSH1 0x20 265F 52 MSTORE 2660 60 PUSH1 0x40 2662 90 SWAP1 2663 20 SHA3 2664 54 SLOAD 2665 15 ISZERO 2666 15 ISZERO 2667 90 SWAP1 2668 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2656 memory[0x00:0x20] = stack[-3] // @265F memory[0x20:0x40] = 0x01 + stack[-4] // @2667 stack[-5] = !!storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-5] label_2669: // Incoming call from 0x21BA, returns to 0x0934 // Incoming call from 0x21BA, returns to 0x0934 // Inputs[3] // { // @266D stack[-2] // @266E storage[stack[-2]] // @266F stack[-1] // } 2669 5B JUMPDEST 266A 60 PUSH1 0x00 266C 5B JUMPDEST 266D 82 DUP3 266E 54 SLOAD 266F 82 DUP3 2670 14 EQ 2671 80 DUP1 2672 15 ISZERO 2673 90 SWAP1 2674 61 PUSH2 0x2696 2677 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @266A stack[0] = 0x00 // @2673 stack[1] = !(stack[-1] == storage[stack[-2]]) // } // Block ends with conditional jump to 0x2696, if stack[-1] == storage[stack[-2]] label_2678: // Incoming jump from 0x2677, if not stack[-2] == storage[stack[-3]] // Incoming jump from 0x2677, if not stack[-1] == storage[stack[-2]] // Inputs[6] // { // @267B stack[-3] // @2680 stack[-4] // @2689 memory[0x00:0x40] // @268A storage[keccak256(memory[0x00:0x40])] // @268E memory[0x00:0x40] // @2692 storage[0x03 + keccak256(memory[0x00:0x40])] // } 2678 50 POP 2679 60 PUSH1 0x00 267B 82 DUP3 267C 81 DUP2 267D 52 MSTORE 267E 60 PUSH1 0x01 2680 84 DUP5 2681 01 ADD 2682 60 PUSH1 0x20 2684 52 MSTORE 2685 60 PUSH1 0x40 2687 80 DUP1 2688 82 DUP3 2689 20 SHA3 268A 54 SLOAD 268B 82 DUP3 268C 52 MSTORE 268D 90 SWAP1 268E 20 SHA3 268F 60 PUSH1 0x03 2691 01 ADD 2692 54 SLOAD 2693 60 PUSH1 0xff 2695 16 AND 2696 5B JUMPDEST 2697 15 ISZERO 2698 61 PUSH2 0x28b2 269B 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @267D memory[0x00:0x20] = stack[-3] // @2684 memory[0x20:0x40] = stack[-4] + 0x01 // @268C memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x28b2, if !(0xff & storage[0x03 + keccak256(memory[0x00:0x40])]) label_269C: // Incoming jump from 0x269B, if not !(0xff & storage[0x03 + keccak256(memory[0x00:0x40])]) // Incoming jump from 0x269B, if not !stack[-1] // Inputs[8] // { // @269E stack[-2] // @26A4 stack[-3] // @26AD memory[0x00:0x40] // @26AE storage[keccak256(memory[0x00:0x40])] // @26B4 memory[0x00:0x40] // @26B5 storage[keccak256(memory[0x00:0x40])] // @26B9 memory[0x00:0x40] // @26BB storage[keccak256(memory[0x00:0x40]) + 0x01] // } 269C 60 PUSH1 0x00 269E 82 DUP3 269F 81 DUP2 26A0 52 MSTORE 26A1 60 PUSH1 0x01 26A3 80 DUP1 26A4 85 DUP6 26A5 01 ADD 26A6 60 PUSH1 0x20 26A8 52 MSTORE 26A9 60 PUSH1 0x40 26AB 80 DUP1 26AC 83 DUP4 26AD 20 SHA3 26AE 54 SLOAD 26AF 80 DUP1 26B0 84 DUP5 26B1 52 MSTORE 26B2 81 DUP2 26B3 84 DUP5 26B4 20 SHA3 26B5 54 SLOAD 26B6 84 DUP5 26B7 52 MSTORE 26B8 92 SWAP3 26B9 20 SHA3 26BA 01 ADD 26BB 54 SLOAD 26BC 81 DUP2 26BD 14 EQ 26BE 15 ISZERO 26BF 61 PUSH2 0x27b9 26C2 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @26A0 memory[0x00:0x20] = stack[-2] // @26A8 memory[0x20:0x40] = stack[-3] + 0x01 // @26B1 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @26B7 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @26B8 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x27b9, if !(storage[keccak256(memory[0x00:0x40])] == storage[keccak256(memory[0x00:0x40]) + 0x01]) label_26C3: // Incoming jump from 0x26C2, if not !(storage[keccak256(memory[0x00:0x40])] == storage[keccak256(memory[0x00:0x40]) + 0x01]) // Inputs[9] // { // @26C5 stack[-1] // @26CA stack[-4] // @26D3 memory[0x00:0x40] // @26D4 storage[keccak256(memory[0x00:0x40])] // @26D9 memory[0x00:0x40] // @26DD storage[0x02 + keccak256(memory[0x00:0x40])] // @26E2 memory[0x00:0x40] // @26E6 storage[0x03 + keccak256(memory[0x00:0x40])] // @26E8 stack[-2] // } 26C3 60 PUSH1 0x00 26C5 81 DUP2 26C6 81 DUP2 26C7 52 MSTORE 26C8 60 PUSH1 0x01 26CA 85 DUP6 26CB 01 ADD 26CC 60 PUSH1 0x20 26CE 52 MSTORE 26CF 60 PUSH1 0x40 26D1 80 DUP1 26D2 82 DUP3 26D3 20 SHA3 26D4 54 SLOAD 26D5 82 DUP3 26D6 52 MSTORE 26D7 80 DUP1 26D8 82 DUP3 26D9 20 SHA3 26DA 60 PUSH1 0x02 26DC 01 ADD 26DD 54 SLOAD 26DE 80 DUP1 26DF 83 DUP4 26E0 52 MSTORE 26E1 91 SWAP2 26E2 20 SHA3 26E3 60 PUSH1 0x03 26E5 01 ADD 26E6 54 SLOAD 26E7 90 SWAP1 26E8 92 SWAP3 26E9 50 POP 26EA 60 PUSH1 0xff 26EC 16 AND 26ED 15 ISZERO 26EE 61 PUSH2 0x273f 26F1 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @26C7 memory[0x00:0x20] = stack[-1] // @26CE memory[0x20:0x40] = stack[-4] + 0x01 // @26D6 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @26E0 memory[0x00:0x20] = storage[0x02 + keccak256(memory[0x00:0x40])] // @26E8 stack[-2] = storage[0x02 + keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x273f, if !(0xff & storage[0x03 + keccak256(memory[0x00:0x40])]) label_26F2: // Incoming jump from 0x26F1, if not !(0xff & storage[0x03 + keccak256(memory[0x00:0x40])]) // Inputs[12] // { // @26F4 stack[-1] // @26FA stack[-4] // @2703 memory[0x00:0x40] // @270A storage[keccak256(memory[0x00:0x40]) + 0x03] // @2714 stack[-2] // @2719 memory[0x00:0x40] // @271D storage[0x03 + keccak256(memory[0x00:0x40])] // @2723 storage[keccak256(memory[0x00:0x40])] // @2728 memory[0x00:0x40] // @272B storage[keccak256(memory[0x00:0x40]) + 0x03] // @2738 storage[keccak256(memory[0x00:0x40])] // @2739 stack[-3] // } 26F2 60 PUSH1 0x00 26F4 81 DUP2 26F5 81 DUP2 26F6 52 MSTORE 26F7 60 PUSH1 0x01 26F9 80 DUP1 26FA 86 DUP7 26FB 01 ADD 26FC 60 PUSH1 0x20 26FE 52 MSTORE 26FF 60 PUSH1 0x40 2701 80 DUP1 2702 83 DUP4 2703 20 SHA3 2704 60 PUSH1 0x03 2706 80 DUP1 2707 82 DUP3 2708 01 ADD 2709 80 DUP1 270A 54 SLOAD 270B 60 PUSH1 0xff 270D 19 NOT 270E 90 SWAP1 270F 81 DUP2 2710 16 AND 2711 90 SWAP1 2712 91 SWAP2 2713 55 SSTORE 2714 87 DUP8 2715 86 DUP7 2716 52 MSTORE 2717 83 DUP4 2718 86 DUP7 2719 20 SHA3 271A 82 DUP3 271B 01 ADD 271C 80 DUP1 271D 54 SLOAD 271E 82 DUP3 271F 16 AND 2720 90 SWAP1 2721 55 SSTORE 2722 82 DUP3 2723 54 SLOAD 2724 86 DUP7 2725 52 MSTORE 2726 92 SWAP3 2727 85 DUP6 2728 20 SHA3 2729 01 ADD 272A 80 DUP1 272B 54 SLOAD 272C 90 SWAP1 272D 92 SWAP3 272E 16 AND 272F 90 SWAP1 2730 92 SWAP3 2731 17 OR 2732 90 SWAP1 2733 55 SSTORE 2734 90 SWAP1 2735 82 DUP3 2736 90 SWAP1 2737 52 MSTORE 2738 54 SLOAD 2739 92 SWAP3 273A 50 POP 273B 61 PUSH2 0x27b4 273E 56 *JUMP // Stack delta = +0 // Outputs[9] // { // @26F6 memory[0x00:0x20] = stack[-1] // @26FE memory[0x20:0x40] = stack[-4] + 0x01 // @2713 storage[keccak256(memory[0x00:0x40]) + 0x03] = ~0xff & storage[keccak256(memory[0x00:0x40]) + 0x03] // @2716 memory[0x00:0x20] = stack[-2] // @2721 storage[0x03 + keccak256(memory[0x00:0x40])] = ~0xff & storage[0x03 + keccak256(memory[0x00:0x40])] // @2725 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @2733 storage[keccak256(memory[0x00:0x40]) + 0x03] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40]) + 0x03]) // @2737 memory[0x00:0x20] = stack[-1] // @2739 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x27b4 label_273F: // Incoming jump from 0x26F1, if !(0xff & storage[0x03 + keccak256(memory[0x00:0x40])]) // Inputs[5] // { // @2742 stack[-1] // @2747 stack[-4] // @274F memory[0x00:0x40] // @2753 storage[0x02 + keccak256(memory[0x00:0x40])] // @2754 stack[-3] // } 273F 5B JUMPDEST 2740 60 PUSH1 0x00 2742 81 DUP2 2743 81 DUP2 2744 52 MSTORE 2745 60 PUSH1 0x01 2747 85 DUP6 2748 01 ADD 2749 60 PUSH1 0x20 274B 52 MSTORE 274C 60 PUSH1 0x40 274E 90 SWAP1 274F 20 SHA3 2750 60 PUSH1 0x02 2752 01 ADD 2753 54 SLOAD 2754 83 DUP4 2755 14 EQ 2756 15 ISZERO 2757 61 PUSH2 0x2767 275A 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2744 memory[0x00:0x20] = stack[-1] // @274B memory[0x20:0x40] = stack[-4] + 0x01 // } // Block ends with conditional jump to 0x2767, if !(stack[-3] == storage[0x02 + keccak256(memory[0x00:0x40])]) label_275B: // Incoming jump from 0x275A, if not !(stack[-3] == storage[0x02 + keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @275B stack[-1] // @275C stack[-3] // @2761 stack[-4] // } 275B 80 DUP1 275C 92 SWAP3 275D 50 POP 275E 61 PUSH2 0x2767 2761 84 DUP5 2762 84 DUP5 2763 61 PUSH2 0x2a75 2766 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @275C stack[-3] = stack[-1] // @275E stack[0] = 0x2767 // @2761 stack[1] = stack[-4] // @2762 stack[2] = stack[-1] // } // Block ends with call to 0x2a75, returns to 0x2767 label_2767: // Incoming return from call to 0x2A75 at 0x2766 // Incoming jump from 0x275A, if !(stack[-3] == storage[0x02 + keccak256(memory[0x00:0x40])]) // Inputs[10] // { // @276B stack[-3] // @2771 stack[-4] // @277A memory[0x00:0x40] // @277B storage[keccak256(memory[0x00:0x40])] // @2781 memory[0x00:0x40] // @2788 storage[keccak256(memory[0x00:0x40]) + 0x03] // @2793 storage[keccak256(memory[0x00:0x40])] // @2798 memory[0x00:0x40] // @279B storage[keccak256(memory[0x00:0x40]) + 0x03] // @27A9 storage[keccak256(memory[0x00:0x40])] // } 2767 5B JUMPDEST 2768 50 POP 2769 60 PUSH1 0x00 276B 82 DUP3 276C 81 DUP2 276D 52 MSTORE 276E 60 PUSH1 0x01 2770 80 DUP1 2771 85 DUP6 2772 01 ADD 2773 60 PUSH1 0x20 2775 52 MSTORE 2776 60 PUSH1 0x40 2778 80 DUP1 2779 83 DUP4 277A 20 SHA3 277B 54 SLOAD 277C 80 DUP1 277D 84 DUP5 277E 52 MSTORE 277F 81 DUP2 2780 84 DUP5 2781 20 SHA3 2782 60 PUSH1 0x03 2784 80 DUP1 2785 82 DUP3 2786 01 ADD 2787 80 DUP1 2788 54 SLOAD 2789 60 PUSH1 0xff 278B 19 NOT 278C 90 SWAP1 278D 81 DUP2 278E 16 AND 278F 90 SWAP1 2790 91 SWAP2 2791 55 SSTORE 2792 82 DUP3 2793 54 SLOAD 2794 87 DUP8 2795 52 MSTORE 2796 93 SWAP4 2797 86 DUP7 2798 20 SHA3 2799 01 ADD 279A 80 DUP1 279B 54 SLOAD 279C 90 SWAP1 279D 93 SWAP4 279E 16 AND 279F 90 SWAP1 27A0 93 SWAP4 27A1 17 OR 27A2 90 SWAP1 27A3 91 SWAP2 27A4 55 SSTORE 27A5 91 SWAP2 27A6 82 DUP3 27A7 90 SWAP1 27A8 52 MSTORE 27A9 54 SLOAD 27AA 61 PUSH2 0x27b4 27AD 90 SWAP1 27AE 85 DUP6 27AF 90 SWAP1 27B0 61 PUSH2 0x2b4d 27B3 56 *JUMP // Stack delta = +3 // Outputs[11] // { // @276D memory[0x00:0x20] = stack[-3] // @2775 memory[0x20:0x40] = stack[-4] + 0x01 // @277E memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @2791 storage[keccak256(memory[0x00:0x40]) + 0x03] = ~0xff & storage[keccak256(memory[0x00:0x40]) + 0x03] // @2795 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @27A4 storage[keccak256(memory[0x00:0x40]) + 0x03] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40]) + 0x03]) // @27A5 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @27A8 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @27AD stack[0] = 0x27b4 // @27AF stack[2] = storage[keccak256(memory[0x00:0x40])] // @27AF stack[1] = stack[-4] // } // Block ends with call to 0x2b4d, returns to 0x27B4 label_27B4: // Incoming jump from 0x273E // Incoming return from call to 0x2B4D at 0x27B3 27B4 5B JUMPDEST 27B5 61 PUSH2 0x28ac 27B8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x28ac label_27B9: // Incoming jump from 0x26C2, if !(storage[keccak256(memory[0x00:0x40])] == storage[keccak256(memory[0x00:0x40]) + 0x01]) // Inputs[9] // { // @27BC stack[-1] // @27C2 stack[-4] // @27CB memory[0x00:0x40] // @27CC storage[keccak256(memory[0x00:0x40])] // @27D1 memory[0x00:0x40] // @27D5 storage[0x01 + keccak256(memory[0x00:0x40])] // @27DA memory[0x00:0x40] // @27DE storage[0x03 + keccak256(memory[0x00:0x40])] // @27E0 stack[-2] // } 27B9 5B JUMPDEST 27BA 60 PUSH1 0x00 27BC 81 DUP2 27BD 81 DUP2 27BE 52 MSTORE 27BF 60 PUSH1 0x01 27C1 80 DUP1 27C2 86 DUP7 27C3 01 ADD 27C4 60 PUSH1 0x20 27C6 52 MSTORE 27C7 60 PUSH1 0x40 27C9 80 DUP1 27CA 83 DUP4 27CB 20 SHA3 27CC 54 SLOAD 27CD 83 DUP4 27CE 52 MSTORE 27CF 80 DUP1 27D0 83 DUP4 27D1 20 SHA3 27D2 90 SWAP1 27D3 91 SWAP2 27D4 01 ADD 27D5 54 SLOAD 27D6 80 DUP1 27D7 83 DUP4 27D8 52 MSTORE 27D9 91 SWAP2 27DA 20 SHA3 27DB 60 PUSH1 0x03 27DD 01 ADD 27DE 54 SLOAD 27DF 90 SWAP1 27E0 92 SWAP3 27E1 50 POP 27E2 60 PUSH1 0xff 27E4 16 AND 27E5 15 ISZERO 27E6 61 PUSH2 0x2837 27E9 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @27BE memory[0x00:0x20] = stack[-1] // @27C6 memory[0x20:0x40] = stack[-4] + 0x01 // @27CE memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @27D8 memory[0x00:0x20] = storage[0x01 + keccak256(memory[0x00:0x40])] // @27E0 stack[-2] = storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x2837, if !(0xff & storage[0x03 + keccak256(memory[0x00:0x40])]) label_27EA: // Incoming jump from 0x27E9, if not !(0xff & storage[0x03 + keccak256(memory[0x00:0x40])]) // Inputs[12] // { // @27EC stack[-1] // @27F2 stack[-4] // @27FB memory[0x00:0x40] // @2802 storage[keccak256(memory[0x00:0x40]) + 0x03] // @280C stack[-2] // @2811 memory[0x00:0x40] // @2815 storage[0x03 + keccak256(memory[0x00:0x40])] // @281B storage[keccak256(memory[0x00:0x40])] // @2820 memory[0x00:0x40] // @2823 storage[keccak256(memory[0x00:0x40]) + 0x03] // @2830 storage[keccak256(memory[0x00:0x40])] // @2831 stack[-3] // } 27EA 60 PUSH1 0x00 27EC 81 DUP2 27ED 81 DUP2 27EE 52 MSTORE 27EF 60 PUSH1 0x01 27F1 80 DUP1 27F2 86 DUP7 27F3 01 ADD 27F4 60 PUSH1 0x20 27F6 52 MSTORE 27F7 60 PUSH1 0x40 27F9 80 DUP1 27FA 83 DUP4 27FB 20 SHA3 27FC 60 PUSH1 0x03 27FE 80 DUP1 27FF 82 DUP3 2800 01 ADD 2801 80 DUP1 2802 54 SLOAD 2803 60 PUSH1 0xff 2805 19 NOT 2806 90 SWAP1 2807 81 DUP2 2808 16 AND 2809 90 SWAP1 280A 91 SWAP2 280B 55 SSTORE 280C 87 DUP8 280D 86 DUP7 280E 52 MSTORE 280F 83 DUP4 2810 86 DUP7 2811 20 SHA3 2812 82 DUP3 2813 01 ADD 2814 80 DUP1 2815 54 SLOAD 2816 82 DUP3 2817 16 AND 2818 90 SWAP1 2819 55 SSTORE 281A 82 DUP3 281B 54 SLOAD 281C 86 DUP7 281D 52 MSTORE 281E 92 SWAP3 281F 85 DUP6 2820 20 SHA3 2821 01 ADD 2822 80 DUP1 2823 54 SLOAD 2824 90 SWAP1 2825 92 SWAP3 2826 16 AND 2827 90 SWAP1 2828 92 SWAP3 2829 17 OR 282A 90 SWAP1 282B 55 SSTORE 282C 90 SWAP1 282D 82 DUP3 282E 90 SWAP1 282F 52 MSTORE 2830 54 SLOAD 2831 92 SWAP3 2832 50 POP 2833 61 PUSH2 0x28ac 2836 56 *JUMP // Stack delta = +0 // Outputs[9] // { // @27EE memory[0x00:0x20] = stack[-1] // @27F6 memory[0x20:0x40] = stack[-4] + 0x01 // @280B storage[keccak256(memory[0x00:0x40]) + 0x03] = ~0xff & storage[keccak256(memory[0x00:0x40]) + 0x03] // @280E memory[0x00:0x20] = stack[-2] // @2819 storage[0x03 + keccak256(memory[0x00:0x40])] = ~0xff & storage[0x03 + keccak256(memory[0x00:0x40])] // @281D memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @282B storage[keccak256(memory[0x00:0x40]) + 0x03] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40]) + 0x03]) // @282F memory[0x00:0x20] = stack[-1] // @2831 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x28ac label_2837: // Incoming jump from 0x27E9, if !(0xff & storage[0x03 + keccak256(memory[0x00:0x40])]) // Inputs[5] // { // @283A stack[-1] // @2840 stack[-4] // @2849 memory[0x00:0x40] // @284B storage[keccak256(memory[0x00:0x40]) + 0x01] // @284C stack[-3] // } 2837 5B JUMPDEST 2838 60 PUSH1 0x00 283A 81 DUP2 283B 81 DUP2 283C 52 MSTORE 283D 60 PUSH1 0x01 283F 80 DUP1 2840 86 DUP7 2841 01 ADD 2842 60 PUSH1 0x20 2844 52 MSTORE 2845 60 PUSH1 0x40 2847 90 SWAP1 2848 91 SWAP2 2849 20 SHA3 284A 01 ADD 284B 54 SLOAD 284C 83 DUP4 284D 14 EQ 284E 15 ISZERO 284F 61 PUSH2 0x285f 2852 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @283C memory[0x00:0x20] = stack[-1] // @2844 memory[0x20:0x40] = stack[-4] + 0x01 // } // Block ends with conditional jump to 0x285f, if !(stack[-3] == storage[keccak256(memory[0x00:0x40]) + 0x01]) label_2853: // Incoming jump from 0x2852, if not !(stack[-3] == storage[keccak256(memory[0x00:0x40]) + 0x01]) // Inputs[3] // { // @2853 stack[-1] // @2854 stack[-3] // @2859 stack[-4] // } 2853 80 DUP1 2854 92 SWAP3 2855 50 POP 2856 61 PUSH2 0x285f 2859 84 DUP5 285A 84 DUP5 285B 61 PUSH2 0x2b4d 285E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2854 stack[-3] = stack[-1] // @2856 stack[0] = 0x285f // @2859 stack[1] = stack[-4] // @285A stack[2] = stack[-1] // } // Block ends with call to 0x2b4d, returns to 0x285F label_285F: // Incoming jump from 0x2852, if !(stack[-3] == storage[keccak256(memory[0x00:0x40]) + 0x01]) // Incoming return from call to 0x2B4D at 0x285E // Inputs[10] // { // @2863 stack[-3] // @2869 stack[-4] // @2872 memory[0x00:0x40] // @2873 storage[keccak256(memory[0x00:0x40])] // @2879 memory[0x00:0x40] // @2880 storage[keccak256(memory[0x00:0x40]) + 0x03] // @288B storage[keccak256(memory[0x00:0x40])] // @2890 memory[0x00:0x40] // @2893 storage[keccak256(memory[0x00:0x40]) + 0x03] // @28A1 storage[keccak256(memory[0x00:0x40])] // } 285F 5B JUMPDEST 2860 50 POP 2861 60 PUSH1 0x00 2863 82 DUP3 2864 81 DUP2 2865 52 MSTORE 2866 60 PUSH1 0x01 2868 80 DUP1 2869 85 DUP6 286A 01 ADD 286B 60 PUSH1 0x20 286D 52 MSTORE 286E 60 PUSH1 0x40 2870 80 DUP1 2871 83 DUP4 2872 20 SHA3 2873 54 SLOAD 2874 80 DUP1 2875 84 DUP5 2876 52 MSTORE 2877 81 DUP2 2878 84 DUP5 2879 20 SHA3 287A 60 PUSH1 0x03 287C 80 DUP1 287D 82 DUP3 287E 01 ADD 287F 80 DUP1 2880 54 SLOAD 2881 60 PUSH1 0xff 2883 19 NOT 2884 90 SWAP1 2885 81 DUP2 2886 16 AND 2887 90 SWAP1 2888 91 SWAP2 2889 55 SSTORE 288A 82 DUP3 288B 54 SLOAD 288C 87 DUP8 288D 52 MSTORE 288E 93 SWAP4 288F 86 DUP7 2890 20 SHA3 2891 01 ADD 2892 80 DUP1 2893 54 SLOAD 2894 90 SWAP1 2895 93 SWAP4 2896 16 AND 2897 90 SWAP1 2898 93 SWAP4 2899 17 OR 289A 90 SWAP1 289B 91 SWAP2 289C 55 SSTORE 289D 91 SWAP2 289E 82 DUP3 289F 90 SWAP1 28A0 52 MSTORE 28A1 54 SLOAD 28A2 61 PUSH2 0x28ac 28A5 90 SWAP1 28A6 85 DUP6 28A7 90 SWAP1 28A8 61 PUSH2 0x2a75 28AB 56 *JUMP // Stack delta = +3 // Outputs[11] // { // @2865 memory[0x00:0x20] = stack[-3] // @286D memory[0x20:0x40] = stack[-4] + 0x01 // @2876 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @2889 storage[keccak256(memory[0x00:0x40]) + 0x03] = ~0xff & storage[keccak256(memory[0x00:0x40]) + 0x03] // @288D memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @289C storage[keccak256(memory[0x00:0x40]) + 0x03] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40]) + 0x03]) // @289D stack[-1] = storage[keccak256(memory[0x00:0x40])] // @28A0 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @28A5 stack[0] = 0x28ac // @28A7 stack[2] = storage[keccak256(memory[0x00:0x40])] // @28A7 stack[1] = stack[-4] // } // Block ends with call to 0x2a75, returns to 0x28AC label_28AC: // Incoming jump from 0x2836 // Incoming return from call to 0x2A75 at 0x28AB // Incoming jump from 0x27B8 28AC 5B JUMPDEST 28AD 50 POP 28AE 61 PUSH2 0x266c 28B1 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x266c label_28B2: // Incoming jump from 0x269B, if !(0xff & storage[0x03 + keccak256(memory[0x00:0x40])]) // Incoming jump from 0x269B, if !stack[-1] // Inputs[5] // { // @28B5 stack[-3] // @28B6 storage[stack[-3]] // @28C7 memory[0x00:0x40] // @28CC storage[0x03 + keccak256(memory[0x00:0x40])] // @28D3 stack[-4] // } 28B2 5B JUMPDEST 28B3 50 POP 28B4 50 POP 28B5 80 DUP1 28B6 54 SLOAD 28B7 60 PUSH1 0x00 28B9 90 SWAP1 28BA 81 DUP2 28BB 52 MSTORE 28BC 60 PUSH1 0x01 28BE 90 SWAP1 28BF 91 SWAP2 28C0 01 ADD 28C1 60 PUSH1 0x20 28C3 52 MSTORE 28C4 60 PUSH1 0x40 28C6 90 SWAP1 28C7 20 SHA3 28C8 60 PUSH1 0x03 28CA 01 ADD 28CB 80 DUP1 28CC 54 SLOAD 28CD 60 PUSH1 0xff 28CF 19 NOT 28D0 16 AND 28D1 90 SWAP1 28D2 55 SSTORE 28D3 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @28BB memory[0x00:0x20] = storage[stack[-3]] // @28C3 memory[0x20:0x40] = stack[-3] + 0x01 // @28D2 storage[0x03 + keccak256(memory[0x00:0x40])] = ~0xff & storage[0x03 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] 28D4 5B JUMPDEST 28D5 60 PUSH1 0x00 28D7 83 DUP4 28D8 3F EXTCODEHASH 28D9 7F PUSH32 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 28FA 81 DUP2 28FB 15 ISZERO 28FC 80 DUP1 28FD 15 ISZERO 28FE 90 SWAP1 28FF 61 PUSH2 0x2908 2902 57 *JUMPI 2903 50 POP 2904 80 DUP1 2905 82 DUP3 2906 14 EQ 2907 15 ISZERO 2908 5B JUMPDEST 2909 61 PUSH2 0x2917 290C 57 *JUMPI 290D 60 PUSH1 0x01 290F 92 SWAP3 2910 50 POP 2911 50 POP 2912 50 POP 2913 61 PUSH2 0x259b 2916 56 *JUMP 2917 5B JUMPDEST 2918 60 PUSH1 0x40 291A 51 MLOAD 291B 63 PUSH4 0x0a85bd01 2920 60 PUSH1 0xe1 2922 1B SHL 2923 81 DUP2 2924 52 MSTORE 2925 33 CALLER 2926 60 PUSH1 0x04 2928 82 DUP3 2929 01 ADD 292A 81 DUP2 292B 81 DUP2 292C 52 MSTORE 292D 60 PUSH1 0x01 292F 60 PUSH1 0x01 2931 60 PUSH1 0xa0 2933 1B SHL 2934 03 SUB 2935 8A DUP11 2936 81 DUP2 2937 16 AND 2938 60 PUSH1 0x24 293A 85 DUP6 293B 01 ADD 293C 52 MSTORE 293D 60 PUSH1 0x44 293F 84 DUP5 2940 01 ADD 2941 89 DUP10 2942 90 SWAP1 2943 52 MSTORE 2944 60 PUSH1 0x80 2946 60 PUSH1 0x64 2948 85 DUP6 2949 01 ADD 294A 90 SWAP1 294B 81 DUP2 294C 52 MSTORE 294D 88 DUP9 294E 51 MLOAD 294F 60 PUSH1 0x84 2951 86 DUP7 2952 01 ADD 2953 52 MSTORE 2954 88 DUP9 2955 51 MLOAD 2956 60 PUSH1 0x00 2958 95 SWAP6 2959 92 SWAP3 295A 8C DUP13 295B 16 AND 295C 94 SWAP5 295D 63 PUSH4 0x150b7a02 2962 94 SWAP5 2963 90 SWAP1 2964 93 SWAP4 2965 8E DUP15 2966 93 SWAP4 2967 8D DUP14 2968 93 SWAP4 2969 8D DUP14 296A 93 SWAP4 296B 92 SWAP3 296C 60 PUSH1 0xa4 296E 01 ADD 296F 90 SWAP1 2970 60 PUSH1 0x20 2972 85 DUP6 2973 01 ADD 2974 90 SWAP1 2975 80 DUP1 2976 83 DUP4 2977 83 DUP4 2978 8E DUP15 2979 5B JUMPDEST 297A 83 DUP4 297B 81 DUP2 297C 10 LT 297D 15 ISZERO 297E 61 PUSH2 0x2991 2981 57 *JUMPI 2982 81 DUP2 2983 81 DUP2 2984 01 ADD 2985 51 MLOAD 2986 83 DUP4 2987 82 DUP3 2988 01 ADD 2989 52 MSTORE 298A 60 PUSH1 0x20 298C 01 ADD 298D 61 PUSH2 0x2979 2990 56 *JUMP 2991 5B JUMPDEST 2992 50 POP 2993 50 POP 2994 50 POP 2995 50 POP 2996 90 SWAP1 2997 50 POP 2998 90 SWAP1 2999 81 DUP2 299A 01 ADD 299B 90 SWAP1 299C 60 PUSH1 0x1f 299E 16 AND 299F 80 DUP1 29A0 15 ISZERO 29A1 61 PUSH2 0x29be 29A4 57 *JUMPI 29A5 80 DUP1 29A6 82 DUP3 29A7 03 SUB 29A8 80 DUP1 29A9 51 MLOAD 29AA 60 PUSH1 0x01 29AC 83 DUP4 29AD 60 PUSH1 0x20 29AF 03 SUB 29B0 61 PUSH2 0x0100 29B3 0A EXP 29B4 03 SUB 29B5 19 NOT 29B6 16 AND 29B7 81 DUP2 29B8 52 MSTORE 29B9 60 PUSH1 0x20 29BB 01 ADD 29BC 91 SWAP2 29BD 50 POP 29BE 5B JUMPDEST 29BF 50 POP 29C0 95 SWAP6 29C1 50 POP 29C2 50 POP 29C3 50 POP 29C4 50 POP 29C5 50 POP 29C6 50 POP 29C7 60 PUSH1 0x20 29C9 60 PUSH1 0x40 29CB 51 MLOAD 29CC 80 DUP1 29CD 83 DUP4 29CE 03 SUB 29CF 81 DUP2 29D0 60 PUSH1 0x00 29D2 87 DUP8 29D3 80 DUP1 29D4 3B EXTCODESIZE 29D5 15 ISZERO 29D6 80 DUP1 29D7 15 ISZERO 29D8 61 PUSH2 0x29e0 29DB 57 *JUMPI 29DC 60 PUSH1 0x00 29DE 80 DUP1 29DF FD *REVERT 29E0 5B JUMPDEST 29E1 50 POP 29E2 5A GAS 29E3 F1 CALL 29E4 15 ISZERO 29E5 80 DUP1 29E6 15 ISZERO 29E7 61 PUSH2 0x29f4 29EA 57 *JUMPI 29EB 3D RETURNDATASIZE 29EC 60 PUSH1 0x00 29EE 80 DUP1 29EF 3E RETURNDATACOPY 29F0 3D RETURNDATASIZE 29F1 60 PUSH1 0x00 29F3 FD *REVERT 29F4 5B JUMPDEST 29F5 50 POP 29F6 50 POP 29F7 50 POP 29F8 50 POP 29F9 60 PUSH1 0x40 29FB 51 MLOAD 29FC 3D RETURNDATASIZE 29FD 60 PUSH1 0x20 29FF 81 DUP2 2A00 10 LT 2A01 15 ISZERO 2A02 61 PUSH2 0x2a0a 2A05 57 *JUMPI 2A06 60 PUSH1 0x00 2A08 80 DUP1 2A09 FD *REVERT 2A0A 5B JUMPDEST 2A0B 50 POP 2A0C 51 MLOAD 2A0D 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 2A2E 16 AND 2A2F 63 PUSH4 0x0a85bd01 2A34 60 PUSH1 0xe1 2A36 1B SHL 2A37 14 EQ 2A38 93 SWAP4 2A39 50 POP 2A3A 50 POP 2A3B 50 POP 2A3C 50 POP 2A3D 94 SWAP5 2A3E 93 SWAP4 2A3F 50 POP 2A40 50 POP 2A41 50 POP 2A42 50 POP 2A43 56 *JUMP label_2A44: // Incoming call from 0x2293, returns to 0x2294 // Incoming call from 0x22C2, returns to 0x22C3 // Inputs[1] { @2A4B stack[-1] } 2A44 5B JUMPDEST 2A45 60 PUSH1 0x00 2A47 60 PUSH1 0x0a 2A49 60 PUSH1 0xf8 2A4B 83 DUP4 2A4C 90 SWAP1 2A4D 1C SHR 2A4E 10 LT 2A4F 15 ISZERO 2A50 61 PUSH2 0x2a64 2A53 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A45 stack[0] = 0x00 } // Block ends with conditional jump to 0x2a64, if !(stack[-1] >> 0xf8 < 0x0a) label_2A54: // Incoming jump from 0x2A53, if not !(stack[-1] >> 0xf8 < 0x0a) // Inputs[2] // { // @2A54 stack[-2] // @2A5E stack[-1] // } 2A54 81 DUP2 2A55 60 PUSH1 0xf8 2A57 1C SHR 2A58 60 PUSH1 0x30 2A5A 01 ADD 2A5B 60 PUSH1 0xf8 2A5D 1B SHL 2A5E 90 SWAP1 2A5F 50 POP 2A60 61 PUSH2 0x0970 2A63 56 *JUMP // Stack delta = +0 // Outputs[1] { @2A5E stack[-1] = 0x30 + (stack[-2] >> 0xf8) << 0xf8 } // Block ends with unconditional jump to 0x0970 label_2A64: // Incoming jump from 0x2A53, if !(stack[-1] >> 0xf8 < 0x0a) // Inputs[2] // { // @2A65 stack[-2] // @2A6F stack[-1] // } 2A64 5B JUMPDEST 2A65 81 DUP2 2A66 60 PUSH1 0xf8 2A68 1C SHR 2A69 60 PUSH1 0x57 2A6B 01 ADD 2A6C 60 PUSH1 0xf8 2A6E 1B SHL 2A6F 90 SWAP1 2A70 50 POP 2A71 61 PUSH2 0x0970 2A74 56 *JUMP // Stack delta = +0 // Outputs[1] { @2A6F stack[-1] = 0x57 + (stack[-2] >> 0xf8) << 0xf8 } // Block ends with unconditional jump to 0x0970 label_2A75: // Incoming call from 0x28AB, returns to 0x28AC // Incoming call from 0x2766, returns to 0x2767 // Inputs[7] // { // @2A78 stack[-1] // @2A7E stack[-2] // @2A87 memory[0x00:0x40] // @2A8D storage[keccak256(memory[0x00:0x40]) + 0x02] // @2A8F storage[keccak256(memory[0x00:0x40])] // @2A95 memory[0x00:0x40] // @2A99 storage[0x01 + keccak256(memory[0x00:0x40])] // } 2A75 5B JUMPDEST 2A76 60 PUSH1 0x00 2A78 81 DUP2 2A79 81 DUP2 2A7A 52 MSTORE 2A7B 60 PUSH1 0x01 2A7D 80 DUP1 2A7E 84 DUP5 2A7F 01 ADD 2A80 60 PUSH1 0x20 2A82 52 MSTORE 2A83 60 PUSH1 0x40 2A85 80 DUP1 2A86 83 DUP4 2A87 20 SHA3 2A88 60 PUSH1 0x02 2A8A 81 DUP2 2A8B 01 ADD 2A8C 80 DUP1 2A8D 54 SLOAD 2A8E 91 SWAP2 2A8F 54 SLOAD 2A90 82 DUP3 2A91 86 DUP7 2A92 52 MSTORE 2A93 92 SWAP3 2A94 85 DUP6 2A95 20 SHA3 2A96 90 SWAP1 2A97 93 SWAP4 2A98 01 ADD 2A99 54 SLOAD 2A9A 93 SWAP4 2A9B 85 DUP6 2A9C 90 SWAP1 2A9D 52 MSTORE 2A9E 91 SWAP2 2A9F 83 DUP4 2AA0 90 SWAP1 2AA1 55 SSTORE 2AA2 90 SWAP1 2AA3 91 SWAP2 2AA4 80 DUP1 2AA5 15 ISZERO 2AA6 61 PUSH2 0x2abd 2AA9 57 *JUMPI // Stack delta = +3 // Outputs[8] // { // @2A7A memory[0x00:0x20] = stack[-1] // @2A82 memory[0x20:0x40] = stack[-2] + 0x01 // @2A92 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40]) + 0x02] // @2A9D memory[0x00:0x20] = stack[-1] // @2AA1 storage[keccak256(memory[0x00:0x40]) + 0x02] = storage[0x01 + keccak256(memory[0x00:0x40])] // @2AA2 stack[1] = storage[keccak256(memory[0x00:0x40])] // @2AA3 stack[0] = storage[keccak256(memory[0x00:0x40]) + 0x02] // @2AA3 stack[2] = storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x2abd, if !storage[0x01 + keccak256(memory[0x00:0x40])] label_2AAA: // Incoming jump from 0x2AA9, if not !storage[0x01 + keccak256(memory[0x00:0x40])] // Inputs[7] // { // @2AAC stack[-1] // @2AB1 stack[-5] // @2AB9 memory[0x00:0x40] // @2ABA stack[-4] // @2AC0 stack[-3] // @2ACD memory[0x00:0x40] // @2ACE stack[-2] // } 2AAA 60 PUSH1 0x00 2AAC 81 DUP2 2AAD 81 DUP2 2AAE 52 MSTORE 2AAF 60 PUSH1 0x01 2AB1 86 DUP7 2AB2 01 ADD 2AB3 60 PUSH1 0x20 2AB5 52 MSTORE 2AB6 60 PUSH1 0x40 2AB8 90 SWAP1 2AB9 20 SHA3 2ABA 84 DUP5 2ABB 90 SWAP1 2ABC 55 SSTORE 2ABD 5B JUMPDEST 2ABE 60 PUSH1 0x00 2AC0 83 DUP4 2AC1 81 DUP2 2AC2 52 MSTORE 2AC3 60 PUSH1 0x01 2AC5 86 DUP7 2AC6 01 ADD 2AC7 60 PUSH1 0x20 2AC9 52 MSTORE 2ACA 60 PUSH1 0x40 2ACC 90 SWAP1 2ACD 20 SHA3 2ACE 82 DUP3 2ACF 90 SWAP1 2AD0 55 SSTORE 2AD1 81 DUP2 2AD2 61 PUSH2 0x2add 2AD5 57 *JUMPI // Stack delta = +0 // Outputs[6] // { // @2AAE memory[0x00:0x20] = stack[-1] // @2AB5 memory[0x20:0x40] = stack[-5] + 0x01 // @2ABC storage[keccak256(memory[0x00:0x40])] = stack[-4] // @2AC2 memory[0x00:0x20] = stack[-3] // @2AC9 memory[0x20:0x40] = stack[-5] + 0x01 // @2AD0 storage[keccak256(memory[0x00:0x40])] = stack[-2] // } // Block ends with conditional jump to 0x2add, if stack[-2] label_2AD6: // Incoming jump from 0x2AD5, if not stack[-2] // Incoming jump from 0x2AD5, if not stack[-2] // Inputs[2] // { // @2AD6 stack[-3] // @2AD7 stack[-5] // } 2AD6 82 DUP3 2AD7 85 DUP6 2AD8 55 SSTORE 2AD9 61 PUSH2 0x2b2a 2ADC 56 *JUMP // Stack delta = +0 // Outputs[1] { @2AD8 storage[stack[-5]] = stack[-3] } // Block ends with unconditional jump to 0x2b2a label_2ADD: // Incoming jump from 0x2AD5, if stack[-2] // Incoming jump from 0x2AD5, if stack[-2] // Inputs[5] // { // @2AE0 stack[-2] // @2AE6 stack[-5] // @2AEF memory[0x00:0x40] // @2AF1 storage[keccak256(memory[0x00:0x40]) + 0x01] // @2AF2 stack[-4] // } 2ADD 5B JUMPDEST 2ADE 60 PUSH1 0x00 2AE0 82 DUP3 2AE1 81 DUP2 2AE2 52 MSTORE 2AE3 60 PUSH1 0x01 2AE5 80 DUP1 2AE6 87 DUP8 2AE7 01 ADD 2AE8 60 PUSH1 0x20 2AEA 52 MSTORE 2AEB 60 PUSH1 0x40 2AED 90 SWAP1 2AEE 91 SWAP2 2AEF 20 SHA3 2AF0 01 ADD 2AF1 54 SLOAD 2AF2 84 DUP5 2AF3 14 EQ 2AF4 15 ISZERO 2AF5 61 PUSH2 0x2b13 2AF8 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2AE2 memory[0x00:0x20] = stack[-2] // @2AEA memory[0x20:0x40] = stack[-5] + 0x01 // } // Block ends with conditional jump to 0x2b13, if !(stack[-4] == storage[keccak256(memory[0x00:0x40]) + 0x01]) label_2AF9: // Incoming jump from 0x2AF8, if not !(stack[-4] == storage[keccak256(memory[0x00:0x40]) + 0x01]) // Inputs[4] // { // @2AFB stack[-2] // @2B01 stack[-5] // @2B0A memory[0x00:0x40] // @2B0C stack[-3] // } 2AF9 60 PUSH1 0x00 2AFB 82 DUP3 2AFC 81 DUP2 2AFD 52 MSTORE 2AFE 60 PUSH1 0x01 2B00 80 DUP1 2B01 87 DUP8 2B02 01 ADD 2B03 60 PUSH1 0x20 2B05 52 MSTORE 2B06 60 PUSH1 0x40 2B08 90 SWAP1 2B09 91 SWAP2 2B0A 20 SHA3 2B0B 01 ADD 2B0C 83 DUP4 2B0D 90 SWAP1 2B0E 55 SSTORE 2B0F 61 PUSH2 0x2b2a 2B12 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2AFD memory[0x00:0x20] = stack[-2] // @2B05 memory[0x20:0x40] = stack[-5] + 0x01 // @2B0E storage[keccak256(memory[0x00:0x40]) + 0x01] = stack[-3] // } // Block ends with unconditional jump to 0x2b2a label_2B13: // Incoming jump from 0x2AF8, if !(stack[-4] == storage[keccak256(memory[0x00:0x40]) + 0x01]) // Inputs[8] // { // @2B16 stack[-2] // @2B1B stack[-5] // @2B23 memory[0x00:0x40] // @2B27 stack[-3] // @2B3E memory[0x00:0x40] // @2B42 stack[-4] // @2B4A memory[0x00:0x40] // @2B4C stack[-6] // } 2B13 5B JUMPDEST 2B14 60 PUSH1 0x00 2B16 82 DUP3 2B17 81 DUP2 2B18 52 MSTORE 2B19 60 PUSH1 0x01 2B1B 86 DUP7 2B1C 01 ADD 2B1D 60 PUSH1 0x20 2B1F 52 MSTORE 2B20 60 PUSH1 0x40 2B22 90 SWAP1 2B23 20 SHA3 2B24 60 PUSH1 0x02 2B26 01 ADD 2B27 83 DUP4 2B28 90 SWAP1 2B29 55 SSTORE 2B2A 5B JUMPDEST 2B2B 50 POP 2B2C 50 POP 2B2D 60 PUSH1 0x00 2B2F 81 DUP2 2B30 81 DUP2 2B31 52 MSTORE 2B32 60 PUSH1 0x01 2B34 93 SWAP4 2B35 84 DUP5 2B36 01 ADD 2B37 60 PUSH1 0x20 2B39 52 MSTORE 2B3A 60 PUSH1 0x40 2B3C 80 DUP1 2B3D 82 DUP3 2B3E 20 SHA3 2B3F 90 SWAP1 2B40 94 SWAP5 2B41 01 ADD 2B42 83 DUP4 2B43 90 SWAP1 2B44 55 SSTORE 2B45 91 SWAP2 2B46 82 DUP3 2B47 52 MSTORE 2B48 91 SWAP2 2B49 90 SWAP1 2B4A 20 SHA3 2B4B 55 SSTORE 2B4C 56 *JUMP // Stack delta = -6 // Outputs[8] // { // @2B18 memory[0x00:0x20] = stack[-2] // @2B1F memory[0x20:0x40] = stack[-5] + 0x01 // @2B29 storage[0x02 + keccak256(memory[0x00:0x40])] = stack[-3] // @2B31 memory[0x00:0x20] = stack[-3] // @2B39 memory[0x20:0x40] = 0x01 + stack[-5] // @2B44 storage[0x01 + keccak256(memory[0x00:0x40])] = stack[-4] // @2B47 memory[0x00:0x20] = stack[-4] // @2B4B storage[keccak256(memory[0x00:0x40])] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2B4D: // Incoming call from 0x285E, returns to 0x285F // Incoming call from 0x27B3, returns to 0x27B4 // Inputs[7] // { // @2B50 stack[-1] // @2B56 stack[-2] // @2B5F memory[0x00:0x40] // @2B64 storage[keccak256(memory[0x00:0x40]) + 0x01] // @2B66 storage[keccak256(memory[0x00:0x40])] // @2B6C memory[0x00:0x40] // @2B70 storage[0x02 + keccak256(memory[0x00:0x40])] // } 2B4D 5B JUMPDEST 2B4E 60 PUSH1 0x00 2B50 81 DUP2 2B51 81 DUP2 2B52 52 MSTORE 2B53 60 PUSH1 0x01 2B55 80 DUP1 2B56 84 DUP5 2B57 01 ADD 2B58 60 PUSH1 0x20 2B5A 52 MSTORE 2B5B 60 PUSH1 0x40 2B5D 80 DUP1 2B5E 83 DUP4 2B5F 20 SHA3 2B60 91 SWAP2 2B61 82 DUP3 2B62 01 ADD 2B63 80 DUP1 2B64 54 SLOAD 2B65 92 SWAP3 2B66 54 SLOAD 2B67 83 DUP4 2B68 85 DUP6 2B69 52 MSTORE 2B6A 91 SWAP2 2B6B 84 DUP5 2B6C 20 SHA3 2B6D 60 PUSH1 0x02 2B6F 01 ADD 2B70 54 SLOAD 2B71 93 SWAP4 2B72 85 DUP6 2B73 90 SWAP1 2B74 52 MSTORE 2B75 83 DUP4 2B76 90 SWAP1 2B77 55 SSTORE 2B78 90 SWAP1 2B79 91 SWAP2 2B7A 80 DUP1 2B7B 15 ISZERO 2B7C 61 PUSH2 0x2b93 2B7F 57 *JUMPI // Stack delta = +3 // Outputs[8] // { // @2B52 memory[0x00:0x20] = stack[-1] // @2B5A memory[0x20:0x40] = stack[-2] + 0x01 // @2B69 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40]) + 0x01] // @2B74 memory[0x00:0x20] = stack[-1] // @2B77 storage[keccak256(memory[0x00:0x40]) + 0x01] = storage[0x02 + keccak256(memory[0x00:0x40])] // @2B78 stack[1] = storage[keccak256(memory[0x00:0x40])] // @2B79 stack[0] = storage[keccak256(memory[0x00:0x40]) + 0x01] // @2B79 stack[2] = storage[0x02 + keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x2b93, if !storage[0x02 + keccak256(memory[0x00:0x40])] label_2B80: // Incoming jump from 0x2B7F, if not !storage[0x02 + keccak256(memory[0x00:0x40])] // Inputs[7] // { // @2B82 stack[-1] // @2B87 stack[-5] // @2B8F memory[0x00:0x40] // @2B90 stack[-4] // @2B96 stack[-3] // @2BA3 memory[0x00:0x40] // @2BA4 stack[-2] // } 2B80 60 PUSH1 0x00 2B82 81 DUP2 2B83 81 DUP2 2B84 52 MSTORE 2B85 60 PUSH1 0x01 2B87 86 DUP7 2B88 01 ADD 2B89 60 PUSH1 0x20 2B8B 52 MSTORE 2B8C 60 PUSH1 0x40 2B8E 90 SWAP1 2B8F 20 SHA3 2B90 84 DUP5 2B91 90 SWAP1 2B92 55 SSTORE 2B93 5B JUMPDEST 2B94 60 PUSH1 0x00 2B96 83 DUP4 2B97 81 DUP2 2B98 52 MSTORE 2B99 60 PUSH1 0x01 2B9B 86 DUP7 2B9C 01 ADD 2B9D 60 PUSH1 0x20 2B9F 52 MSTORE 2BA0 60 PUSH1 0x40 2BA2 90 SWAP1 2BA3 20 SHA3 2BA4 82 DUP3 2BA5 90 SWAP1 2BA6 55 SSTORE 2BA7 81 DUP2 2BA8 61 PUSH2 0x2bb3 2BAB 57 *JUMPI // Stack delta = +0 // Outputs[6] // { // @2B84 memory[0x00:0x20] = stack[-1] // @2B8B memory[0x20:0x40] = stack[-5] + 0x01 // @2B92 storage[keccak256(memory[0x00:0x40])] = stack[-4] // @2B98 memory[0x00:0x20] = stack[-3] // @2B9F memory[0x20:0x40] = stack[-5] + 0x01 // @2BA6 storage[keccak256(memory[0x00:0x40])] = stack[-2] // } // Block ends with conditional jump to 0x2bb3, if stack[-2] label_2BAC: // Incoming jump from 0x2BAB, if not stack[-2] // Incoming jump from 0x2BAB, if not stack[-2] // Inputs[2] // { // @2BAC stack[-3] // @2BAD stack[-5] // } 2BAC 82 DUP3 2BAD 85 DUP6 2BAE 55 SSTORE 2BAF 61 PUSH2 0x2c00 2BB2 56 *JUMP // Stack delta = +0 // Outputs[1] { @2BAE storage[stack[-5]] = stack[-3] } // Block ends with unconditional jump to 0x2c00 label_2BB3: // Incoming jump from 0x2BAB, if stack[-2] // Incoming jump from 0x2BAB, if stack[-2] // Inputs[5] // { // @2BB6 stack[-2] // @2BBB stack[-5] // @2BC3 memory[0x00:0x40] // @2BC7 storage[0x02 + keccak256(memory[0x00:0x40])] // @2BC8 stack[-4] // } 2BB3 5B JUMPDEST 2BB4 60 PUSH1 0x00 2BB6 82 DUP3 2BB7 81 DUP2 2BB8 52 MSTORE 2BB9 60 PUSH1 0x01 2BBB 86 DUP7 2BBC 01 ADD 2BBD 60 PUSH1 0x20 2BBF 52 MSTORE 2BC0 60 PUSH1 0x40 2BC2 90 SWAP1 2BC3 20 SHA3 2BC4 60 PUSH1 0x02 2BC6 01 ADD 2BC7 54 SLOAD 2BC8 84 DUP5 2BC9 14 EQ 2BCA 15 ISZERO 2BCB 61 PUSH2 0x2be9 2BCE 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2BB8 memory[0x00:0x20] = stack[-2] // @2BBF memory[0x20:0x40] = stack[-5] + 0x01 // } // Block ends with conditional jump to 0x2be9, if !(stack[-4] == storage[0x02 + keccak256(memory[0x00:0x40])]) label_2BCF: // Incoming jump from 0x2BCE, if not !(stack[-4] == storage[0x02 + keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @2BD1 stack[-2] // @2BD6 stack[-5] // @2BDE memory[0x00:0x40] // @2BE2 stack[-3] // } 2BCF 60 PUSH1 0x00 2BD1 82 DUP3 2BD2 81 DUP2 2BD3 52 MSTORE 2BD4 60 PUSH1 0x01 2BD6 86 DUP7 2BD7 01 ADD 2BD8 60 PUSH1 0x20 2BDA 52 MSTORE 2BDB 60 PUSH1 0x40 2BDD 90 SWAP1 2BDE 20 SHA3 2BDF 60 PUSH1 0x02 2BE1 01 ADD 2BE2 83 DUP4 2BE3 90 SWAP1 2BE4 55 SSTORE 2BE5 61 PUSH2 0x2c00 2BE8 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2BD3 memory[0x00:0x20] = stack[-2] // @2BDA memory[0x20:0x40] = stack[-5] + 0x01 // @2BE4 storage[0x02 + keccak256(memory[0x00:0x40])] = stack[-3] // } // Block ends with unconditional jump to 0x2c00 label_2BE9: // Incoming jump from 0x2BCE, if !(stack[-4] == storage[0x02 + keccak256(memory[0x00:0x40])]) // Inputs[8] // { // @2BEC stack[-2] // @2BF2 stack[-5] // @2BFB memory[0x00:0x40] // @2BFD stack[-3] // @2C14 memory[0x00:0x40] // @2C18 stack[-4] // @2C1F memory[0x00:0x40] // @2C21 stack[-6] // } 2BE9 5B JUMPDEST 2BEA 60 PUSH1 0x00 2BEC 82 DUP3 2BED 81 DUP2 2BEE 52 MSTORE 2BEF 60 PUSH1 0x01 2BF1 80 DUP1 2BF2 87 DUP8 2BF3 01 ADD 2BF4 60 PUSH1 0x20 2BF6 52 MSTORE 2BF7 60 PUSH1 0x40 2BF9 90 SWAP1 2BFA 91 SWAP2 2BFB 20 SHA3 2BFC 01 ADD 2BFD 83 DUP4 2BFE 90 SWAP1 2BFF 55 SSTORE 2C00 5B JUMPDEST 2C01 50 POP 2C02 50 POP 2C03 60 PUSH1 0x00 2C05 81 DUP2 2C06 81 DUP2 2C07 52 MSTORE 2C08 60 PUSH1 0x01 2C0A 90 SWAP1 2C0B 93 SWAP4 2C0C 01 ADD 2C0D 60 PUSH1 0x20 2C0F 52 MSTORE 2C10 60 PUSH1 0x40 2C12 80 DUP1 2C13 84 DUP5 2C14 20 SHA3 2C15 60 PUSH1 0x02 2C17 01 ADD 2C18 83 DUP4 2C19 90 SWAP1 2C1A 55 SSTORE 2C1B 91 SWAP2 2C1C 83 DUP4 2C1D 52 MSTORE 2C1E 91 SWAP2 2C1F 20 SHA3 2C20 55 SSTORE 2C21 56 *JUMP // Stack delta = -6 // Outputs[8] // { // @2BEE memory[0x00:0x20] = stack[-2] // @2BF6 memory[0x20:0x40] = stack[-5] + 0x01 // @2BFF storage[keccak256(memory[0x00:0x40]) + 0x01] = stack[-3] // @2C07 memory[0x00:0x20] = stack[-3] // @2C0F memory[0x20:0x40] = stack[-5] + 0x01 // @2C1A storage[0x02 + keccak256(memory[0x00:0x40])] = stack[-4] // @2C1D memory[0x00:0x20] = stack[-4] // @2C20 storage[keccak256(memory[0x00:0x40])] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2C22: // Incoming jump from 0x15C5 // Inputs[5] // { // @2C23 stack[-3] // @2C25 storage[stack[-3]] // @2C3F memory[0x00:0x20] // @2C4A stack[-2] // @2C4B stack[-1] // } 2C22 5B JUMPDEST 2C23 82 DUP3 2C24 80 DUP1 2C25 54 SLOAD 2C26 60 PUSH1 0x01 2C28 81 DUP2 2C29 60 PUSH1 0x01 2C2B 16 AND 2C2C 15 ISZERO 2C2D 61 PUSH2 0x0100 2C30 02 MUL 2C31 03 SUB 2C32 16 AND 2C33 60 PUSH1 0x02 2C35 90 SWAP1 2C36 04 DIV 2C37 90 SWAP1 2C38 60 PUSH1 0x00 2C3A 52 MSTORE 2C3B 60 PUSH1 0x20 2C3D 60 PUSH1 0x00 2C3F 20 SHA3 2C40 90 SWAP1 2C41 60 PUSH1 0x1f 2C43 01 ADD 2C44 60 PUSH1 0x20 2C46 90 SWAP1 2C47 04 DIV 2C48 81 DUP2 2C49 01 ADD 2C4A 92 SWAP3 2C4B 82 DUP3 2C4C 60 PUSH1 0x1f 2C4E 10 LT 2C4F 61 PUSH2 0x2c63 2C52 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @2C3A memory[0x00:0x20] = stack[-3] // @2C40 stack[0] = keccak256(memory[0x00:0x20]) // @2C4A stack[1] = stack[-2] // @2C4A stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x2c63, if 0x1f < stack[-1] label_2C53: // Incoming jump from 0x2C52, if not 0x1f < stack[-1] // Inputs[4] // { // @2C53 stack[-3] // @2C59 stack[-1] // @2C5A msg.data[stack[-1]:stack[-1] + 0x20] // @2C5D stack[-5] // } 2C53 82 DUP3 2C54 80 DUP1 2C55 01 ADD 2C56 60 PUSH1 0xff 2C58 19 NOT 2C59 82 DUP3 2C5A 35 CALLDATALOAD 2C5B 16 AND 2C5C 17 OR 2C5D 85 DUP6 2C5E 55 SSTORE 2C5F 61 PUSH2 0x2c90 2C62 56 *JUMP // Stack delta = +0 // Outputs[1] { @2C5E storage[stack[-5]] = (msg.data[stack[-1]:stack[-1] + 0x20] & ~0xff) | stack[-3] + stack[-3] } // Block ends with unconditional jump to 0x2c90 label_2C63: // Incoming jump from 0x2C52, if 0x1f < stack[-1] // Inputs[2] // { // @2C64 stack[-3] // @2C6A stack[-5] // } 2C63 5B JUMPDEST 2C64 82 DUP3 2C65 80 DUP1 2C66 01 ADD 2C67 60 PUSH1 0x01 2C69 01 ADD 2C6A 85 DUP6 2C6B 55 SSTORE 2C6C 82 DUP3 2C6D 15 ISZERO 2C6E 61 PUSH2 0x2c90 2C71 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2C6B storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x2c90, if !stack[-3] label_2C72: // Incoming jump from 0x2C71, if not !stack[-3] // Inputs[2] // { // @2C72 stack[-3] // @2C72 stack[-1] // } 2C72 91 SWAP2 2C73 82 DUP3 2C74 01 ADD 2C75 5B JUMPDEST 2C76 82 DUP3 2C77 81 DUP2 2C78 11 GT 2C79 15 ISZERO 2C7A 61 PUSH2 0x2c90 2C7D 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2C72 stack[-3] = stack[-1] // @2C74 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x2c90, if !(stack[-1] + stack[-3] > stack[-1]) label_2C7E: // Incoming jump from 0x2C7D, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x2C7D, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @2C7E stack[-3] // @2C7F msg.data[stack[-3]:stack[-3] + 0x20] // @2C80 stack[-2] // @2C82 stack[-1] // } 2C7E 82 DUP3 2C7F 35 CALLDATALOAD 2C80 82 DUP3 2C81 55 SSTORE 2C82 91 SWAP2 2C83 60 PUSH1 0x20 2C85 01 ADD 2C86 91 SWAP2 2C87 90 SWAP1 2C88 60 PUSH1 0x01 2C8A 01 ADD 2C8B 90 SWAP1 2C8C 61 PUSH2 0x2c75 2C8F 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2C81 storage[stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20] // @2C86 stack[-3] = 0x20 + stack[-3] // @2C8B stack[-2] = 0x01 + stack[-2] // @2C8B stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x2c75 label_2C90: // Incoming jump from 0x2C7D, if !(stack[-1] > stack[-3]) // Incoming jump from 0x2C7D, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x2C71, if !stack[-3] // Incoming jump from 0x2C62 // Inputs[2] // { // @2C95 stack[-4] // @2C96 stack[-3] // } 2C90 5B JUMPDEST 2C91 50 POP 2C92 61 PUSH2 0x2c9c 2C95 92 SWAP3 2C96 91 SWAP2 2C97 50 POP 2C98 61 PUSH2 0x2cc0 2C9B 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2C95 stack[-4] = 0x2c9c // @2C96 stack[-3] = stack[-4] // } // Block ends with call to 0x2cc0, returns to 0x2C9C label_2C9C: // Incoming call from 0x2CCE, returns to 0x1A56, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x2CC0 at 0x2C9B // Incoming jump from 0x2CCE, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @2C9E stack[-2] // @2C9E stack[-3] // } 2C9C 5B JUMPDEST 2C9D 50 POP 2C9E 90 SWAP1 2C9F 56 *JUMP // Stack delta = -2 // Outputs[1] { @2C9E stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_2CA0: // Incoming call from 0x1E0E, returns to 0x1E0F // Incoming call from 0x1E0E, returns to 0x1E0F // Inputs[2] // { // @2CA4 memory[0x40:0x60] // @2CBE stack[-1] // } 2CA0 5B JUMPDEST 2CA1 60 PUSH1 0x40 2CA3 80 DUP1 2CA4 51 MLOAD 2CA5 60 PUSH1 0x60 2CA7 81 DUP2 2CA8 01 ADD 2CA9 82 DUP3 2CAA 52 MSTORE 2CAB 60 PUSH1 0x00 2CAD 80 DUP1 2CAE 82 DUP3 2CAF 52 MSTORE 2CB0 60 PUSH1 0x20 2CB2 82 DUP3 2CB3 01 ADD 2CB4 81 DUP2 2CB5 90 SWAP1 2CB6 52 MSTORE 2CB7 91 SWAP2 2CB8 81 DUP2 2CB9 01 ADD 2CBA 91 SWAP2 2CBB 90 SWAP1 2CBC 91 SWAP2 2CBD 52 MSTORE 2CBE 90 SWAP1 2CBF 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @2CAA memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @2CAF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @2CB6 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @2CBD memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @2CBE stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_2CC0: // Incoming call from 0x2C9B, returns to 0x2C9C // Inputs[2] // { // @2CC4 stack[-2] // @2CC5 stack[-1] // } 2CC0 5B JUMPDEST 2CC1 61 PUSH2 0x1a56 2CC4 91 SWAP2 2CC5 90 SWAP1 2CC6 5B JUMPDEST 2CC7 80 DUP1 2CC8 82 DUP3 2CC9 11 GT 2CCA 15 ISZERO 2CCB 61 PUSH2 0x2c9c 2CCE 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2CC4 stack[-2] = 0x1a56 // @2CC5 stack[-1] = stack[-2] // @2CC5 stack[0] = stack[-1] // } // Block ends with conditional call to 0x2c9c, returns to 0x1A56, if !(stack[-2] > stack[-1]) label_2CCF: // Incoming jump from 0x2CCE, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x2CCE, if not !(stack[-2] > stack[-1]) // Inputs[1] { @2CD1 stack[-1] } 2CCF 60 PUSH1 0x00 2CD1 81 DUP2 2CD2 55 SSTORE 2CD3 60 PUSH1 0x01 2CD5 01 ADD 2CD6 61 PUSH2 0x2cc6 2CD9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2CD2 storage[stack[-1]] = 0x00 // @2CD5 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2cc6 2CDA FE *ASSERT 2CDB 45 GASLIMIT 2CDC 52 MSTORE 2CDD 43 NUMBER 2CDE 37 CALLDATACOPY 2CDF 32 ORIGIN 2CE0 31 BALANCE 2CE1 3A GASPRICE 2CE2 20 SHA3 2CE3 74 PUSH21 0x72616e7366657220746f206e6f6e20455243373231 2CF9 52 MSTORE 2CFA 65 PUSH6 0x636569766572 2D01 20 SHA3 2D02 69 PUSH10 0x6d706c656d656e746572 2D0D 53 MSTORE8 2D0E 65 PUSH6 0x6e646572206e 2D15 6F PUSH16 0x742063726561746f72206f72206e6f74 2D26 20 SHA3 2D27 61 PUSH2 0x7070 2D2A 72 PUSH19 0x6f7665644552433732313a206f70657261746f 2D3E 72 PUSH19 0x20717565727920666f72206e6f6e6578697374 2D52 65 PUSH6 0x6e7420746f6b 2D59 65 PUSH6 0x6e4552433732 2D60 31 BALANCE 2D61 3A GASPRICE 2D62 20 SHA3 2D63 61 PUSH2 0x7070 2D66 72 PUSH19 0x6f76652063616c6c6572206973206e6f74206f 2D7A 77 PUSH24 0x6e6572206e6f7220617070726f76656420666f7220616c6c 2D93 59 MSIZE 2D94 6F PUSH16 0x7520646f206e6f74206b6e6f77207768 2DA5 61 PUSH2 0x7420 2DA8 79 PUSH26 0x6f752061726520646f696e672e4552433732313a20617070726f 2DC3 76 PUSH23 0x616c20746f2063757272656e74206f776e657245524337 2DDB 32 ORIGIN 2DDC 31 BALANCE 2DDD 3A GASPRICE 2DDE 20 SHA3 2DDF 74 PUSH21 0x72616e736665722063616c6c6572206973206e6f74 2DF5 20 SHA3 2DF6 6F PUSH16 0x776e6572206e6f7220617070726f7665 2E07 64 PUSH5 0x6874747073 2E0D 3A GASPRICE 2E0E 2F 2F 2E0F 2F 2F 2E10 61 PUSH2 0x7069 2E13 32 ORIGIN 2E14 2E 2E 2E15 63 PUSH4 0x6172676f 2E1A 2E 2E 2E1B 62 PUSH3 0x75696c 2E1F 64 PUSH5 0x2f76332f63 2E25 6F PUSH16 0x6e74726163742d6d657461646174612f 2E36 30 ADDRESS 2E37 78 PUSH25 0xa265627a7a723058205db0b3f01f0214c682d27acfb8ac2367 2E51 B6 B6 2E52 E5 E5 2E53 76 PUSH23 0x8497763eb0d4ae9a643c10bf1964736f6c634300050a00 2E6B 32 ORIGIN