Online Solidity Decompiler

label_0000: // Incoming return from call to 0x188D at 0x0BC3 // Incoming return from call to 0x188D at 0x0BC3 // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x0206 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0206, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x70a08231 0026 11 GT 0027 61 PUSH2 0x011a 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x011a, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xa22cb465 0031 11 GT 0032 61 PUSH2 0x00ad 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ad, if 0xa22cb465 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xa22cb465 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xd134dd4a 003C 11 GT 003D 61 PUSH2 0x007c 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007c, if 0xd134dd4a > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xd134dd4a > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xd134dd4a 0047 14 EQ 0048 61 PUSH2 0x0437 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0437, if 0xd134dd4a == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xd134dd4a == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xe8a3d485 0052 14 EQ 0053 61 PUSH2 0x045b 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x045b, if 0xe8a3d485 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xe8a3d485 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xe985e9c5 005D 14 EQ 005E 61 PUSH2 0x0463 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0463, if 0xe985e9c5 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xefd563cd 0068 14 EQ 0069 61 PUSH2 0x049f 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x049f, if 0xefd563cd == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xefd563cd == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0xf2fde38b 0073 14 EQ 0074 61 PUSH2 0x04b2 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b2, if 0xf2fde38b == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0xf2fde38b == stack[-1] // Inputs[1] { @007B memory[0x00:0x00] } 0078 60 PUSH1 0x00 007A 80 DUP1 007B FD *REVERT // Stack delta = +0 // Outputs[1] { @007B revert(memory[0x00:0x00]); } // Block terminates label_007C: // Incoming jump from 0x0040, if 0xd134dd4a > stack[-1] // Inputs[1] { @007D stack[-1] } 007C 5B JUMPDEST 007D 80 DUP1 007E 63 PUSH4 0xa22cb465 0083 14 EQ 0084 61 PUSH2 0x03eb 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03eb, if 0xa22cb465 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xb88d4fde 008E 14 EQ 008F 61 PUSH2 0x03fe 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03fe, if 0xb88d4fde == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xb88d4fde == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xc47f0027 0099 14 EQ 009A 61 PUSH2 0x0411 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0411, if 0xc47f0027 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xc47f0027 == stack[-1] // Inputs[1] { @009E stack[-1] } 009E 80 DUP1 009F 63 PUSH4 0xc87b56dd 00A4 14 EQ 00A5 61 PUSH2 0x0424 00A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0424, if 0xc87b56dd == stack[-1] label_00A9: // Incoming jump from 0x00A8, if not 0xc87b56dd == stack[-1] // Inputs[1] { @00AC memory[0x00:0x00] } 00A9 60 PUSH1 0x00 00AB 80 DUP1 00AC FD *REVERT // Stack delta = +0 // Outputs[1] { @00AC revert(memory[0x00:0x00]); } // Block terminates label_00AD: // Incoming jump from 0x0035, if 0xa22cb465 > stack[-1] // Inputs[1] { @00AE stack[-1] } 00AD 5B JUMPDEST 00AE 80 DUP1 00AF 63 PUSH4 0x8da5cb5b 00B4 11 GT 00B5 61 PUSH2 0x00e9 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00e9, if 0x8da5cb5b > stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x8da5cb5b > stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x8da5cb5b 00BF 14 EQ 00C0 61 PUSH2 0x03ac 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ac, if 0x8da5cb5b == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x94f5a0cb 00CA 14 EQ 00CB 61 PUSH2 0x03bd 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03bd, if 0x94f5a0cb == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x94f5a0cb == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0x95d89b41 00D5 14 EQ 00D6 61 PUSH2 0x03d0 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d0, if 0x95d89b41 == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0x9fe2c592 00E0 14 EQ 00E1 61 PUSH2 0x03d8 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d8, if 0x9fe2c592 == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0x9fe2c592 == stack[-1] // Inputs[1] { @00E8 memory[0x00:0x00] } 00E5 60 PUSH1 0x00 00E7 80 DUP1 00E8 FD *REVERT // Stack delta = +0 // Outputs[1] { @00E8 revert(memory[0x00:0x00]); } // Block terminates label_00E9: // Incoming jump from 0x00B8, if 0x8da5cb5b > stack[-1] // Inputs[1] { @00EA stack[-1] } 00E9 5B JUMPDEST 00EA 80 DUP1 00EB 63 PUSH4 0x70a08231 00F0 14 EQ 00F1 61 PUSH2 0x036a 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036a, if 0x70a08231 == stack[-1] label_00F5: // Incoming jump from 0x00F4, if not 0x70a08231 == stack[-1] // Inputs[1] { @00F5 stack[-1] } 00F5 80 DUP1 00F6 63 PUSH4 0x715018a6 00FB 14 EQ 00FC 61 PUSH2 0x037d 00FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037d, if 0x715018a6 == stack[-1] label_0100: // Incoming jump from 0x00FF, if not 0x715018a6 == stack[-1] // Inputs[1] { @0100 stack[-1] } 0100 80 DUP1 0101 63 PUSH4 0x729ad39e 0106 14 EQ 0107 61 PUSH2 0x0385 010A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0385, if 0x729ad39e == stack[-1] label_010B: // Incoming jump from 0x010A, if not 0x729ad39e == stack[-1] // Inputs[1] { @010B stack[-1] } 010B 80 DUP1 010C 63 PUSH4 0x7f7dcdbf 0111 14 EQ 0112 61 PUSH2 0x0398 0115 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0398, if 0x7f7dcdbf == stack[-1] label_0116: // Incoming jump from 0x0115, if not 0x7f7dcdbf == stack[-1] // Inputs[1] { @0119 memory[0x00:0x00] } 0116 60 PUSH1 0x00 0118 80 DUP1 0119 FD *REVERT // Stack delta = +0 // Outputs[1] { @0119 revert(memory[0x00:0x00]); } // Block terminates label_011A: // Incoming jump from 0x002A, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @011B stack[-1] } 011A 5B JUMPDEST 011B 80 DUP1 011C 63 PUSH4 0x23b872dd 0121 11 GT 0122 61 PUSH2 0x019d 0125 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x019d, if 0x23b872dd > stack[-1] label_0126: // Incoming jump from 0x0125, if not 0x23b872dd > stack[-1] // Inputs[1] { @0126 stack[-1] } 0126 80 DUP1 0127 63 PUSH4 0x42966c68 012C 11 GT 012D 61 PUSH2 0x016c 0130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x016c, if 0x42966c68 > stack[-1] label_0131: // Incoming jump from 0x0130, if not 0x42966c68 > stack[-1] // Inputs[1] { @0131 stack[-1] } 0131 80 DUP1 0132 63 PUSH4 0x42966c68 0137 14 EQ 0138 61 PUSH2 0x0315 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0315, if 0x42966c68 == stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x42966c68 == stack[-1] // Inputs[1] { @013C stack[-1] } 013C 80 DUP1 013D 63 PUSH4 0x42d8c7d5 0142 14 EQ 0143 61 PUSH2 0x0328 0146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0328, if 0x42d8c7d5 == stack[-1] label_0147: // Incoming jump from 0x0146, if not 0x42d8c7d5 == stack[-1] // Inputs[1] { @0147 stack[-1] } 0147 80 DUP1 0148 63 PUSH4 0x5640f549 014D 14 EQ 014E 61 PUSH2 0x033b 0151 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033b, if 0x5640f549 == stack[-1] label_0152: // Incoming jump from 0x0151, if not 0x5640f549 == stack[-1] // Inputs[1] { @0152 stack[-1] } 0152 80 DUP1 0153 63 PUSH4 0x56938980 0158 14 EQ 0159 61 PUSH2 0x034e 015C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x034e, if 0x56938980 == stack[-1] label_015D: // Incoming jump from 0x015C, if not 0x56938980 == stack[-1] // Inputs[1] { @015D stack[-1] } 015D 80 DUP1 015E 63 PUSH4 0x6352211e 0163 14 EQ 0164 61 PUSH2 0x0357 0167 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0357, if 0x6352211e == stack[-1] label_0168: // Incoming jump from 0x0167, if not 0x6352211e == stack[-1] // Inputs[1] { @016B memory[0x00:0x00] } 0168 60 PUSH1 0x00 016A 80 DUP1 016B FD *REVERT // Stack delta = +0 // Outputs[1] { @016B revert(memory[0x00:0x00]); } // Block terminates label_016C: // Incoming jump from 0x0130, if 0x42966c68 > stack[-1] // Inputs[1] { @016D stack[-1] } 016C 5B JUMPDEST 016D 80 DUP1 016E 63 PUSH4 0x23b872dd 0173 14 EQ 0174 61 PUSH2 0x02d3 0177 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d3, if 0x23b872dd == stack[-1] label_0178: // Incoming jump from 0x0177, if not 0x23b872dd == stack[-1] // Inputs[1] { @0178 stack[-1] } 0178 80 DUP1 0179 63 PUSH4 0x2c00e7b9 017E 14 EQ 017F 61 PUSH2 0x02e6 0182 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e6, if 0x2c00e7b9 == stack[-1] label_0183: // Incoming jump from 0x0182, if not 0x2c00e7b9 == stack[-1] // Inputs[1] { @0183 stack[-1] } 0183 80 DUP1 0184 63 PUSH4 0x32cb6b0c 0189 14 EQ 018A 61 PUSH2 0x02f9 018D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f9, if 0x32cb6b0c == stack[-1] label_018E: // Incoming jump from 0x018D, if not 0x32cb6b0c == stack[-1] // Inputs[1] { @018E stack[-1] } 018E 80 DUP1 018F 63 PUSH4 0x42842e0e 0194 14 EQ 0195 61 PUSH2 0x0302 0198 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0302, if 0x42842e0e == stack[-1] label_0199: // Incoming jump from 0x0198, if not 0x42842e0e == stack[-1] // Inputs[1] { @019C memory[0x00:0x00] } 0199 60 PUSH1 0x00 019B 80 DUP1 019C FD *REVERT // Stack delta = +0 // Outputs[1] { @019C revert(memory[0x00:0x00]); } // Block terminates label_019D: // Incoming jump from 0x0125, if 0x23b872dd > stack[-1] // Inputs[1] { @019E stack[-1] } 019D 5B JUMPDEST 019E 80 DUP1 019F 63 PUSH4 0x095ea7b3 01A4 11 GT 01A5 61 PUSH2 0x01d9 01A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d9, if 0x095ea7b3 > stack[-1] label_01A9: // Incoming jump from 0x01A8, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @01A9 stack[-1] } 01A9 80 DUP1 01AA 63 PUSH4 0x095ea7b3 01AF 14 EQ 01B0 61 PUSH2 0x0288 01B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0288, if 0x095ea7b3 == stack[-1] label_01B4: // Incoming jump from 0x01B3, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @01B4 stack[-1] } 01B4 80 DUP1 01B5 63 PUSH4 0x109b79a9 01BA 14 EQ 01BB 61 PUSH2 0x029b 01BE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x029b, if 0x109b79a9 == stack[-1] label_01BF: // Incoming jump from 0x01BE, if not 0x109b79a9 == stack[-1] // Inputs[1] { @01BF stack[-1] } 01BF 80 DUP1 01C0 63 PUSH4 0x17495dde 01C5 14 EQ 01C6 61 PUSH2 0x02ae 01C9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ae, if 0x17495dde == stack[-1] label_01CA: // Incoming jump from 0x01C9, if not 0x17495dde == stack[-1] // Inputs[1] { @01CA stack[-1] } 01CA 80 DUP1 01CB 63 PUSH4 0x18160ddd 01D0 14 EQ 01D1 61 PUSH2 0x02c1 01D4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c1, if 0x18160ddd == stack[-1] label_01D5: // Incoming jump from 0x01D4, if not 0x18160ddd == stack[-1] // Inputs[1] { @01D8 memory[0x00:0x00] } 01D5 60 PUSH1 0x00 01D7 80 DUP1 01D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D8 revert(memory[0x00:0x00]); } // Block terminates label_01D9: // Incoming jump from 0x01A8, if 0x095ea7b3 > stack[-1] // Inputs[1] { @01DA stack[-1] } 01D9 5B JUMPDEST 01DA 80 DUP1 01DB 63 PUSH4 0x01ffc9a7 01E0 14 EQ 01E1 61 PUSH2 0x020b 01E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x020b, if 0x01ffc9a7 == stack[-1] label_01E5: // Incoming jump from 0x01E4, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01E5 stack[-1] } 01E5 80 DUP1 01E6 63 PUSH4 0x02fe5305 01EB 14 EQ 01EC 61 PUSH2 0x0233 01EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0233, if 0x02fe5305 == stack[-1] label_01F0: // Incoming jump from 0x01EF, if not 0x02fe5305 == stack[-1] // Inputs[1] { @01F0 stack[-1] } 01F0 80 DUP1 01F1 63 PUSH4 0x06fdde03 01F6 14 EQ 01F7 61 PUSH2 0x0248 01FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0248, if 0x06fdde03 == stack[-1] label_01FB: // Incoming jump from 0x01FA, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01FB stack[-1] } 01FB 80 DUP1 01FC 63 PUSH4 0x081812fc 0201 14 EQ 0202 61 PUSH2 0x025d 0205 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x025d, if 0x081812fc == stack[-1] label_0206: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x0205, if not 0x081812fc == stack[-1] // Inputs[1] { @020A memory[0x00:0x00] } 0206 5B JUMPDEST 0207 60 PUSH1 0x00 0209 80 DUP1 020A FD *REVERT // Stack delta = +0 // Outputs[1] { @020A revert(memory[0x00:0x00]); } // Block terminates label_020B: // Incoming jump from 0x01E4, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0212 msg.data.length } 020B 5B JUMPDEST 020C 61 PUSH2 0x021e 020F 61 PUSH2 0x0219 0212 36 CALLDATASIZE 0213 60 PUSH1 0x04 0215 61 PUSH2 0x1e84 0218 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @020C stack[0] = 0x021e // @020F stack[1] = 0x0219 // @0212 stack[2] = msg.data.length // @0213 stack[3] = 0x04 // } // Block ends with call to 0x1e84, returns to 0x0219 label_0219: // Incoming return from call to 0x1E84 at 0x0218 0219 5B JUMPDEST 021A 61 PUSH2 0x04c5 021D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04c5 label_021E: // Incoming return from call to 0x0219 at 0x0218 // Incoming return from call to 0x0349 at 0x0348 // Incoming jump from 0x03AB // Incoming return from call to 0x0471 at 0x0470 // Inputs[4] // { // @0221 memory[0x40:0x60] // @0222 stack[-1] // @022D memory[0x40:0x60] // @0232 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 021E 5B JUMPDEST 021F 60 PUSH1 0x40 0221 51 MLOAD 0222 90 SWAP1 0223 15 ISZERO 0224 15 ISZERO 0225 81 DUP2 0226 52 MSTORE 0227 60 PUSH1 0x20 0229 01 ADD 022A 5B JUMPDEST 022B 60 PUSH1 0x40 022D 51 MLOAD 022E 80 DUP1 022F 91 SWAP2 0230 03 SUB 0231 90 SWAP1 0232 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0226 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0232 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0233: // Incoming jump from 0x01EF, if 0x02fe5305 == stack[-1] // Inputs[1] { @023A msg.data.length } 0233 5B JUMPDEST 0234 61 PUSH2 0x0246 0237 61 PUSH2 0x0241 023A 36 CALLDATASIZE 023B 60 PUSH1 0x04 023D 61 PUSH2 0x1ea1 0240 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0234 stack[0] = 0x0246 // @0237 stack[1] = 0x0241 // @023A stack[2] = msg.data.length // @023B stack[3] = 0x04 // } // Block ends with call to 0x1ea1, returns to 0x0241 label_0241: // Incoming return from call to 0x1EA1 at 0x0240 0241 5B JUMPDEST 0242 61 PUSH2 0x0517 0245 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0517 label_0246: // Incoming return from call to 0x0393 at 0x0392 // Incoming return from call to 0x0393 at 0x0392 // Incoming return from call to 0x03E6 at 0x03E5 // Incoming return from call to 0x0CEF at 0x0384 // Incoming return from call to 0x02F4 at 0x02F3 // Incoming return from call to 0x03CB at 0x03CA // Incoming return from call to 0x04AD at 0x04AC // Incoming return from call to 0x0336 at 0x0335 // Incoming return from call to 0x02A9 at 0x02A8 // Incoming return from call to 0x02BC at 0x02BB 0246 5B JUMPDEST 0247 00 *STOP // Stack delta = +0 // Outputs[1] { @0247 stop(); } // Block terminates label_0248: // Incoming jump from 0x01FA, if 0x06fdde03 == stack[-1] 0248 5B JUMPDEST 0249 61 PUSH2 0x0250 024C 61 PUSH2 0x05c1 024F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0249 stack[0] = 0x0250 } // Block ends with call to 0x05c1, returns to 0x0250 label_0250: // Incoming jump from 0x045A // Incoming return from call to 0x0F30 at 0x03D7 // Incoming return from call to 0x05C1 at 0x024F // Incoming return from call to 0x0432 at 0x0431 // Incoming return from call to 0x12A0 at 0x0462 // Inputs[2] // { // @0253 memory[0x40:0x60] // @0257 stack[-1] // } 0250 5B JUMPDEST 0251 60 PUSH1 0x40 0253 51 MLOAD 0254 61 PUSH2 0x022a 0257 91 SWAP2 0258 90 SWAP1 0259 61 PUSH2 0x1f6b 025C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0257 stack[-1] = 0x022a // @0258 stack[1] = memory[0x40:0x60] // @0258 stack[0] = stack[-1] // } // Block ends with call to 0x1f6b, returns to 0x022A label_025D: // Incoming jump from 0x0205, if 0x081812fc == stack[-1] // Inputs[1] { @0264 msg.data.length } 025D 5B JUMPDEST 025E 61 PUSH2 0x0270 0261 61 PUSH2 0x026b 0264 36 CALLDATASIZE 0265 60 PUSH1 0x04 0267 61 PUSH2 0x1f7e 026A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @025E stack[0] = 0x0270 // @0261 stack[1] = 0x026b // @0264 stack[2] = msg.data.length // @0265 stack[3] = 0x04 // } // Block ends with call to 0x1f7e, returns to 0x026B label_026B: // Incoming return from call to 0x1F7E at 0x026A 026B 5B JUMPDEST 026C 61 PUSH2 0x0653 026F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0653 label_0270: // Incoming return from call to 0x026B at 0x026A // Incoming jump from 0x03BC // Inputs[2] // { // @0273 memory[0x40:0x60] // @027D stack[-1] // } 0270 5B JUMPDEST 0271 60 PUSH1 0x40 0273 51 MLOAD 0274 60 PUSH1 0x01 0276 60 PUSH1 0x01 0278 60 PUSH1 0xa0 027A 1B SHL 027B 03 SUB 027C 90 SWAP1 027D 91 SWAP2 027E 16 AND 027F 81 DUP2 0280 52 MSTORE 0281 60 PUSH1 0x20 0283 01 ADD 0284 61 PUSH2 0x022a 0287 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0280 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0283 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x022a label_0288: // Incoming jump from 0x01B3, if 0x095ea7b3 == stack[-1] // Inputs[1] { @028F msg.data.length } 0288 5B JUMPDEST 0289 61 PUSH2 0x0246 028C 61 PUSH2 0x0296 028F 36 CALLDATASIZE 0290 60 PUSH1 0x04 0292 61 PUSH2 0x1fac 0295 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0289 stack[0] = 0x0246 // @028C stack[1] = 0x0296 // @028F stack[2] = msg.data.length // @0290 stack[3] = 0x04 // } // Block ends with call to 0x1fac, returns to 0x0296 label_0296: // Incoming return from call to 0x1FAC at 0x0295 0296 5B JUMPDEST 0297 61 PUSH2 0x06db 029A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06db label_029B: // Incoming jump from 0x01BE, if 0x109b79a9 == stack[-1] // Inputs[1] { @02A2 msg.data.length } 029B 5B JUMPDEST 029C 61 PUSH2 0x0246 029F 61 PUSH2 0x02a9 02A2 36 CALLDATASIZE 02A3 60 PUSH1 0x04 02A5 61 PUSH2 0x1fd8 02A8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @029C stack[0] = 0x0246 // @029F stack[1] = 0x02a9 // @02A2 stack[2] = msg.data.length // @02A3 stack[3] = 0x04 // } // Block ends with call to 0x1fd8, returns to 0x02A9 label_02A9: // Incoming return from call to 0x1FD8 at 0x02A8 02A9 5B JUMPDEST 02AA 61 PUSH2 0x07ec 02AD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07ec label_02AE: // Incoming jump from 0x01C9, if 0x17495dde == stack[-1] // Inputs[1] { @02B5 msg.data.length } 02AE 5B JUMPDEST 02AF 61 PUSH2 0x0246 02B2 61 PUSH2 0x02bc 02B5 36 CALLDATASIZE 02B6 60 PUSH1 0x04 02B8 61 PUSH2 0x2005 02BB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02AF stack[0] = 0x0246 // @02B2 stack[1] = 0x02bc // @02B5 stack[2] = msg.data.length // @02B6 stack[3] = 0x04 // } // Block ends with call to 0x2005, returns to 0x02BC label_02BC: // Incoming return from call to 0x2005 at 0x02BB 02BC 5B JUMPDEST 02BD 61 PUSH2 0x086a 02C0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x086a label_02C1: // Incoming jump from 0x01D4, if 0x18160ddd == stack[-1] // Inputs[1] { @02C4 storage[0x08] } 02C1 5B JUMPDEST 02C2 60 PUSH1 0x08 02C4 54 SLOAD // Stack delta = +1 // Outputs[1] { @02C4 stack[0] = storage[0x08] } // Block continues label_02C5: // Incoming jump from 0x0301 // Incoming return from call to 0x0378 at 0x0377 // Incoming jump from 0x02C4 // Incoming jump from 0x0356 // Inputs[2] // { // @02C8 memory[0x40:0x60] // @02C9 stack[-1] // } 02C5 5B JUMPDEST 02C6 60 PUSH1 0x40 02C8 51 MLOAD 02C9 90 SWAP1 02CA 81 DUP2 02CB 52 MSTORE 02CC 60 PUSH1 0x20 02CE 01 ADD 02CF 61 PUSH2 0x022a 02D2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02CB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02CE stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x022a label_02D3: // Incoming jump from 0x0177, if 0x23b872dd == stack[-1] // Inputs[1] { @02DA msg.data.length } 02D3 5B JUMPDEST 02D4 61 PUSH2 0x0246 02D7 61 PUSH2 0x02e1 02DA 36 CALLDATASIZE 02DB 60 PUSH1 0x04 02DD 61 PUSH2 0x2020 02E0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02D4 stack[0] = 0x0246 // @02D7 stack[1] = 0x02e1 // @02DA stack[2] = msg.data.length // @02DB stack[3] = 0x04 // } // Block ends with call to 0x2020, returns to 0x02E1 label_02E1: // Incoming return from call to 0x2020 at 0x02E0 02E1 5B JUMPDEST 02E2 61 PUSH2 0x0914 02E5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0914 label_02E6: // Incoming jump from 0x0182, if 0x2c00e7b9 == stack[-1] // Inputs[1] { @02ED msg.data.length } 02E6 5B JUMPDEST 02E7 61 PUSH2 0x0246 02EA 61 PUSH2 0x02f4 02ED 36 CALLDATASIZE 02EE 60 PUSH1 0x04 02F0 61 PUSH2 0x2005 02F3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02E7 stack[0] = 0x0246 // @02EA stack[1] = 0x02f4 // @02ED stack[2] = msg.data.length // @02EE stack[3] = 0x04 // } // Block ends with call to 0x2005, returns to 0x02F4 label_02F4: // Incoming return from call to 0x2005 at 0x02F3 02F4 5B JUMPDEST 02F5 61 PUSH2 0x0945 02F8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0945 label_02F9: // Incoming jump from 0x018D, if 0x32cb6b0c == stack[-1] 02F9 5B JUMPDEST 02FA 61 PUSH2 0x02c5 02FD 61 PUSH2 0x3aad 0300 81 DUP2 0301 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02FA stack[0] = 0x02c5 // @02FD stack[1] = 0x3aad // } // Block ends with unconditional jump to 0x02c5 label_0302: // Incoming jump from 0x0198, if 0x42842e0e == stack[-1] // Inputs[1] { @0309 msg.data.length } 0302 5B JUMPDEST 0303 61 PUSH2 0x0246 0306 61 PUSH2 0x0310 0309 36 CALLDATASIZE 030A 60 PUSH1 0x04 030C 61 PUSH2 0x2020 030F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0303 stack[0] = 0x0246 // @0306 stack[1] = 0x0310 // @0309 stack[2] = msg.data.length // @030A stack[3] = 0x04 // } // Block ends with call to 0x2020, returns to 0x0310 label_0310: // Incoming return from call to 0x2020 at 0x030F 0310 5B JUMPDEST 0311 61 PUSH2 0x09f1 0314 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09f1 label_0315: // Incoming jump from 0x013B, if 0x42966c68 == stack[-1] // Inputs[1] { @031C msg.data.length } 0315 5B JUMPDEST 0316 61 PUSH2 0x0246 0319 61 PUSH2 0x0323 031C 36 CALLDATASIZE 031D 60 PUSH1 0x04 031F 61 PUSH2 0x1f7e 0322 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0316 stack[0] = 0x0246 // @0319 stack[1] = 0x0323 // @031C stack[2] = msg.data.length // @031D stack[3] = 0x04 // } // Block ends with call to 0x1f7e, returns to 0x0323 label_0323: // Incoming return from call to 0x1F7E at 0x0322 0323 5B JUMPDEST 0324 61 PUSH2 0x0a0c 0327 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a0c label_0328: // Incoming jump from 0x0146, if 0x42d8c7d5 == stack[-1] // Inputs[1] { @032F msg.data.length } 0328 5B JUMPDEST 0329 61 PUSH2 0x0246 032C 61 PUSH2 0x0336 032F 36 CALLDATASIZE 0330 60 PUSH1 0x04 0332 61 PUSH2 0x20ad 0335 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0329 stack[0] = 0x0246 // @032C stack[1] = 0x0336 // @032F stack[2] = msg.data.length // @0330 stack[3] = 0x04 // } // Block ends with call to 0x20ad, returns to 0x0336 label_0336: // Incoming return from call to 0x20AD at 0x0335 0336 5B JUMPDEST 0337 61 PUSH2 0x0a18 033A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a18 label_033B: // Incoming jump from 0x0151, if 0x5640f549 == stack[-1] // Inputs[1] { @0342 msg.data.length } 033B 5B JUMPDEST 033C 61 PUSH2 0x021e 033F 61 PUSH2 0x0349 0342 36 CALLDATASIZE 0343 60 PUSH1 0x04 0345 61 PUSH2 0x1f7e 0348 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @033C stack[0] = 0x021e // @033F stack[1] = 0x0349 // @0342 stack[2] = msg.data.length // @0343 stack[3] = 0x04 // } // Block ends with call to 0x1f7e, returns to 0x0349 label_0349: // Incoming return from call to 0x1F7E at 0x0348 0349 5B JUMPDEST 034A 61 PUSH2 0x0b8d 034D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b8d label_034E: // Incoming jump from 0x015C, if 0x56938980 == stack[-1] 034E 5B JUMPDEST 034F 61 PUSH2 0x02c5 0352 61 PUSH2 0x2724 0355 81 DUP2 0356 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @034F stack[0] = 0x02c5 // @0352 stack[1] = 0x2724 // } // Block ends with unconditional jump to 0x02c5 label_0357: // Incoming jump from 0x0167, if 0x6352211e == stack[-1] // Inputs[1] { @035E msg.data.length } 0357 5B JUMPDEST 0358 61 PUSH2 0x0270 035B 61 PUSH2 0x0365 035E 36 CALLDATASIZE 035F 60 PUSH1 0x04 0361 61 PUSH2 0x1f7e 0364 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0358 stack[0] = 0x0270 // @035B stack[1] = 0x0365 // @035E stack[2] = msg.data.length // @035F stack[3] = 0x04 // } // Block ends with call to 0x1f7e, returns to 0x0365 label_0365: // Incoming return from call to 0x1F7E at 0x0364 0365 5B JUMPDEST 0366 61 PUSH2 0x0bb8 0369 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bb8 label_036A: // Incoming jump from 0x00F4, if 0x70a08231 == stack[-1] // Inputs[1] { @0371 msg.data.length } 036A 5B JUMPDEST 036B 61 PUSH2 0x02c5 036E 61 PUSH2 0x0378 0371 36 CALLDATASIZE 0372 60 PUSH1 0x04 0374 61 PUSH2 0x1fd8 0377 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @036B stack[0] = 0x02c5 // @036E stack[1] = 0x0378 // @0371 stack[2] = msg.data.length // @0372 stack[3] = 0x04 // } // Block ends with call to 0x1fd8, returns to 0x0378 label_0378: // Incoming return from call to 0x1FD8 at 0x0377 0378 5B JUMPDEST 0379 61 PUSH2 0x0c2e 037C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c2e label_037D: // Incoming jump from 0x00FF, if 0x715018a6 == stack[-1] 037D 5B JUMPDEST 037E 61 PUSH2 0x0246 0381 61 PUSH2 0x0cef 0384 56 *JUMP // Stack delta = +1 // Outputs[1] { @037E stack[0] = 0x0246 } // Block ends with call to 0x0cef, returns to 0x0246 label_0385: // Incoming jump from 0x010A, if 0x729ad39e == stack[-1] // Inputs[1] { @038C msg.data.length } 0385 5B JUMPDEST 0386 61 PUSH2 0x0246 0389 61 PUSH2 0x0393 038C 36 CALLDATASIZE 038D 60 PUSH1 0x04 038F 61 PUSH2 0x2147 0392 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0386 stack[0] = 0x0246 // @0389 stack[1] = 0x0393 // @038C stack[2] = msg.data.length // @038D stack[3] = 0x04 // } // Block ends with call to 0x2147, returns to 0x0393 label_0393: // Incoming return from call to 0x2147 at 0x0392 0393 5B JUMPDEST 0394 61 PUSH2 0x0d25 0397 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d25 label_0398: // Incoming jump from 0x0115, if 0x7f7dcdbf == stack[-1] // Inputs[2] // { // @039E storage[0x00] // @03A8 msg.sender // } 0398 5B JUMPDEST 0399 61 PUSH2 0x021e 039C 60 PUSH1 0x00 039E 54 SLOAD 039F 60 PUSH1 0x01 03A1 60 PUSH1 0x01 03A3 60 PUSH1 0xa0 03A5 1B SHL 03A6 03 SUB 03A7 16 AND 03A8 33 CALLER 03A9 14 EQ 03AA 90 SWAP1 03AB 56 *JUMP // Stack delta = +1 // Outputs[1] { @03AA stack[0] = msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] } // Block ends with unconditional jump to 0x021e label_03AC: // Incoming jump from 0x00C3, if 0x8da5cb5b == stack[-1] // Inputs[1] { @03AF storage[0x00] } 03AC 5B JUMPDEST 03AD 60 PUSH1 0x00 03AF 54 SLOAD 03B0 60 PUSH1 0x01 03B2 60 PUSH1 0x01 03B4 60 PUSH1 0xa0 03B6 1B SHL 03B7 03 SUB 03B8 16 AND 03B9 61 PUSH2 0x0270 03BC 56 *JUMP // Stack delta = +1 // Outputs[1] { @03B8 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x00] } // Block ends with unconditional jump to 0x0270 label_03BD: // Incoming jump from 0x00CE, if 0x94f5a0cb == stack[-1] // Inputs[1] { @03C4 msg.data.length } 03BD 5B JUMPDEST 03BE 61 PUSH2 0x0246 03C1 61 PUSH2 0x03cb 03C4 36 CALLDATASIZE 03C5 60 PUSH1 0x04 03C7 61 PUSH2 0x1fd8 03CA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03BE stack[0] = 0x0246 // @03C1 stack[1] = 0x03cb // @03C4 stack[2] = msg.data.length // @03C5 stack[3] = 0x04 // } // Block ends with call to 0x1fd8, returns to 0x03CB label_03CB: // Incoming return from call to 0x1FD8 at 0x03CA 03CB 5B JUMPDEST 03CC 61 PUSH2 0x0eb2 03CF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0eb2 label_03D0: // Incoming jump from 0x00D9, if 0x95d89b41 == stack[-1] 03D0 5B JUMPDEST 03D1 61 PUSH2 0x0250 03D4 61 PUSH2 0x0f30 03D7 56 *JUMP // Stack delta = +1 // Outputs[1] { @03D1 stack[0] = 0x0250 } // Block ends with call to 0x0f30, returns to 0x0250 label_03D8: // Incoming jump from 0x00E4, if 0x9fe2c592 == stack[-1] // Inputs[1] { @03DF msg.data.length } 03D8 5B JUMPDEST 03D9 61 PUSH2 0x0246 03DC 61 PUSH2 0x03e6 03DF 36 CALLDATASIZE 03E0 60 PUSH1 0x04 03E2 61 PUSH2 0x2147 03E5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03D9 stack[0] = 0x0246 // @03DC stack[1] = 0x03e6 // @03DF stack[2] = msg.data.length // @03E0 stack[3] = 0x04 // } // Block ends with call to 0x2147, returns to 0x03E6 label_03E6: // Incoming return from call to 0x2147 at 0x03E5 03E6 5B JUMPDEST 03E7 61 PUSH2 0x0f3f 03EA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f3f label_03EB: // Incoming jump from 0x0087, if 0xa22cb465 == stack[-1] // Inputs[1] { @03F2 msg.data.length } 03EB 5B JUMPDEST 03EC 61 PUSH2 0x0246 03EF 61 PUSH2 0x03f9 03F2 36 CALLDATASIZE 03F3 60 PUSH1 0x04 03F5 61 PUSH2 0x2189 03F8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03EC stack[0] = 0x0246 // @03EF stack[1] = 0x03f9 // @03F2 stack[2] = msg.data.length // @03F3 stack[3] = 0x04 // } // Block ends with call to 0x2189, returns to 0x03F9 label_03F9: // Incoming return from call to 0x2189 at 0x03F8 03F9 5B JUMPDEST 03FA 61 PUSH2 0x1051 03FD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1051 label_03FE: // Incoming jump from 0x0092, if 0xb88d4fde == stack[-1] // Inputs[1] { @0405 msg.data.length } 03FE 5B JUMPDEST 03FF 61 PUSH2 0x0246 0402 61 PUSH2 0x040c 0405 36 CALLDATASIZE 0406 60 PUSH1 0x04 0408 61 PUSH2 0x224a 040B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03FF stack[0] = 0x0246 // @0402 stack[1] = 0x040c // @0405 stack[2] = msg.data.length // @0406 stack[3] = 0x04 // } // Block ends with call to 0x224a, returns to 0x040C label_040C: // Incoming return from call to 0x224A at 0x040B 040C 5B JUMPDEST 040D 61 PUSH2 0x1060 0410 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1060 label_0411: // Incoming jump from 0x009D, if 0xc47f0027 == stack[-1] // Inputs[1] { @0418 msg.data.length } 0411 5B JUMPDEST 0412 61 PUSH2 0x0246 0415 61 PUSH2 0x041f 0418 36 CALLDATASIZE 0419 60 PUSH1 0x04 041B 61 PUSH2 0x22ca 041E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0412 stack[0] = 0x0246 // @0415 stack[1] = 0x041f // @0418 stack[2] = msg.data.length // @0419 stack[3] = 0x04 // } // Block ends with call to 0x22ca, returns to 0x041F label_041F: // Incoming return from call to 0x22CA at 0x041E 041F 5B JUMPDEST 0420 61 PUSH2 0x1092 0423 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1092 label_0424: // Incoming jump from 0x00A8, if 0xc87b56dd == stack[-1] // Inputs[1] { @042B msg.data.length } 0424 5B JUMPDEST 0425 61 PUSH2 0x0250 0428 61 PUSH2 0x0432 042B 36 CALLDATASIZE 042C 60 PUSH1 0x04 042E 61 PUSH2 0x1f7e 0431 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0425 stack[0] = 0x0250 // @0428 stack[1] = 0x0432 // @042B stack[2] = msg.data.length // @042C stack[3] = 0x04 // } // Block ends with call to 0x1f7e, returns to 0x0432 label_0432: // Incoming return from call to 0x1F7E at 0x0431 0432 5B JUMPDEST 0433 61 PUSH2 0x1133 0436 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1133 label_0437: // Incoming jump from 0x004B, if 0xd134dd4a == stack[-1] // Inputs[1] { @043D memory[0x40:0x60] } 0437 5B JUMPDEST 0438 61 PUSH2 0x0250 043B 60 PUSH1 0x40 043D 51 MLOAD 043E 80 DUP1 043F 60 PUSH1 0x40 0441 01 ADD 0442 60 PUSH1 0x40 0444 52 MSTORE 0445 80 DUP1 0446 60 PUSH1 0x05 0448 81 DUP2 0449 52 MSTORE 044A 60 PUSH1 0x20 044C 01 ADD 044D 64 PUSH5 0x173539b7b7 0453 60 PUSH1 0xd9 0455 1B SHL 0456 81 DUP2 0457 52 MSTORE 0458 50 POP 0459 81 DUP2 045A 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @0438 stack[0] = 0x0250 // @043D stack[1] = memory[0x40:0x60] // @0444 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0449 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x05 // @0457 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x173539b7b7 << 0xd9 // } // Block ends with unconditional jump to 0x0250 label_045B: // Incoming jump from 0x0056, if 0xe8a3d485 == stack[-1] 045B 5B JUMPDEST 045C 61 PUSH2 0x0250 045F 61 PUSH2 0x12a0 0462 56 *JUMP // Stack delta = +1 // Outputs[1] { @045C stack[0] = 0x0250 } // Block ends with call to 0x12a0, returns to 0x0250 label_0463: // Incoming jump from 0x0061, if 0xe985e9c5 == stack[-1] // Inputs[1] { @046A msg.data.length } 0463 5B JUMPDEST 0464 61 PUSH2 0x021e 0467 61 PUSH2 0x0471 046A 36 CALLDATASIZE 046B 60 PUSH1 0x04 046D 61 PUSH2 0x2313 0470 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0464 stack[0] = 0x021e // @0467 stack[1] = 0x0471 // @046A stack[2] = msg.data.length // @046B stack[3] = 0x04 // } // Block ends with call to 0x2313, returns to 0x0471 label_0471: // Incoming return from call to 0x2313 at 0x0470 // Inputs[6] // { // @047A stack[-2] // @048D memory[0x00:0x40] // @048E stack[-1] // @0498 memory[0x00:0x40] // @0499 storage[keccak256(memory[0x00:0x40])] // @049D stack[-3] // } 0471 5B JUMPDEST 0472 60 PUSH1 0x01 0474 60 PUSH1 0x01 0476 60 PUSH1 0xa0 0478 1B SHL 0479 03 SUB 047A 91 SWAP2 047B 82 DUP3 047C 16 AND 047D 60 PUSH1 0x00 047F 90 SWAP1 0480 81 DUP2 0481 52 MSTORE 0482 60 PUSH1 0x05 0484 60 PUSH1 0x20 0486 90 SWAP1 0487 81 DUP2 0488 52 MSTORE 0489 60 PUSH1 0x40 048B 80 DUP1 048C 83 DUP4 048D 20 SHA3 048E 93 SWAP4 048F 90 SWAP1 0490 94 SWAP5 0491 16 AND 0492 82 DUP3 0493 52 MSTORE 0494 91 SWAP2 0495 90 SWAP1 0496 91 SWAP2 0497 52 MSTORE 0498 20 SHA3 0499 54 SLOAD 049A 60 PUSH1 0xff 049C 16 AND 049D 90 SWAP1 049E 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0481 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0488 memory[0x20:0x40] = 0x05 // @0493 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0497 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @049D stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_049F: // Incoming jump from 0x006C, if 0xefd563cd == stack[-1] // Inputs[1] { @04A6 msg.data.length } 049F 5B JUMPDEST 04A0 61 PUSH2 0x0246 04A3 61 PUSH2 0x04ad 04A6 36 CALLDATASIZE 04A7 60 PUSH1 0x04 04A9 61 PUSH2 0x1fac 04AC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04A0 stack[0] = 0x0246 // @04A3 stack[1] = 0x04ad // @04A6 stack[2] = msg.data.length // @04A7 stack[3] = 0x04 // } // Block ends with call to 0x1fac, returns to 0x04AD label_04AD: // Incoming return from call to 0x1FAC at 0x04AC 04AD 5B JUMPDEST 04AE 61 PUSH2 0x12af 04B1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x12af label_04B2: // Incoming jump from 0x0077, if 0xf2fde38b == stack[-1] // Inputs[1] { @04B9 msg.data.length } 04B2 5B JUMPDEST 04B3 61 PUSH2 0x0246 04B6 61 PUSH2 0x04c0 04B9 36 CALLDATASIZE 04BA 60 PUSH1 0x04 04BC 61 PUSH2 0x1fd8 04BF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04B3 stack[0] = 0x0246 // @04B6 stack[1] = 0x04c0 // @04B9 stack[2] = msg.data.length // @04BA stack[3] = 0x04 // } // Block ends with call to 0x1fd8, returns to 0x04C0 label_04C0: // Incoming return from call to 0x1FD8 at 0x04BF 04C0 5B JUMPDEST 04C1 61 PUSH2 0x139e 04C4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x139e label_04C5: // Incoming jump from 0x021D // Inputs[1] { @04D1 stack[-1] } 04C5 5B JUMPDEST 04C6 60 PUSH1 0x00 04C8 60 PUSH1 0x01 04CA 60 PUSH1 0x01 04CC 60 PUSH1 0xe0 04CE 1B SHL 04CF 03 SUB 04D0 19 NOT 04D1 82 DUP3 04D2 16 AND 04D3 63 PUSH4 0x80ac58cd 04D8 60 PUSH1 0xe0 04DA 1B SHL 04DB 14 EQ 04DC 80 DUP1 04DD 61 PUSH2 0x04f6 04E0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @04C6 stack[0] = 0x00 // @04DB stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x04f6, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_04E1: // Incoming jump from 0x04E0, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @04EB stack[-3] } 04E1 50 POP 04E2 60 PUSH1 0x01 04E4 60 PUSH1 0x01 04E6 60 PUSH1 0xe0 04E8 1B SHL 04E9 03 SUB 04EA 19 NOT 04EB 82 DUP3 04EC 16 AND 04ED 63 PUSH4 0x5b5e139f 04F2 60 PUSH1 0xe0 04F4 1B SHL 04F5 14 EQ 04F6 5B JUMPDEST 04F7 80 DUP1 04F8 61 PUSH2 0x0511 04FB 57 *JUMPI // Stack delta = +0 // Outputs[1] { @04F5 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0511, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_04FC: // Incoming jump from 0x04FB, if not stack[-1] // Incoming jump from 0x04FB, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @050E stack[-3] } 04FC 50 POP 04FD 63 PUSH4 0x01ffc9a7 0502 60 PUSH1 0xe0 0504 1B SHL 0505 60 PUSH1 0x01 0507 60 PUSH1 0x01 0509 60 PUSH1 0xe0 050B 1B SHL 050C 03 SUB 050D 19 NOT 050E 83 DUP4 050F 16 AND 0510 14 EQ // Stack delta = +0 // Outputs[1] { @0510 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block continues label_0511: // Incoming jump from 0x18BB, if !!(0xff & storage[0x0a]) // Incoming jump from 0x0B99, if stack[-1] > 0x2724 // Incoming jump from 0x18BB, if !stack[-1] // Incoming jump from 0x0510 // Incoming jump from 0x04FB, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x04FB, if stack[-1] // Incoming jump from 0x19D9 // Incoming jump from 0x1943 // Incoming jump from 0x194A // Inputs[3] // { // @0512 stack[-1] // @0512 stack[-4] // @0513 stack[-3] // } 0511 5B JUMPDEST 0512 92 SWAP3 0513 91 SWAP2 0514 50 POP 0515 50 POP 0516 56 *JUMP // Stack delta = -3 // Outputs[1] { @0512 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0517: // Incoming jump from 0x0245 // Inputs[2] // { // @051A storage[0x00] // @0524 msg.sender // } 0517 5B JUMPDEST 0518 60 PUSH1 0x00 051A 54 SLOAD 051B 60 PUSH1 0x01 051D 60 PUSH1 0x01 051F 60 PUSH1 0xa0 0521 1B SHL 0522 03 SUB 0523 16 AND 0524 33 CALLER 0525 14 EQ 0526 61 PUSH2 0x054a 0529 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x054a, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_052A: // Incoming jump from 0x0529, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @052C memory[0x40:0x60] } 052A 60 PUSH1 0x40 052C 51 MLOAD 052D 62 PUSH3 0x461bcd 0531 60 PUSH1 0xe5 0533 1B SHL 0534 81 DUP2 0535 52 MSTORE 0536 60 PUSH1 0x04 0538 01 ADD 0539 61 PUSH2 0x0541 053C 90 SWAP1 053D 61 PUSH2 0x234c 0540 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0535 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @053C stack[0] = 0x0541 // @053C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x234c, returns to 0x0541 label_0541: // Incoming jump from 0x05AF // Incoming return from call to 0x234C at 0x13C7 // Incoming jump from 0x111F // Incoming jump from 0x142C // Incoming return from call to 0x234C at 0x0A41 // Incoming return from call to 0x234C at 0x0EDB // Incoming return from call to 0x234C at 0x096E // Incoming return from call to 0x234C at 0x0815 // Incoming return from call to 0x234C at 0x10BB // Incoming return from call to 0x23BC at 0x083D // Incoming jump from 0x0A92 // Incoming jump from 0x0900 // Incoming jump from 0x1AB5 // Incoming jump from 0x0E10 // Incoming return from call to 0x23BC at 0x0F03 // Incoming return from call to 0x234C at 0x0893 // Incoming jump from 0x1337 // Incoming return from call to 0x234C at 0x0540 // Incoming jump from 0x06BE // Incoming jump from 0x09D6 // Incoming jump from 0x11A1 // Incoming return from call to 0x234C at 0x0D4E // Incoming jump from 0x0DA6 // Incoming return from call to 0x234C at 0x0D18 // Incoming jump from 0x0C98 // Inputs[3] // { // @0544 memory[0x40:0x60] // @0546 stack[-1] // @0549 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0541 5B JUMPDEST 0542 60 PUSH1 0x40 0544 51 MLOAD 0545 80 DUP1 0546 91 SWAP2 0547 03 SUB 0548 90 SWAP1 0549 FD *REVERT // Stack delta = -1 // Outputs[1] { @0549 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_054A: // Incoming jump from 0x0529, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @054D storage[0x0a] } 054A 5B JUMPDEST 054B 60 PUSH1 0x0a 054D 54 SLOAD 054E 61 PUSH2 0x0100 0551 90 SWAP1 0552 04 DIV 0553 60 PUSH1 0xff 0555 16 AND 0556 15 ISZERO 0557 61 PUSH2 0x05b0 055A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b0, if !(0xff & storage[0x0a] / 0x0100) label_055B: // Incoming jump from 0x055A, if not !(0xff & storage[0x0a] / 0x0100) // Inputs[1] { @055D memory[0x40:0x60] } 055B 60 PUSH1 0x40 055D 51 MLOAD 055E 62 PUSH3 0x461bcd 0562 60 PUSH1 0xe5 0564 1B SHL 0565 81 DUP2 0566 52 MSTORE 0567 60 PUSH1 0x20 0569 60 PUSH1 0x04 056B 82 DUP3 056C 01 ADD 056D 52 MSTORE 056E 60 PUSH1 0x25 0570 60 PUSH1 0x24 0572 82 DUP3 0573 01 ADD 0574 52 MSTORE 0575 7F PUSH32 0x43616e6e6f7420656469742062617365205552492061667465722066696e616c 0596 60 PUSH1 0x44 0598 82 DUP3 0599 01 ADD 059A 52 MSTORE 059B 64 PUSH5 0x34bd32b217 05A1 60 PUSH1 0xd9 05A3 1B SHL 05A4 60 PUSH1 0x64 05A6 82 DUP3 05A7 01 ADD 05A8 52 MSTORE 05A9 60 PUSH1 0x84 05AB 01 ADD 05AC 61 PUSH2 0x0541 05AF 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0566 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @056D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0574 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @059A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616e6e6f7420656469742062617365205552492061667465722066696e616c // @05A8 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x34bd32b217 << 0xd9 // @05AB stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0541 label_05B0: // Incoming jump from 0x055A, if !(0xff & storage[0x0a] / 0x0100) // Inputs[2] // { // @05B6 stack[-2] // @05B7 stack[-1] // } 05B0 5B JUMPDEST 05B1 61 PUSH2 0x05bc 05B4 60 PUSH1 0x06 05B6 83 DUP4 05B7 83 DUP4 05B8 61 PUSH2 0x1d61 05BB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05B1 stack[0] = 0x05bc // @05B4 stack[1] = 0x06 // @05B6 stack[2] = stack[-2] // @05B7 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1d61 label_05BC: // Incoming jump from 0x0E94, if !(stack[-1] > stack[-2]) // Inputs[1] { @05C0 stack[-4] } 05BC 5B JUMPDEST 05BD 50 POP 05BE 50 POP 05BF 50 POP 05C0 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_05C1: // Incoming call from 0x024F, returns to 0x0250 // Inputs[1] { @05C7 storage[0x01] } 05C1 5B JUMPDEST 05C2 60 PUSH1 0x60 05C4 60 PUSH1 0x01 05C6 80 DUP1 05C7 54 SLOAD 05C8 61 PUSH2 0x05d0 05CB 90 SWAP1 05CC 61 PUSH2 0x2381 05CF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05C2 stack[0] = 0x60 // @05C4 stack[1] = 0x01 // @05CB stack[2] = 0x05d0 // @05CB stack[3] = storage[0x01] // } // Block ends with call to 0x2381, returns to 0x05D0 label_05D0: // Incoming return from call to 0x2381 at 0x0F3E // Incoming return from call to 0x2381 at 0x12AE // Incoming return from call to 0x2381 at 0x05CF // Inputs[4] // { // @05D1 stack[-1] // @05E0 memory[0x40:0x60] // @05E8 stack[-2] // @05F3 storage[stack[-2]] // } 05D0 5B JUMPDEST 05D1 80 DUP1 05D2 60 PUSH1 0x1f 05D4 01 ADD 05D5 60 PUSH1 0x20 05D7 80 DUP1 05D8 91 SWAP2 05D9 04 DIV 05DA 02 MUL 05DB 60 PUSH1 0x20 05DD 01 ADD 05DE 60 PUSH1 0x40 05E0 51 MLOAD 05E1 90 SWAP1 05E2 81 DUP2 05E3 01 ADD 05E4 60 PUSH1 0x40 05E6 52 MSTORE 05E7 80 DUP1 05E8 92 SWAP3 05E9 91 SWAP2 05EA 90 SWAP1 05EB 81 DUP2 05EC 81 DUP2 05ED 52 MSTORE 05EE 60 PUSH1 0x20 05F0 01 ADD 05F1 82 DUP3 05F2 80 DUP1 05F3 54 SLOAD 05F4 61 PUSH2 0x05fc 05F7 90 SWAP1 05F8 61 PUSH2 0x2381 05FB 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @05E6 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @05E8 stack[-2] = memory[0x40:0x60] // @05E9 stack[-1] = stack[-2] // @05EA stack[0] = stack[-1] // @05ED memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @05F0 stack[1] = 0x20 + memory[0x40:0x60] // @05F1 stack[2] = stack[-2] // @05F7 stack[4] = storage[stack[-2]] // @05F7 stack[3] = 0x05fc // } // Block ends with call to 0x2381, returns to 0x05FC label_05FC: // Incoming return from call to 0x2381 at 0x05FB // Inputs[1] { @05FD stack[-1] } 05FC 5B JUMPDEST 05FD 80 DUP1 05FE 15 ISZERO 05FF 61 PUSH2 0x0649 0602 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0649, if !stack[-1] label_0603: // Incoming jump from 0x0602, if not !stack[-1] // Inputs[1] { @0603 stack[-1] } 0603 80 DUP1 0604 60 PUSH1 0x1f 0606 10 LT 0607 61 PUSH2 0x061e 060A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x061e, if 0x1f < stack[-1] label_060B: // Incoming jump from 0x060A, if not 0x1f < stack[-1] // Inputs[4] // { // @060F stack[-2] // @0610 storage[stack[-2]] // @0613 stack[-3] // @0615 stack[-1] // } 060B 61 PUSH2 0x0100 060E 80 DUP1 060F 83 DUP4 0610 54 SLOAD 0611 04 DIV 0612 02 MUL 0613 83 DUP4 0614 52 MSTORE 0615 91 SWAP2 0616 60 PUSH1 0x20 0618 01 ADD 0619 91 SWAP2 061A 61 PUSH2 0x0649 061D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0614 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0619 stack[-1] = stack[-1] // @0619 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0649 label_061E: // Incoming jump from 0x060A, if 0x1f < stack[-1] // Inputs[5] // { // @061F stack[-3] // @0620 stack[-1] // @0622 stack[-2] // @062A memory[0x00:0x20] // @062E storage[keccak256(memory[0x00:0x20])] // } 061E 5B JUMPDEST 061F 82 DUP3 0620 01 ADD 0621 91 SWAP2 0622 90 SWAP1 0623 60 PUSH1 0x00 0625 52 MSTORE 0626 60 PUSH1 0x20 0628 60 PUSH1 0x00 062A 20 SHA3 062B 90 SWAP1 062C 5B JUMPDEST 062D 81 DUP2 062E 54 SLOAD 062F 81 DUP2 0630 52 MSTORE 0631 90 SWAP1 0632 60 PUSH1 0x01 0634 01 ADD 0635 90 SWAP1 0636 60 PUSH1 0x20 0638 01 ADD 0639 80 DUP1 063A 83 DUP4 063B 11 GT 063C 61 PUSH2 0x062c 063F 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0621 stack[-3] = stack[-3] + stack[-1] // @0625 memory[0x00:0x20] = stack[-2] // @0630 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0635 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0638 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x062c, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0640: // Incoming jump from 0x063F, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x063F, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0640 stack[-3] // @0641 stack[-1] // } 0640 82 DUP3 0641 90 SWAP1 0642 03 SUB 0643 60 PUSH1 0x1f 0645 16 AND 0646 82 DUP3 0647 01 ADD 0648 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0648 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0648 stack[-1] = stack[-3] // } // Block continues label_0649: // Incoming jump from 0x0648 // Incoming jump from 0x0602, if !stack[-1] // Incoming jump from 0x061D // Inputs[3] // { // @064F stack[-6] // @064F stack[-7] // @0651 stack[-8] // } 0649 5B JUMPDEST 064A 50 POP 064B 50 POP 064C 50 POP 064D 50 POP 064E 50 POP 064F 90 SWAP1 0650 50 POP 0651 90 SWAP1 0652 56 *JUMP // Stack delta = -7 // Outputs[1] { @0651 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0653: // Incoming jump from 0x026F // Inputs[1] { @0659 stack[-1] } 0653 5B JUMPDEST 0654 60 PUSH1 0x00 0656 61 PUSH2 0x065e 0659 82 DUP3 065A 61 PUSH2 0x1436 065D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0654 stack[0] = 0x00 // @0656 stack[1] = 0x065e // @0659 stack[2] = stack[-1] // } // Block ends with call to 0x1436, returns to 0x065E label_065E: // Incoming return from call to 0x1436 at 0x065D // Incoming return from call to 0x1436 at 0x065D // Incoming return from call to 0x1436 at 0x065D // Inputs[1] { @0662 stack[-1] } 065E 5B JUMPDEST 065F 61 PUSH2 0x06bf 0662 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x06bf, if stack[-1] label_0663: // Incoming jump from 0x0662, if not stack[-1] // Inputs[1] { @0665 memory[0x40:0x60] } 0663 60 PUSH1 0x40 0665 51 MLOAD 0666 62 PUSH3 0x461bcd 066A 60 PUSH1 0xe5 066C 1B SHL 066D 81 DUP2 066E 52 MSTORE 066F 60 PUSH1 0x20 0671 60 PUSH1 0x04 0673 82 DUP3 0674 01 ADD 0675 52 MSTORE 0676 60 PUSH1 0x2c 0678 60 PUSH1 0x24 067A 82 DUP3 067B 01 ADD 067C 52 MSTORE 067D 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 069E 60 PUSH1 0x44 06A0 82 DUP3 06A1 01 ADD 06A2 52 MSTORE 06A3 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 06B0 60 PUSH1 0xa1 06B2 1B SHL 06B3 60 PUSH1 0x64 06B5 82 DUP3 06B6 01 ADD 06B7 52 MSTORE 06B8 60 PUSH1 0x84 06BA 01 ADD 06BB 61 PUSH2 0x0541 06BE 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @066E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0675 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @067C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @06A2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 // @06B7 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @06BA stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0541 label_06BF: // Incoming jump from 0x0662, if stack[-1] // Inputs[4] // { // @06C3 stack[-2] // @06CE memory[0x00:0x40] // @06CF storage[keccak256(memory[0x00:0x40])] // @06D9 stack[-3] // } 06BF 5B JUMPDEST 06C0 50 POP 06C1 60 PUSH1 0x00 06C3 90 SWAP1 06C4 81 DUP2 06C5 52 MSTORE 06C6 60 PUSH1 0x04 06C8 60 PUSH1 0x20 06CA 52 MSTORE 06CB 60 PUSH1 0x40 06CD 90 SWAP1 06CE 20 SHA3 06CF 54 SLOAD 06D0 60 PUSH1 0x01 06D2 60 PUSH1 0x01 06D4 60 PUSH1 0xa0 06D6 1B SHL 06D7 03 SUB 06D8 16 AND 06D9 90 SWAP1 06DA 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @06C5 memory[0x00:0x20] = stack[-2] // @06CA memory[0x20:0x40] = 0x04 // @06D9 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_06DB: // Incoming jump from 0x029A // Inputs[1] { @06E1 stack[-1] } 06DB 5B JUMPDEST 06DC 60 PUSH1 0x00 06DE 61 PUSH2 0x06e6 06E1 82 DUP3 06E2 61 PUSH2 0x0bb8 06E5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06DC stack[0] = 0x00 // @06DE stack[1] = 0x06e6 // @06E1 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x0bb8 06E6 5B JUMPDEST 06E7 90 SWAP1 06E8 50 POP 06E9 80 DUP1 06EA 60 PUSH1 0x01 06EC 60 PUSH1 0x01 06EE 60 PUSH1 0xa0 06F0 1B SHL 06F1 03 SUB 06F2 16 AND 06F3 83 DUP4 06F4 60 PUSH1 0x01 06F6 60 PUSH1 0x01 06F8 60 PUSH1 0xa0 06FA 1B SHL 06FB 03 SUB 06FC 16 AND 06FD 14 EQ 06FE 15 ISZERO 06FF 61 PUSH2 0x0754 0702 57 *JUMPI 0703 60 PUSH1 0x40 0705 51 MLOAD 0706 62 PUSH3 0x461bcd 070A 60 PUSH1 0xe5 070C 1B SHL 070D 81 DUP2 070E 52 MSTORE 070F 60 PUSH1 0x20 0711 60 PUSH1 0x04 0713 82 DUP3 0714 01 ADD 0715 52 MSTORE 0716 60 PUSH1 0x21 0718 60 PUSH1 0x24 071A 82 DUP3 071B 01 ADD 071C 52 MSTORE 071D 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 073E 60 PUSH1 0x44 0740 82 DUP3 0741 01 ADD 0742 52 MSTORE 0743 60 PUSH1 0x39 0745 60 PUSH1 0xf9 0747 1B SHL 0748 60 PUSH1 0x64 074A 82 DUP3 074B 01 ADD 074C 52 MSTORE 074D 60 PUSH1 0x84 074F 01 ADD 0750 61 PUSH2 0x0541 0753 56 *JUMP 0754 5B JUMPDEST 0755 33 CALLER 0756 60 PUSH1 0x01 0758 60 PUSH1 0x01 075A 60 PUSH1 0xa0 075C 1B SHL 075D 03 SUB 075E 82 DUP3 075F 16 AND 0760 14 EQ 0761 80 DUP1 0762 61 PUSH2 0x0770 0765 57 *JUMPI 0766 50 POP 0767 61 PUSH2 0x0770 076A 81 DUP2 076B 33 CALLER 076C 61 PUSH2 0x0471 076F 56 *JUMP 0770 5B JUMPDEST 0771 61 PUSH2 0x07e2 0774 57 *JUMPI 0775 60 PUSH1 0x40 0777 51 MLOAD 0778 62 PUSH3 0x461bcd 077C 60 PUSH1 0xe5 077E 1B SHL 077F 81 DUP2 0780 52 MSTORE 0781 60 PUSH1 0x20 0783 60 PUSH1 0x04 0785 82 DUP3 0786 01 ADD 0787 52 MSTORE 0788 60 PUSH1 0x38 078A 60 PUSH1 0x24 078C 82 DUP3 078D 01 ADD 078E 52 MSTORE 078F 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 07B0 60 PUSH1 0x44 07B2 82 DUP3 07B3 01 ADD 07B4 52 MSTORE 07B5 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 07D6 60 PUSH1 0x64 07D8 82 DUP3 07D9 01 ADD 07DA 52 MSTORE 07DB 60 PUSH1 0x84 07DD 01 ADD 07DE 61 PUSH2 0x0541 07E1 56 *JUMP 07E2 5B JUMPDEST 07E3 61 PUSH2 0x05bc 07E6 83 DUP4 07E7 83 DUP4 07E8 61 PUSH2 0x1598 07EB 56 *JUMP label_07EC: // Incoming jump from 0x02AD // Inputs[2] // { // @07EF storage[0x00] // @07F9 msg.sender // } 07EC 5B JUMPDEST 07ED 60 PUSH1 0x00 07EF 54 SLOAD 07F0 60 PUSH1 0x01 07F2 60 PUSH1 0x01 07F4 60 PUSH1 0xa0 07F6 1B SHL 07F7 03 SUB 07F8 16 AND 07F9 33 CALLER 07FA 14 EQ 07FB 61 PUSH2 0x0816 07FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0816, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_07FF: // Incoming jump from 0x07FE, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0801 memory[0x40:0x60] } 07FF 60 PUSH1 0x40 0801 51 MLOAD 0802 62 PUSH3 0x461bcd 0806 60 PUSH1 0xe5 0808 1B SHL 0809 81 DUP2 080A 52 MSTORE 080B 60 PUSH1 0x04 080D 01 ADD 080E 61 PUSH2 0x0541 0811 90 SWAP1 0812 61 PUSH2 0x234c 0815 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @080A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0811 stack[0] = 0x0541 // @0811 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x234c, returns to 0x0541 label_0816: // Incoming jump from 0x07FE, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0819 storage[0x0a] } 0816 5B JUMPDEST 0817 60 PUSH1 0x0a 0819 54 SLOAD 081A 61 PUSH2 0x0100 081D 90 SWAP1 081E 04 DIV 081F 60 PUSH1 0xff 0821 16 AND 0822 15 ISZERO 0823 61 PUSH2 0x083e 0826 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x083e, if !(0xff & storage[0x0a] / 0x0100) label_0827: // Incoming jump from 0x0826, if not !(0xff & storage[0x0a] / 0x0100) // Inputs[1] { @0829 memory[0x40:0x60] } 0827 60 PUSH1 0x40 0829 51 MLOAD 082A 62 PUSH3 0x461bcd 082E 60 PUSH1 0xe5 0830 1B SHL 0831 81 DUP2 0832 52 MSTORE 0833 60 PUSH1 0x04 0835 01 ADD 0836 61 PUSH2 0x0541 0839 90 SWAP1 083A 61 PUSH2 0x23bc 083D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0832 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0839 stack[0] = 0x0541 // @0839 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x23bc, returns to 0x0541 label_083E: // Incoming jump from 0x0826, if !(0xff & storage[0x0a] / 0x0100) // Inputs[4] // { // @0842 storage[0x0c] // @084C stack[-1] // @0862 storage[0x0e] // @0869 stack[-2] // } 083E 5B JUMPDEST 083F 60 PUSH1 0x0c 0841 80 DUP1 0842 54 SLOAD 0843 60 PUSH1 0x01 0845 60 PUSH1 0x01 0847 60 PUSH1 0xa0 0849 1B SHL 084A 03 SUB 084B 90 SWAP1 084C 92 SWAP3 084D 16 AND 084E 60 PUSH1 0x01 0850 60 PUSH1 0x01 0852 60 PUSH1 0xa0 0854 1B SHL 0855 03 SUB 0856 19 NOT 0857 92 SWAP3 0858 83 DUP4 0859 16 AND 085A 81 DUP2 085B 17 OR 085C 90 SWAP1 085D 91 SWAP2 085E 55 SSTORE 085F 60 PUSH1 0x0e 0861 80 DUP1 0862 54 SLOAD 0863 90 SWAP1 0864 92 SWAP3 0865 16 AND 0866 17 OR 0867 90 SWAP1 0868 55 SSTORE 0869 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @085E storage[0x0c] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[0x0c]) // @0868 storage[0x0e] = (~((0x01 << 0xa0) - 0x01) & storage[0x0e]) | (stack[-1] & (0x01 << 0xa0) - 0x01) // } // Block ends with unconditional jump to stack[-2] label_086A: // Incoming jump from 0x02C0 // Inputs[2] // { // @086D storage[0x00] // @0877 msg.sender // } 086A 5B JUMPDEST 086B 60 PUSH1 0x00 086D 54 SLOAD 086E 60 PUSH1 0x01 0870 60 PUSH1 0x01 0872 60 PUSH1 0xa0 0874 1B SHL 0875 03 SUB 0876 16 AND 0877 33 CALLER 0878 14 EQ 0879 61 PUSH2 0x0894 087C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0894, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_087D: // Incoming jump from 0x087C, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @087F memory[0x40:0x60] } 087D 60 PUSH1 0x40 087F 51 MLOAD 0880 62 PUSH3 0x461bcd 0884 60 PUSH1 0xe5 0886 1B SHL 0887 81 DUP2 0888 52 MSTORE 0889 60 PUSH1 0x04 088B 01 ADD 088C 61 PUSH2 0x0541 088F 90 SWAP1 0890 61 PUSH2 0x234c 0893 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0888 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @088F stack[0] = 0x0541 // @088F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x234c, returns to 0x0541 label_0894: // Incoming jump from 0x087C, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0897 storage[0x0a] } 0894 5B JUMPDEST 0895 60 PUSH1 0x0a 0897 54 SLOAD 0898 61 PUSH2 0x0100 089B 90 SWAP1 089C 04 DIV 089D 60 PUSH1 0xff 089F 16 AND 08A0 15 ISZERO 08A1 61 PUSH2 0x0901 08A4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0901, if !(0xff & storage[0x0a] / 0x0100) label_08A5: // Incoming jump from 0x08A4, if not !(0xff & storage[0x0a] / 0x0100) // Inputs[1] { @08A7 memory[0x40:0x60] } 08A5 60 PUSH1 0x40 08A7 51 MLOAD 08A8 62 PUSH3 0x461bcd 08AC 60 PUSH1 0xe5 08AE 1B SHL 08AF 81 DUP2 08B0 52 MSTORE 08B1 60 PUSH1 0x20 08B3 60 PUSH1 0x04 08B5 82 DUP3 08B6 01 ADD 08B7 52 MSTORE 08B8 60 PUSH1 0x2c 08BA 60 PUSH1 0x24 08BC 82 DUP3 08BD 01 ADD 08BE 52 MSTORE 08BF 7F PUSH32 0x43616e6e6f74206275726e20656e7469726520636f6e74726163742061667465 08E0 60 PUSH1 0x44 08E2 82 DUP3 08E3 01 ADD 08E4 52 MSTORE 08E5 6B PUSH12 0x39103334b730b634bd32b217 08F2 60 PUSH1 0xa1 08F4 1B SHL 08F5 60 PUSH1 0x64 08F7 82 DUP3 08F8 01 ADD 08F9 52 MSTORE 08FA 60 PUSH1 0x84 08FC 01 ADD 08FD 61 PUSH2 0x0541 0900 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @08B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08B7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @08BE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @08E4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616e6e6f74206275726e20656e7469726520636f6e74726163742061667465 // @08F9 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x39103334b730b634bd32b217 << 0xa1 // @08FC stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0541 label_0901: // Incoming jump from 0x08A4, if !(0xff & storage[0x0a] / 0x0100) // Inputs[3] // { // @0905 storage[0x0a] // @090A stack[-1] // @0913 stack[-2] // } 0901 5B JUMPDEST 0902 60 PUSH1 0x0a 0904 80 DUP1 0905 54 SLOAD 0906 60 PUSH1 0xff 0908 19 NOT 0909 16 AND 090A 91 SWAP2 090B 15 ISZERO 090C 15 ISZERO 090D 91 SWAP2 090E 90 SWAP1 090F 91 SWAP2 0910 17 OR 0911 90 SWAP1 0912 55 SSTORE 0913 56 *JUMP // Stack delta = -2 // Outputs[1] { @0912 storage[0x0a] = !!stack[-1] | (~0xff & storage[0x0a]) } // Block ends with unconditional jump to stack[-2] label_0914: // Incoming jump from 0x02E5 // Inputs[2] // { // @0918 msg.sender // @0919 stack[-1] // } 0914 5B JUMPDEST 0915 61 PUSH2 0x091e 0918 33 CALLER 0919 82 DUP3 091A 61 PUSH2 0x1606 091D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0915 stack[0] = 0x091e // @0918 stack[1] = msg.sender // @0919 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x1606 091E 5B JUMPDEST 091F 61 PUSH2 0x093a 0922 57 *JUMPI 0923 60 PUSH1 0x40 0925 51 MLOAD 0926 62 PUSH3 0x461bcd 092A 60 PUSH1 0xe5 092C 1B SHL 092D 81 DUP2 092E 52 MSTORE 092F 60 PUSH1 0x04 0931 01 ADD 0932 61 PUSH2 0x0541 0935 90 SWAP1 0936 61 PUSH2 0x2407 0939 56 *JUMP 093A 5B JUMPDEST 093B 61 PUSH2 0x05bc 093E 83 DUP4 093F 83 DUP4 0940 83 DUP4 0941 61 PUSH2 0x1685 0944 56 *JUMP label_0945: // Incoming jump from 0x02F8 // Inputs[2] // { // @0948 storage[0x00] // @0952 msg.sender // } 0945 5B JUMPDEST 0946 60 PUSH1 0x00 0948 54 SLOAD 0949 60 PUSH1 0x01 094B 60 PUSH1 0x01 094D 60 PUSH1 0xa0 094F 1B SHL 0950 03 SUB 0951 16 AND 0952 33 CALLER 0953 14 EQ 0954 61 PUSH2 0x096f 0957 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x096f, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0958: // Incoming jump from 0x0957, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @095A memory[0x40:0x60] } 0958 60 PUSH1 0x40 095A 51 MLOAD 095B 62 PUSH3 0x461bcd 095F 60 PUSH1 0xe5 0961 1B SHL 0962 81 DUP2 0963 52 MSTORE 0964 60 PUSH1 0x04 0966 01 ADD 0967 61 PUSH2 0x0541 096A 90 SWAP1 096B 61 PUSH2 0x234c 096E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0963 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @096A stack[0] = 0x0541 // @096A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x234c, returns to 0x0541 label_096F: // Incoming jump from 0x0957, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0972 storage[0x0a] } 096F 5B JUMPDEST 0970 60 PUSH1 0x0a 0972 54 SLOAD 0973 61 PUSH2 0x0100 0976 90 SWAP1 0977 04 DIV 0978 60 PUSH1 0xff 097A 16 AND 097B 15 ISZERO 097C 61 PUSH2 0x09d7 097F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09d7, if !(0xff & storage[0x0a] / 0x0100) label_0980: // Incoming jump from 0x097F, if not !(0xff & storage[0x0a] / 0x0100) // Inputs[1] { @0982 memory[0x40:0x60] } 0980 60 PUSH1 0x40 0982 51 MLOAD 0983 62 PUSH3 0x461bcd 0987 60 PUSH1 0xe5 0989 1B SHL 098A 81 DUP2 098B 52 MSTORE 098C 60 PUSH1 0x20 098E 60 PUSH1 0x04 0990 82 DUP3 0991 01 ADD 0992 52 MSTORE 0993 60 PUSH1 0x27 0995 60 PUSH1 0x24 0997 82 DUP3 0998 01 ADD 0999 52 MSTORE 099A 7F PUSH32 0x43616e6e6f74206368616e67652066696e616c697a652061667465722066696e 09BB 60 PUSH1 0x44 09BD 82 DUP3 09BE 01 ADD 09BF 52 MSTORE 09C0 66 PUSH7 0x30b634bd32b217 09C8 60 PUSH1 0xc9 09CA 1B SHL 09CB 60 PUSH1 0x64 09CD 82 DUP3 09CE 01 ADD 09CF 52 MSTORE 09D0 60 PUSH1 0x84 09D2 01 ADD 09D3 61 PUSH2 0x0541 09D6 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @098B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0992 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0999 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x27 // @09BF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616e6e6f74206368616e67652066696e616c697a652061667465722066696e // @09CF memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x30b634bd32b217 << 0xc9 // @09D2 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0541 label_09D7: // Incoming jump from 0x097F, if !(0xff & storage[0x0a] / 0x0100) // Inputs[3] // { // @09DB storage[0x0a] // @09DC stack[-1] // @09F0 stack[-2] // } 09D7 5B JUMPDEST 09D8 60 PUSH1 0x0a 09DA 80 DUP1 09DB 54 SLOAD 09DC 91 SWAP2 09DD 15 ISZERO 09DE 15 ISZERO 09DF 61 PUSH2 0x0100 09E2 02 MUL 09E3 61 PUSH2 0xff00 09E6 19 NOT 09E7 90 SWAP1 09E8 92 SWAP3 09E9 16 AND 09EA 91 SWAP2 09EB 90 SWAP1 09EC 91 SWAP2 09ED 17 OR 09EE 90 SWAP1 09EF 55 SSTORE 09F0 56 *JUMP // Stack delta = -2 // Outputs[1] { @09EF storage[0x0a] = (storage[0x0a] & ~0xff00) | 0x0100 * !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_09F1: // Incoming jump from 0x0314 // Inputs[4] // { // @09F5 stack[-3] // @09F6 stack[-2] // @09F7 stack[-1] // @09FA memory[0x40:0x60] // } 09F1 5B JUMPDEST 09F2 61 PUSH2 0x05bc 09F5 83 DUP4 09F6 83 DUP4 09F7 83 DUP4 09F8 60 PUSH1 0x40 09FA 51 MLOAD 09FB 80 DUP1 09FC 60 PUSH1 0x20 09FE 01 ADD 09FF 60 PUSH1 0x40 0A01 52 MSTORE 0A02 80 DUP1 0A03 60 PUSH1 0x00 0A05 81 DUP2 0A06 52 MSTORE 0A07 50 POP 0A08 61 PUSH2 0x1060 0A0B 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @09F2 stack[0] = 0x05bc // @09F5 stack[1] = stack[-3] // @09F6 stack[2] = stack[-2] // @09F7 stack[3] = stack[-1] // @09FA stack[4] = memory[0x40:0x60] // @0A01 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0A06 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x1060 label_0A0C: // Incoming jump from 0x0327 // Inputs[1] { @0A10 stack[-1] } 0A0C 5B JUMPDEST 0A0D 61 PUSH2 0x0a15 0A10 81 DUP2 0A11 61 PUSH2 0x17b7 0A14 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0A0D stack[0] = 0x0a15 // @0A10 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x17b7 label_0A15: // Incoming return from call to 0x19DA at 0x1435 // Incoming jump from 0x1E7F, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x1FA7, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0A17 stack[-2] } 0A15 5B JUMPDEST 0A16 50 POP 0A17 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0A18: // Incoming jump from 0x033A // Inputs[2] // { // @0A1B storage[0x00] // @0A25 msg.sender // } 0A18 5B JUMPDEST 0A19 60 PUSH1 0x00 0A1B 54 SLOAD 0A1C 60 PUSH1 0x01 0A1E 60 PUSH1 0x01 0A20 60 PUSH1 0xa0 0A22 1B SHL 0A23 03 SUB 0A24 16 AND 0A25 33 CALLER 0A26 14 EQ 0A27 61 PUSH2 0x0a42 0A2A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a42, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0A2B: // Incoming jump from 0x0A2A, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0A2D memory[0x40:0x60] } 0A2B 60 PUSH1 0x40 0A2D 51 MLOAD 0A2E 62 PUSH3 0x461bcd 0A32 60 PUSH1 0xe5 0A34 1B SHL 0A35 81 DUP2 0A36 52 MSTORE 0A37 60 PUSH1 0x04 0A39 01 ADD 0A3A 61 PUSH2 0x0541 0A3D 90 SWAP1 0A3E 61 PUSH2 0x234c 0A41 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A36 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A3D stack[0] = 0x0541 // @0A3D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x234c, returns to 0x0541 label_0A42: // Incoming jump from 0x0A2A, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[2] // { // @0A43 stack[-5] // @0A44 stack[-3] // } 0A42 5B JUMPDEST 0A43 84 DUP5 0A44 83 DUP4 0A45 14 EQ 0A46 80 DUP1 0A47 15 ISZERO 0A48 61 PUSH2 0x0a50 0A4B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A45 stack[0] = stack[-3] == stack[-5] } // Block ends with conditional jump to 0x0a50, if !(stack[-3] == stack[-5]) label_0A4C: // Incoming jump from 0x0A4B, if not !(stack[-3] == stack[-5]) // Inputs[2] // { // @0A4D stack[-4] // @0A4E stack[-2] // } 0A4C 50 POP 0A4D 82 DUP3 0A4E 81 DUP2 0A4F 14 EQ 0A50 5B JUMPDEST 0A51 61 PUSH2 0x0a93 0A54 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a93, if stack[-2] == stack[-4] label_0A55: // Incoming jump from 0x0A54, if not stack[-1] // Incoming jump from 0x0A54, if not stack[-2] == stack[-4] // Inputs[1] { @0A57 memory[0x40:0x60] } 0A55 60 PUSH1 0x40 0A57 51 MLOAD 0A58 62 PUSH3 0x461bcd 0A5C 60 PUSH1 0xe5 0A5E 1B SHL 0A5F 81 DUP2 0A60 52 MSTORE 0A61 60 PUSH1 0x20 0A63 60 PUSH1 0x04 0A65 82 DUP3 0A66 01 ADD 0A67 52 MSTORE 0A68 60 PUSH1 0x14 0A6A 60 PUSH1 0x24 0A6C 82 DUP3 0A6D 01 ADD 0A6E 52 MSTORE 0A6F 73 PUSH20 0x20b93930bcb9903237903737ba1036b0ba31b417 0A84 60 PUSH1 0x61 0A86 1B SHL 0A87 60 PUSH1 0x44 0A89 82 DUP3 0A8A 01 ADD 0A8B 52 MSTORE 0A8C 60 PUSH1 0x64 0A8E 01 ADD 0A8F 61 PUSH2 0x0541 0A92 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A60 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A67 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A6E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @0A8B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x20b93930bcb9903237903737ba1036b0ba31b417 << 0x61 // @0A8E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0541 label_0A93: // Incoming jump from 0x0A54, if stack[-1] // Incoming jump from 0x0A54, if stack[-2] == stack[-4] // Inputs[1] { @0A97 stack[-5] } 0A93 5B JUMPDEST 0A94 60 PUSH1 0x00 0A96 5B JUMPDEST 0A97 85 DUP6 0A98 81 DUP2 0A99 10 LT 0A9A 15 ISZERO 0A9B 61 PUSH2 0x0b84 0A9E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A94 stack[0] = 0x00 } // Block ends with conditional jump to 0x0b84, if !(0x00 < stack[-5]) label_0A9F: // Incoming jump from 0x0A9E, if not !(stack[-1] < stack[-6]) // Incoming jump from 0x0A9E, if not !(0x00 < stack[-5]) // Inputs[3] // { // @0AA4 stack[-7] // @0AA5 stack[-6] // @0AA6 stack[-1] // } 0A9F 60 PUSH1 0x00 0AA1 60 PUSH1 0x03 0AA3 81 DUP2 0AA4 89 DUP10 0AA5 89 DUP10 0AA6 85 DUP6 0AA7 81 DUP2 0AA8 81 DUP2 0AA9 10 LT 0AAA 61 PUSH2 0x0ab5 0AAD 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @0A9F stack[0] = 0x00 // @0AA1 stack[1] = 0x03 // @0AA3 stack[2] = 0x00 // @0AA4 stack[3] = stack[-7] // @0AA5 stack[4] = stack[-6] // @0AA6 stack[5] = stack[-1] // } // Block ends with conditional jump to 0x0ab5, if stack[-1] < stack[-6] label_0AAE: // Incoming jump from 0x0AAD, if not stack[-1] < stack[-6] 0AAE 61 PUSH2 0x0ab5 0AB1 61 PUSH2 0x2458 0AB4 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AAE stack[0] = 0x0ab5 } // Block ends with unconditional jump to 0x2458 label_0AB5: // Incoming jump from 0x0AAD, if stack[-1] < stack[-6] // Inputs[8] // { // @0AB8 stack[-1] // @0ABB stack[-3] // @0ABF msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0AC0 stack[-4] // @0AC5 stack[-5] // @0ACE memory[0x00:0x00 + 0x40 + stack[-4]] // @0ACF storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-4]])] // @0AD9 stack[-6] // } 0AB5 5B JUMPDEST 0AB6 60 PUSH1 0x20 0AB8 90 SWAP1 0AB9 81 DUP2 0ABA 02 MUL 0ABB 92 SWAP3 0ABC 90 SWAP1 0ABD 92 SWAP3 0ABE 01 ADD 0ABF 35 CALLDATALOAD 0AC0 83 DUP4 0AC1 52 MSTORE 0AC2 50 POP 0AC3 81 DUP2 0AC4 01 ADD 0AC5 91 SWAP2 0AC6 90 SWAP1 0AC7 91 SWAP2 0AC8 52 MSTORE 0AC9 60 PUSH1 0x40 0ACB 01 ADD 0ACC 60 PUSH1 0x00 0ACE 20 SHA3 0ACF 54 SLOAD 0AD0 60 PUSH1 0x01 0AD2 60 PUSH1 0x01 0AD4 60 PUSH1 0xa0 0AD6 1B SHL 0AD7 03 SUB 0AD8 16 AND 0AD9 14 EQ 0ADA 15 ISZERO 0ADB 61 PUSH2 0x0b72 0ADE 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0AC1 memory[stack[-4]:stack[-4] + 0x20] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0AC8 memory[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] = stack[-5] // } // Block ends with conditional jump to 0x0b72, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-4]])] == stack[-6]) label_0ADF: // Incoming jump from 0x0ADE, if not !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-4]])] == stack[-6]) // Inputs[3] // { // @0ADF stack[-7] // @0AE0 stack[-6] // @0AE1 stack[-1] // } 0ADF 86 DUP7 0AE0 86 DUP7 0AE1 82 DUP3 0AE2 81 DUP2 0AE3 81 DUP2 0AE4 10 LT 0AE5 61 PUSH2 0x0af0 0AE8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0ADF stack[0] = stack[-7] // @0AE0 stack[1] = stack[-6] // @0AE1 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x0af0, if stack[-1] < stack[-6] label_0AE9: // Incoming jump from 0x0AE8, if not stack[-1] < stack[-6] 0AE9 61 PUSH2 0x0af0 0AEC 61 PUSH2 0x2458 0AEF 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AE9 stack[0] = 0x0af0 } // Block ends with unconditional jump to 0x2458 label_0AF0: // Incoming jump from 0x0AE8, if stack[-1] < stack[-6] // Inputs[7] // { // @0AF1 stack[-1] // @0AF1 stack[-2] // @0AF6 stack[-3] // @0AF7 msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0AF8 stack[-6] // @0AF9 stack[-5] // @0AFA stack[-4] // } 0AF0 5B JUMPDEST 0AF1 90 SWAP1 0AF2 50 POP 0AF3 60 PUSH1 0x20 0AF5 02 MUL 0AF6 01 ADD 0AF7 35 CALLDATALOAD 0AF8 83 DUP4 0AF9 83 DUP4 0AFA 83 DUP4 0AFB 81 DUP2 0AFC 81 DUP2 0AFD 10 LT 0AFE 61 PUSH2 0x0b09 0B01 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0AF7 stack[-3] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0AF8 stack[-2] = stack[-6] // @0AF9 stack[-1] = stack[-5] // @0AFA stack[0] = stack[-4] // } // Block ends with conditional jump to 0x0b09, if stack[-4] < stack[-5] label_0B02: // Incoming jump from 0x0B01, if not stack[-4] < stack[-5] 0B02 61 PUSH2 0x0b09 0B05 61 PUSH2 0x2458 0B08 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B02 stack[0] = 0x0b09 } // Block ends with unconditional jump to 0x2458 label_0B09: // Incoming jump from 0x0B01, if stack[-4] < stack[-5] // Inputs[3] // { // @0B0A stack[-2] // @0B0A stack[-1] // @0B0F stack[-3] // } 0B09 5B JUMPDEST 0B0A 90 SWAP1 0B0B 50 POP 0B0C 60 PUSH1 0x20 0B0E 02 MUL 0B0F 01 ADD 0B10 60 PUSH1 0x20 0B12 81 DUP2 0B13 01 ADD 0B14 90 SWAP1 0B15 61 PUSH2 0x0b1e 0B18 91 SWAP2 0B19 90 SWAP1 0B1A 61 PUSH2 0x1fd8 0B1D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0B18 stack[-3] = 0x0b1e // @0B19 stack[-1] = 0x20 * stack[-1] + stack[-3] // @0B19 stack[-2] = 0x20 * stack[-1] + stack[-3] + 0x20 // } // Block ends with call to 0x1fd8, returns to 0x0B1E label_0B1E: // Incoming return from call to 0x1FD8 at 0x0B1D // Inputs[4] // { // @0B27 stack[-1] // @0B28 stack[-7] // @0B29 stack[-6] // @0B2A stack[-3] // } 0B1E 5B JUMPDEST 0B1F 60 PUSH1 0x01 0B21 60 PUSH1 0x01 0B23 60 PUSH1 0xa0 0B25 1B SHL 0B26 03 SUB 0B27 16 AND 0B28 86 DUP7 0B29 86 DUP7 0B2A 84 DUP5 0B2B 81 DUP2 0B2C 81 DUP2 0B2D 10 LT 0B2E 61 PUSH2 0x0b39 0B31 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @0B27 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0B28 stack[0] = stack[-7] // @0B29 stack[1] = stack[-6] // @0B2A stack[2] = stack[-3] // } // Block ends with conditional jump to 0x0b39, if stack[-3] < stack[-6] label_0B32: // Incoming jump from 0x0B31, if not stack[-3] < stack[-6] 0B32 61 PUSH2 0x0b39 0B35 61 PUSH2 0x2458 0B38 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B32 stack[0] = 0x0b39 } // Block ends with unconditional jump to 0x2458 label_0B39: // Incoming jump from 0x0B31, if stack[-3] < stack[-6] // Inputs[3] // { // @0B3A stack[-1] // @0B3A stack[-2] // @0B3F stack[-3] // } 0B39 5B JUMPDEST 0B3A 90 SWAP1 0B3B 50 POP 0B3C 60 PUSH1 0x20 0B3E 02 MUL 0B3F 01 ADD 0B40 60 PUSH1 0x20 0B42 81 DUP2 0B43 01 ADD 0B44 90 SWAP1 0B45 61 PUSH2 0x0b4e 0B48 91 SWAP2 0B49 90 SWAP1 0B4A 61 PUSH2 0x1fd8 0B4D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0B48 stack[-3] = 0x0b4e // @0B49 stack[-1] = 0x20 * stack[-1] + stack[-3] // @0B49 stack[-2] = 0x20 * stack[-1] + stack[-3] + 0x20 // } // Block ends with call to 0x1fd8, returns to 0x0B4E label_0B4E: // Incoming return from call to 0x1FD8 at 0x0B4D // Inputs[8] // { // @0B57 stack[-1] // @0B5B memory[0x00:0x20] // @0B64 memory[0x00:0x20] // @0B69 memory[0x40:0x60] // @0B6C memory[0x40:0x60] // @0B71 stack[-2] // @0B71 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0B71 stack[-3] // } 0B4E 5B JUMPDEST 0B4F 60 PUSH1 0x01 0B51 60 PUSH1 0x01 0B53 60 PUSH1 0xa0 0B55 1B SHL 0B56 03 SUB 0B57 16 AND 0B58 60 PUSH1 0x00 0B5A 80 DUP1 0B5B 51 MLOAD 0B5C 60 PUSH1 0x20 0B5E 61 PUSH2 0x2619 0B61 83 DUP4 0B62 39 CODECOPY 0B63 81 DUP2 0B64 51 MLOAD 0B65 91 SWAP2 0B66 52 MSTORE 0B67 60 PUSH1 0x40 0B69 51 MLOAD 0B6A 60 PUSH1 0x40 0B6C 51 MLOAD 0B6D 80 DUP1 0B6E 91 SWAP2 0B6F 03 SUB 0B70 90 SWAP1 0B71 A4 LOG4 // Stack delta = -3 // Outputs[3] // { // @0B62 memory[0x00:0x20] = code[0x2619:0x2639] // @0B66 memory[0x00:0x20] = memory[0x00:0x20] // @0B71 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [memory[0x00:0x20], stack[-1] & (0x01 << 0xa0) - 0x01, stack[-2], stack[-3]]); // } // Block continues label_0B72: // Incoming jump from 0x0ADE, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-4]])] == stack[-6]) // Incoming jump from 0x0B71 // Inputs[1] { @0B73 stack[-1] } 0B72 5B JUMPDEST 0B73 80 DUP1 0B74 61 PUSH2 0x0b7c 0B77 81 DUP2 0B78 61 PUSH2 0x2484 0B7B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B73 stack[0] = stack[-1] // @0B74 stack[1] = 0x0b7c // @0B77 stack[2] = stack[-1] // } // Block ends with call to 0x2484, returns to 0x0B7C label_0B7C: // Incoming return from call to 0x2484 at 0x0B7B // Inputs[2] // { // @0B7D stack[-1] // @0B7D stack[-3] // } 0B7C 5B JUMPDEST 0B7D 91 SWAP2 0B7E 50 POP 0B7F 50 POP 0B80 61 PUSH2 0x0a96 0B83 56 *JUMP // Stack delta = -2 // Outputs[1] { @0B7D stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0a96 label_0B84: // Incoming jump from 0x0A9E, if !(stack[-1] < stack[-6]) // Incoming jump from 0x0A9E, if !(0x00 < stack[-5]) // Inputs[1] { @0B8C stack[-8] } 0B84 5B JUMPDEST 0B85 50 POP 0B86 50 POP 0B87 50 POP 0B88 50 POP 0B89 50 POP 0B8A 50 POP 0B8B 50 POP 0B8C 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] label_0B8D: // Incoming jump from 0x034D // Inputs[1] { @0B93 stack[-1] } 0B8D 5B JUMPDEST 0B8E 60 PUSH1 0x00 0B90 61 PUSH2 0x2724 0B93 82 DUP3 0B94 11 GT 0B95 80 DUP1 0B96 61 PUSH2 0x0511 0B99 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0B8E stack[0] = 0x00 // @0B94 stack[1] = stack[-1] > 0x2724 // } // Block ends with conditional jump to 0x0511, if stack[-1] > 0x2724 label_0B9A: // Incoming jump from 0x0B99, if not stack[-1] > 0x2724 // Inputs[4] // { // @0B9E stack[-3] // @0BA9 memory[0x00:0x40] // @0BAA storage[keccak256(memory[0x00:0x40])] // @0BB6 stack[-4] // } 0B9A 50 POP 0B9B 50 POP 0B9C 60 PUSH1 0x00 0B9E 90 SWAP1 0B9F 81 DUP2 0BA0 52 MSTORE 0BA1 60 PUSH1 0x03 0BA3 60 PUSH1 0x20 0BA5 52 MSTORE 0BA6 60 PUSH1 0x40 0BA8 90 SWAP1 0BA9 20 SHA3 0BAA 54 SLOAD 0BAB 60 PUSH1 0x01 0BAD 60 PUSH1 0x01 0BAF 60 PUSH1 0xa0 0BB1 1B SHL 0BB2 03 SUB 0BB3 16 AND 0BB4 15 ISZERO 0BB5 15 ISZERO 0BB6 90 SWAP1 0BB7 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0BA0 memory[0x00:0x20] = stack[-3] // @0BA5 memory[0x20:0x40] = 0x03 // @0BB6 stack[-4] = !!((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-4] label_0BB8: // Incoming jump from 0x1611 // Incoming jump from 0x0F84 // Incoming jump from 0x06E5 // Incoming jump from 0x0369 // Incoming jump from 0x17C1 // Inputs[1] { @0BBF stack[-1] } 0BB8 5B JUMPDEST 0BB9 60 PUSH1 0x00 0BBB 80 DUP1 0BBC 61 PUSH2 0x0bc4 0BBF 83 DUP4 0BC0 61 PUSH2 0x188d 0BC3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0BB9 stack[0] = 0x00 // @0BBB stack[1] = 0x00 // @0BBC stack[2] = 0x0bc4 // @0BBF stack[3] = stack[-1] // } // Block ends with call to 0x188d, returns to 0x0000 0BC4 5B JUMPDEST 0BC5 90 SWAP1 0BC6 50 POP 0BC7 60 PUSH1 0x01 0BC9 60 PUSH1 0x01 0BCB 60 PUSH1 0xa0 0BCD 1B SHL 0BCE 03 SUB 0BCF 81 DUP2 0BD0 16 AND 0BD1 61 PUSH2 0x0511 0BD4 57 *JUMPI 0BD5 60 PUSH1 0x40 0BD7 51 MLOAD 0BD8 62 PUSH3 0x461bcd 0BDC 60 PUSH1 0xe5 0BDE 1B SHL 0BDF 81 DUP2 0BE0 52 MSTORE 0BE1 60 PUSH1 0x20 0BE3 60 PUSH1 0x04 0BE5 82 DUP3 0BE6 01 ADD 0BE7 52 MSTORE 0BE8 60 PUSH1 0x29 0BEA 60 PUSH1 0x24 0BEC 82 DUP3 0BED 01 ADD 0BEE 52 MSTORE 0BEF 7F PUSH32 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 0C10 60 PUSH1 0x44 0C12 82 DUP3 0C13 01 ADD 0C14 52 MSTORE 0C15 68 PUSH9 0x32b73a103a37b5b2b7 0C1F 60 PUSH1 0xb9 0C21 1B SHL 0C22 60 PUSH1 0x64 0C24 82 DUP3 0C25 01 ADD 0C26 52 MSTORE 0C27 60 PUSH1 0x84 0C29 01 ADD 0C2A 61 PUSH2 0x0541 0C2D 56 *JUMP label_0C2E: // Incoming jump from 0x037C // Inputs[1] { @0C39 stack[-1] } 0C2E 5B JUMPDEST 0C2F 60 PUSH1 0x00 0C31 60 PUSH1 0x01 0C33 60 PUSH1 0x01 0C35 60 PUSH1 0xa0 0C37 1B SHL 0C38 03 SUB 0C39 82 DUP3 0C3A 16 AND 0C3B 61 PUSH2 0x0c99 0C3E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C2F stack[0] = 0x00 } // Block ends with conditional jump to 0x0c99, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0C3F: // Incoming jump from 0x0C3E, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0C41 memory[0x40:0x60] } 0C3F 60 PUSH1 0x40 0C41 51 MLOAD 0C42 62 PUSH3 0x461bcd 0C46 60 PUSH1 0xe5 0C48 1B SHL 0C49 81 DUP2 0C4A 52 MSTORE 0C4B 60 PUSH1 0x20 0C4D 60 PUSH1 0x04 0C4F 82 DUP3 0C50 01 ADD 0C51 52 MSTORE 0C52 60 PUSH1 0x2a 0C54 60 PUSH1 0x24 0C56 82 DUP3 0C57 01 ADD 0C58 52 MSTORE 0C59 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 0C7A 60 PUSH1 0x44 0C7C 82 DUP3 0C7D 01 ADD 0C7E 52 MSTORE 0C7F 69 PUSH10 0x726f2061646472657373 0C8A 60 PUSH1 0xb0 0C8C 1B SHL 0C8D 60 PUSH1 0x64 0C8F 82 DUP3 0C90 01 ADD 0C91 52 MSTORE 0C92 60 PUSH1 0x84 0C94 01 ADD 0C95 61 PUSH2 0x0541 0C98 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0C4A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C51 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C58 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @0C7E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 // @0C91 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x726f2061646472657373 << 0xb0 // @0C94 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0541 label_0C99: // Incoming jump from 0x0C3E, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0CA0 storage[0x09] } 0C99 5B JUMPDEST 0C9A 60 PUSH1 0x00 0C9C 80 DUP1 0C9D 5B JUMPDEST 0C9E 60 PUSH1 0x09 0CA0 54 SLOAD 0CA1 81 DUP2 0CA2 11 GT 0CA3 61 PUSH2 0x0ce8 0CA6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0C9A stack[0] = 0x00 // @0C9C stack[1] = 0x00 // } // Block ends with conditional jump to 0x0ce8, if 0x00 > storage[0x09] label_0CA7: // Incoming jump from 0x0CA6, if not 0x00 > storage[0x09] // Inputs[2] // { // @0CA7 stack[-4] // @0CB4 stack[-1] // } 0CA7 83 DUP4 0CA8 60 PUSH1 0x01 0CAA 60 PUSH1 0x01 0CAC 60 PUSH1 0xa0 0CAE 1B SHL 0CAF 03 SUB 0CB0 16 AND 0CB1 61 PUSH2 0x0cb9 0CB4 82 DUP3 0CB5 61 PUSH2 0x188d 0CB8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CB0 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-4] // @0CB1 stack[1] = 0x0cb9 // @0CB4 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x188d 0CB9 5B JUMPDEST 0CBA 60 PUSH1 0x01 0CBC 60 PUSH1 0x01 0CBE 60 PUSH1 0xa0 0CC0 1B SHL 0CC1 03 SUB 0CC2 16 AND 0CC3 14 EQ 0CC4 15 ISZERO 0CC5 61 PUSH2 0x0cd6 0CC8 57 *JUMPI 0CC9 81 DUP2 0CCA 61 PUSH2 0x0cd2 0CCD 81 DUP2 0CCE 61 PUSH2 0x2484 0CD1 56 *JUMP 0CD2 5B JUMPDEST 0CD3 92 SWAP3 0CD4 50 POP 0CD5 50 POP 0CD6 5B JUMPDEST 0CD7 80 DUP1 0CD8 61 PUSH2 0x0ce0 0CDB 81 DUP2 0CDC 61 PUSH2 0x2484 0CDF 56 *JUMP 0CE0 5B JUMPDEST 0CE1 91 SWAP2 0CE2 50 POP 0CE3 50 POP 0CE4 61 PUSH2 0x0c9d 0CE7 56 *JUMP label_0CE8: // Incoming jump from 0x0CA6, if 0x00 > storage[0x09] // Inputs[3] // { // @0CEA stack[-5] // @0CEA stack[-2] // @0CEB stack[-4] // } 0CE8 5B JUMPDEST 0CE9 50 POP 0CEA 92 SWAP3 0CEB 91 SWAP2 0CEC 50 POP 0CED 50 POP 0CEE 56 *JUMP // Stack delta = -4 // Outputs[1] { @0CEA stack[-5] = stack[-2] } // Block ends with unconditional jump to stack[-5] label_0CEF: // Incoming call from 0x0384, returns to 0x0246 // Inputs[2] // { // @0CF2 storage[0x00] // @0CFC msg.sender // } 0CEF 5B JUMPDEST 0CF0 60 PUSH1 0x00 0CF2 54 SLOAD 0CF3 60 PUSH1 0x01 0CF5 60 PUSH1 0x01 0CF7 60 PUSH1 0xa0 0CF9 1B SHL 0CFA 03 SUB 0CFB 16 AND 0CFC 33 CALLER 0CFD 14 EQ 0CFE 61 PUSH2 0x0d19 0D01 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d19, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0D02: // Incoming jump from 0x0D01, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0D04 memory[0x40:0x60] } 0D02 60 PUSH1 0x40 0D04 51 MLOAD 0D05 62 PUSH3 0x461bcd 0D09 60 PUSH1 0xe5 0D0B 1B SHL 0D0C 81 DUP2 0D0D 52 MSTORE 0D0E 60 PUSH1 0x04 0D10 01 ADD 0D11 61 PUSH2 0x0541 0D14 90 SWAP1 0D15 61 PUSH2 0x234c 0D18 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D0D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D14 stack[0] = 0x0541 // @0D14 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x234c, returns to 0x0541 label_0D19: // Incoming jump from 0x0D01, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] 0D19 5B JUMPDEST 0D1A 61 PUSH2 0x0d23 0D1D 60 PUSH1 0x00 0D1F 61 PUSH2 0x19da 0D22 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D1A stack[0] = 0x0d23 // @0D1D stack[1] = 0x00 // } // Block ends with call to 0x19da, returns to 0x0D23 label_0D23: // Incoming return from call to 0x19DA at 0x0D22 // Inputs[1] { @0D24 stack[-1] } 0D23 5B JUMPDEST 0D24 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0D25: // Incoming jump from 0x0397 // Inputs[2] // { // @0D28 storage[0x00] // @0D32 msg.sender // } 0D25 5B JUMPDEST 0D26 60 PUSH1 0x00 0D28 54 SLOAD 0D29 60 PUSH1 0x01 0D2B 60 PUSH1 0x01 0D2D 60 PUSH1 0xa0 0D2F 1B SHL 0D30 03 SUB 0D31 16 AND 0D32 33 CALLER 0D33 14 EQ 0D34 61 PUSH2 0x0d4f 0D37 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d4f, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0D38: // Incoming jump from 0x0D37, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0D3A memory[0x40:0x60] } 0D38 60 PUSH1 0x40 0D3A 51 MLOAD 0D3B 62 PUSH3 0x461bcd 0D3F 60 PUSH1 0xe5 0D41 1B SHL 0D42 81 DUP2 0D43 52 MSTORE 0D44 60 PUSH1 0x04 0D46 01 ADD 0D47 61 PUSH2 0x0541 0D4A 90 SWAP1 0D4B 61 PUSH2 0x234c 0D4E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D43 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D4A stack[0] = 0x0541 // @0D4A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x234c, returns to 0x0541 label_0D4F: // Incoming jump from 0x0D37, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0D52 storage[0x0a] } 0D4F 5B JUMPDEST 0D50 60 PUSH1 0x0a 0D52 54 SLOAD 0D53 61 PUSH2 0x0100 0D56 90 SWAP1 0D57 04 DIV 0D58 60 PUSH1 0xff 0D5A 16 AND 0D5B 15 ISZERO 0D5C 61 PUSH2 0x0da7 0D5F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0da7, if !(0xff & storage[0x0a] / 0x0100) label_0D60: // Incoming jump from 0x0D5F, if not !(0xff & storage[0x0a] / 0x0100) // Inputs[1] { @0D62 memory[0x40:0x60] } 0D60 60 PUSH1 0x40 0D62 51 MLOAD 0D63 62 PUSH3 0x461bcd 0D67 60 PUSH1 0xe5 0D69 1B SHL 0D6A 81 DUP2 0D6B 52 MSTORE 0D6C 60 PUSH1 0x20 0D6E 60 PUSH1 0x04 0D70 82 DUP3 0D71 01 ADD 0D72 52 MSTORE 0D73 60 PUSH1 0x1f 0D75 60 PUSH1 0x24 0D77 82 DUP3 0D78 01 ADD 0D79 52 MSTORE 0D7A 7F PUSH32 0x43616e6e6f742061697264726f702061667465722066696e616c697a65642e00 0D9B 60 PUSH1 0x44 0D9D 82 DUP3 0D9E 01 ADD 0D9F 52 MSTORE 0DA0 60 PUSH1 0x64 0DA2 01 ADD 0DA3 61 PUSH2 0x0541 0DA6 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0D6B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D72 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D79 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @0D9F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616e6e6f742061697264726f702061667465722066696e616c697a65642e00 // @0DA2 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0541 label_0DA7: // Incoming jump from 0x0D5F, if !(0xff & storage[0x0a] / 0x0100) // Inputs[2] // { // @0DAA storage[0x08] // @0DB1 stack[-1] // } 0DA7 5B JUMPDEST 0DA8 60 PUSH1 0x08 0DAA 54 SLOAD 0DAB 61 PUSH2 0x3aad 0DAE 61 PUSH2 0x0db7 0DB1 83 DUP4 0DB2 83 DUP4 0DB3 61 PUSH2 0x249f 0DB6 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0DAA stack[0] = storage[0x08] // @0DAB stack[1] = 0x3aad // @0DAE stack[2] = 0x0db7 // @0DB1 stack[3] = stack[-1] // @0DB2 stack[4] = storage[0x08] // } // Block ends with call to 0x249f, returns to 0x0DB7 label_0DB7: // Incoming return from call to 0x249F at 0x0DB6 // Inputs[2] // { // @0DB8 stack[-1] // @0DB8 stack[-2] // } 0DB7 5B JUMPDEST 0DB8 11 GT 0DB9 15 ISZERO 0DBA 61 PUSH2 0x0e11 0DBD 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0e11, if !(stack[-1] > stack[-2]) label_0DBE: // Incoming jump from 0x0DBD, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0DC0 memory[0x40:0x60] } 0DBE 60 PUSH1 0x40 0DC0 51 MLOAD 0DC1 62 PUSH3 0x461bcd 0DC5 60 PUSH1 0xe5 0DC7 1B SHL 0DC8 81 DUP2 0DC9 52 MSTORE 0DCA 60 PUSH1 0x20 0DCC 60 PUSH1 0x04 0DCE 82 DUP3 0DCF 01 ADD 0DD0 52 MSTORE 0DD1 60 PUSH1 0x24 0DD3 80 DUP1 0DD4 82 DUP3 0DD5 01 ADD 0DD6 52 MSTORE 0DD7 7F PUSH32 0x43616e6e6f742061697264726f70206d6f7265207468616e206d617820737570 0DF8 60 PUSH1 0x44 0DFA 82 DUP3 0DFB 01 ADD 0DFC 52 MSTORE 0DFD 63 PUSH4 0x38363c97 0E02 60 PUSH1 0xe1 0E04 1B SHL 0E05 60 PUSH1 0x64 0E07 82 DUP3 0E08 01 ADD 0E09 52 MSTORE 0E0A 60 PUSH1 0x84 0E0C 01 ADD 0E0D 61 PUSH2 0x0541 0E10 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0DC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DD0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DD6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @0DFC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616e6e6f742061697264726f70206d6f7265207468616e206d617820737570 // @0E09 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x38363c97 << 0xe1 // @0E0C stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0541 label_0E11: // Incoming jump from 0x0DBD, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @0E15 stack[-2] // @0E16 stack[-1] // } 0E11 5B JUMPDEST 0E12 61 PUSH2 0x0e1b 0E15 82 DUP3 0E16 82 DUP3 0E17 61 PUSH2 0x249f 0E1A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E12 stack[0] = 0x0e1b // @0E15 stack[1] = stack[-2] // @0E16 stack[2] = stack[-1] // } // Block ends with call to 0x249f, returns to 0x0E1B label_0E1B: // Incoming return from call to 0x249F at 0x0E1A // Inputs[2] // { // @0E1E stack[-1] // @0E22 stack[-3] // } 0E1B 5B JUMPDEST 0E1C 60 PUSH1 0x08 0E1E 55 SSTORE 0E1F 60 PUSH1 0x00 0E21 5B JUMPDEST 0E22 82 DUP3 0E23 81 DUP2 0E24 10 LT 0E25 15 ISZERO 0E26 61 PUSH2 0x0e74 0E29 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0E1E storage[0x08] = stack[-1] // @0E1F stack[-1] = 0x00 // } // Block ends with conditional jump to 0x0e74, if !(0x00 < stack[-3]) label_0E2A: // Incoming jump from 0x0E29, if not !(0x00 < stack[-3]) // Incoming jump from 0x0E29, if not !(stack[-1] < stack[-3]) // Inputs[3] // { // @0E2D stack[-4] // @0E2E stack[-3] // @0E2F stack[-1] // } 0E2A 61 PUSH2 0x0e62 0E2D 84 DUP5 0E2E 84 DUP5 0E2F 83 DUP4 0E30 81 DUP2 0E31 81 DUP2 0E32 10 LT 0E33 61 PUSH2 0x0e3e 0E36 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0E2A stack[0] = 0x0e62 // @0E2D stack[1] = stack[-4] // @0E2E stack[2] = stack[-3] // @0E2F stack[3] = stack[-1] // } // Block ends with conditional call to 0x0e3e, returns to 0x0E62, if stack[-1] < stack[-3] label_0E37: // Incoming jump from 0x0E36, if not stack[-1] < stack[-3] 0E37 61 PUSH2 0x0e3e 0E3A 61 PUSH2 0x2458 0E3D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E37 stack[0] = 0x0e3e } // Block ends with unconditional jump to 0x2458 label_0E3E: // Incoming call from 0x0E36, returns to 0x0E62, if stack[-1] < stack[-3] // Inputs[3] // { // @0E3F stack[-2] // @0E3F stack[-1] // @0E44 stack[-3] // } 0E3E 5B JUMPDEST 0E3F 90 SWAP1 0E40 50 POP 0E41 60 PUSH1 0x20 0E43 02 MUL 0E44 01 ADD 0E45 60 PUSH1 0x20 0E47 81 DUP2 0E48 01 ADD 0E49 90 SWAP1 0E4A 61 PUSH2 0x0e53 0E4D 91 SWAP2 0E4E 90 SWAP1 0E4F 61 PUSH2 0x1fd8 0E52 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0E4D stack[-3] = 0x0e53 // @0E4E stack[-1] = 0x20 * stack[-1] + stack[-3] // @0E4E stack[-2] = 0x20 * stack[-1] + stack[-3] + 0x20 // } // Block ends with call to 0x1fd8, returns to 0x0E53 label_0E53: // Incoming return from call to 0x1FD8 at 0x0E52 // Inputs[2] // { // @0E57 stack[-3] // @0E58 stack[-4] // } 0E53 5B JUMPDEST 0E54 61 PUSH2 0x0e5d 0E57 83 DUP4 0E58 85 DUP6 0E59 61 PUSH2 0x249f 0E5C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E54 stack[0] = 0x0e5d // @0E57 stack[1] = stack[-3] // @0E58 stack[2] = stack[-4] // } // Block ends with call to 0x249f, returns to 0x0E5D label_0E5D: // Incoming return from call to 0x249F at 0x0E5C 0E5D 5B JUMPDEST 0E5E 61 PUSH2 0x1a2a 0E61 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1a2a label_0E62: // Incoming return from call to 0x0E3E at 0x0E36 // Inputs[1] { @0E63 stack[-1] } 0E62 5B JUMPDEST 0E63 80 DUP1 0E64 61 PUSH2 0x0e6c 0E67 81 DUP2 0E68 61 PUSH2 0x2484 0E6B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E63 stack[0] = stack[-1] // @0E64 stack[1] = 0x0e6c // @0E67 stack[2] = stack[-1] // } // Block ends with call to 0x2484, returns to 0x0E6C label_0E6C: // Incoming return from call to 0x2484 at 0x0E6B // Inputs[2] // { // @0E6D stack[-3] // @0E6D stack[-1] // } 0E6C 5B JUMPDEST 0E6D 91 SWAP2 0E6E 50 POP 0E6F 50 POP 0E70 61 PUSH2 0x0e21 0E73 56 *JUMP // Stack delta = -2 // Outputs[1] { @0E6D stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0e21 label_0E74: // Incoming jump from 0x0E29, if !(0x00 < stack[-3]) // Incoming jump from 0x0E29, if !(stack[-1] < stack[-3]) // Inputs[3] // { // @0E78 storage[0x09] // @0E7E stack[-3] // @0E7F stack[-2] // } 0E74 5B JUMPDEST 0E75 50 POP 0E76 60 PUSH1 0x09 0E78 54 SLOAD 0E79 60 PUSH1 0x01 0E7B 61 PUSH2 0x0e84 0E7E 84 DUP5 0E7F 84 DUP5 0E80 61 PUSH2 0x249f 0E83 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0E78 stack[-1] = storage[0x09] // @0E79 stack[0] = 0x01 // @0E7B stack[1] = 0x0e84 // @0E7E stack[2] = stack[-3] // @0E7F stack[3] = stack[-2] // } // Block ends with call to 0x249f, returns to 0x0E84 label_0E84: // Incoming return from call to 0x249F at 0x0E83 // Inputs[2] // { // @0E88 stack[-2] // @0E89 stack[-1] // } 0E84 5B JUMPDEST 0E85 61 PUSH2 0x0e8e 0E88 91 SWAP2 0E89 90 SWAP1 0E8A 61 PUSH2 0x24b7 0E8D 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0E88 stack[-2] = 0x0e8e // @0E89 stack[-1] = stack[-2] // @0E89 stack[0] = stack[-1] // } // Block ends with call to 0x24b7, returns to 0x0E8E label_0E8E: // Incoming return from call to 0x24B7 at 0x0E8D // Inputs[2] // { // @0E8F stack[-2] // @0E8F stack[-1] // } 0E8E 5B JUMPDEST 0E8F 11 GT 0E90 15 ISZERO 0E91 61 PUSH2 0x05bc 0E94 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x05bc, if !(stack[-1] > stack[-2]) label_0E95: // Incoming jump from 0x0E94, if not !(stack[-1] > stack[-2]) // Inputs[2] // { // @0E9A stack[-2] // @0E9B stack[-1] // } 0E95 60 PUSH1 0x01 0E97 61 PUSH2 0x0ea0 0E9A 83 DUP4 0E9B 83 DUP4 0E9C 61 PUSH2 0x249f 0E9F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E95 stack[0] = 0x01 // @0E97 stack[1] = 0x0ea0 // @0E9A stack[2] = stack[-2] // @0E9B stack[3] = stack[-1] // } // Block ends with call to 0x249f, returns to 0x0EA0 label_0EA0: // Incoming return from call to 0x249F at 0x0E9F // Inputs[2] // { // @0EA4 stack[-2] // @0EA5 stack[-1] // } 0EA0 5B JUMPDEST 0EA1 61 PUSH2 0x0eaa 0EA4 91 SWAP2 0EA5 90 SWAP1 0EA6 61 PUSH2 0x24b7 0EA9 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0EA4 stack[-2] = 0x0eaa // @0EA5 stack[-1] = stack[-2] // @0EA5 stack[0] = stack[-1] // } // Block ends with call to 0x24b7, returns to 0x0EAA label_0EAA: // Incoming return from call to 0x24B7 at 0x0EA9 // Inputs[2] // { // @0EAD stack[-1] // @0EB1 stack[-5] // } 0EAA 5B JUMPDEST 0EAB 60 PUSH1 0x09 0EAD 55 SSTORE 0EAE 50 POP 0EAF 50 POP 0EB0 50 POP 0EB1 56 *JUMP // Stack delta = -5 // Outputs[1] { @0EAD storage[0x09] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0EB2: // Incoming jump from 0x03CF // Inputs[2] // { // @0EB5 storage[0x00] // @0EBF msg.sender // } 0EB2 5B JUMPDEST 0EB3 60 PUSH1 0x00 0EB5 54 SLOAD 0EB6 60 PUSH1 0x01 0EB8 60 PUSH1 0x01 0EBA 60 PUSH1 0xa0 0EBC 1B SHL 0EBD 03 SUB 0EBE 16 AND 0EBF 33 CALLER 0EC0 14 EQ 0EC1 61 PUSH2 0x0edc 0EC4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0edc, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0EC5: // Incoming jump from 0x0EC4, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0EC7 memory[0x40:0x60] } 0EC5 60 PUSH1 0x40 0EC7 51 MLOAD 0EC8 62 PUSH3 0x461bcd 0ECC 60 PUSH1 0xe5 0ECE 1B SHL 0ECF 81 DUP2 0ED0 52 MSTORE 0ED1 60 PUSH1 0x04 0ED3 01 ADD 0ED4 61 PUSH2 0x0541 0ED7 90 SWAP1 0ED8 61 PUSH2 0x234c 0EDB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0ED0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0ED7 stack[0] = 0x0541 // @0ED7 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x234c, returns to 0x0541 label_0EDC: // Incoming jump from 0x0EC4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0EDF storage[0x0a] } 0EDC 5B JUMPDEST 0EDD 60 PUSH1 0x0a 0EDF 54 SLOAD 0EE0 61 PUSH2 0x0100 0EE3 90 SWAP1 0EE4 04 DIV 0EE5 60 PUSH1 0xff 0EE7 16 AND 0EE8 15 ISZERO 0EE9 61 PUSH2 0x0f04 0EEC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f04, if !(0xff & storage[0x0a] / 0x0100) label_0EED: // Incoming jump from 0x0EEC, if not !(0xff & storage[0x0a] / 0x0100) // Inputs[1] { @0EEF memory[0x40:0x60] } 0EED 60 PUSH1 0x40 0EEF 51 MLOAD 0EF0 62 PUSH3 0x461bcd 0EF4 60 PUSH1 0xe5 0EF6 1B SHL 0EF7 81 DUP2 0EF8 52 MSTORE 0EF9 60 PUSH1 0x04 0EFB 01 ADD 0EFC 61 PUSH2 0x0541 0EFF 90 SWAP1 0F00 61 PUSH2 0x23bc 0F03 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0EF8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EFF stack[0] = 0x0541 // @0EFF stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x23bc, returns to 0x0541 label_0F04: // Incoming jump from 0x0EEC, if !(0xff & storage[0x0a] / 0x0100) // Inputs[4] // { // @0F08 storage[0x0b] // @0F12 stack[-1] // @0F28 storage[0x0d] // @0F2F stack[-2] // } 0F04 5B JUMPDEST 0F05 60 PUSH1 0x0b 0F07 80 DUP1 0F08 54 SLOAD 0F09 60 PUSH1 0x01 0F0B 60 PUSH1 0x01 0F0D 60 PUSH1 0xa0 0F0F 1B SHL 0F10 03 SUB 0F11 90 SWAP1 0F12 92 SWAP3 0F13 16 AND 0F14 60 PUSH1 0x01 0F16 60 PUSH1 0x01 0F18 60 PUSH1 0xa0 0F1A 1B SHL 0F1B 03 SUB 0F1C 19 NOT 0F1D 92 SWAP3 0F1E 83 DUP4 0F1F 16 AND 0F20 81 DUP2 0F21 17 OR 0F22 90 SWAP1 0F23 91 SWAP2 0F24 55 SSTORE 0F25 60 PUSH1 0x0d 0F27 80 DUP1 0F28 54 SLOAD 0F29 90 SWAP1 0F2A 92 SWAP3 0F2B 16 AND 0F2C 17 OR 0F2D 90 SWAP1 0F2E 55 SSTORE 0F2F 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0F24 storage[0x0b] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[0x0b]) // @0F2E storage[0x0d] = (~((0x01 << 0xa0) - 0x01) & storage[0x0d]) | (stack[-1] & (0x01 << 0xa0) - 0x01) // } // Block ends with unconditional jump to stack[-2] label_0F30: // Incoming call from 0x03D7, returns to 0x0250 // Inputs[1] { @0F36 storage[0x02] } 0F30 5B JUMPDEST 0F31 60 PUSH1 0x60 0F33 60 PUSH1 0x02 0F35 80 DUP1 0F36 54 SLOAD 0F37 61 PUSH2 0x05d0 0F3A 90 SWAP1 0F3B 61 PUSH2 0x2381 0F3E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F31 stack[0] = 0x60 // @0F33 stack[1] = 0x02 // @0F3A stack[2] = 0x05d0 // @0F3A stack[3] = storage[0x02] // } // Block ends with call to 0x2381, returns to 0x05D0 label_0F3F: // Incoming jump from 0x03EA // Inputs[2] // { // @0F47 storage[0x00] // @0F51 msg.sender // } 0F3F 5B JUMPDEST 0F40 60 PUSH1 0x00 0F42 61 PUSH2 0x0f55 0F45 60 PUSH1 0x00 0F47 54 SLOAD 0F48 60 PUSH1 0x01 0F4A 60 PUSH1 0x01 0F4C 60 PUSH1 0xa0 0F4E 1B SHL 0F4F 03 SUB 0F50 16 AND 0F51 33 CALLER 0F52 14 EQ 0F53 90 SWAP1 0F54 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0F40 stack[0] = 0x00 // @0F53 stack[1] = msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // } // Block ends with unconditional jump to 0x0f55 label_0F55: // Incoming jump from 0x0F54 // Inputs[3] // { // @0F56 stack[-1] // @0F56 stack[-2] // @0F5B stack[-3] // } 0F55 5B JUMPDEST 0F56 90 SWAP1 0F57 50 POP 0F58 60 PUSH1 0x00 0F5A 5B JUMPDEST 0F5B 82 DUP3 0F5C 81 DUP2 0F5D 10 LT 0F5E 15 ISZERO 0F5F 61 PUSH2 0x104b 0F62 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0F56 stack[-2] = stack[-1] // @0F58 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x104b, if !(0x00 < stack[-3]) label_0F63: // Incoming jump from 0x0F62, if not !(0x00 < stack[-3]) // Inputs[3] // { // @0F68 stack[-4] // @0F69 stack[-3] // @0F6A stack[-1] // } 0F63 60 PUSH1 0x00 0F65 61 PUSH2 0x0f85 0F68 85 DUP6 0F69 85 DUP6 0F6A 84 DUP5 0F6B 81 DUP2 0F6C 81 DUP2 0F6D 10 LT 0F6E 61 PUSH2 0x0f79 0F71 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @0F63 stack[0] = 0x00 // @0F65 stack[1] = 0x0f85 // @0F68 stack[2] = stack[-4] // @0F69 stack[3] = stack[-3] // @0F6A stack[4] = stack[-1] // } // Block ends with conditional jump to 0x0f79, if stack[-1] < stack[-3] label_0F72: // Incoming jump from 0x0F71, if not stack[-1] < stack[-3] 0F72 61 PUSH2 0x0f79 0F75 61 PUSH2 0x2458 0F78 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F72 stack[0] = 0x0f79 } // Block ends with unconditional jump to 0x2458 label_0F79: // Incoming jump from 0x0F71, if stack[-1] < stack[-3] // Inputs[4] // { // @0F7A stack[-1] // @0F7A stack[-2] // @0F7F stack[-3] // @0F80 msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // } 0F79 5B JUMPDEST 0F7A 90 SWAP1 0F7B 50 POP 0F7C 60 PUSH1 0x20 0F7E 02 MUL 0F7F 01 ADD 0F80 35 CALLDATALOAD 0F81 61 PUSH2 0x0bb8 0F84 56 *JUMP // Stack delta = -2 // Outputs[1] { @0F80 stack[-3] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] } // Block ends with unconditional jump to 0x0bb8 0F85 5B JUMPDEST 0F86 90 SWAP1 0F87 50 POP 0F88 60 PUSH1 0x01 0F8A 60 PUSH1 0x01 0F8C 60 PUSH1 0xa0 0F8E 1B SHL 0F8F 03 SUB 0F90 81 DUP2 0F91 16 AND 0F92 33 CALLER 0F93 14 EQ 0F94 80 DUP1 0F95 61 PUSH2 0x0f9b 0F98 57 *JUMPI 0F99 50 POP 0F9A 82 DUP3 0F9B 5B JUMPDEST 0F9C 61 PUSH2 0x0fe7 0F9F 57 *JUMPI 0FA0 60 PUSH1 0x40 0FA2 51 MLOAD 0FA3 62 PUSH3 0x461bcd 0FA7 60 PUSH1 0xe5 0FA9 1B SHL 0FAA 81 DUP2 0FAB 52 MSTORE 0FAC 60 PUSH1 0x20 0FAE 60 PUSH1 0x04 0FB0 82 DUP3 0FB1 01 ADD 0FB2 52 MSTORE 0FB3 60 PUSH1 0x1c 0FB5 60 PUSH1 0x24 0FB7 82 DUP3 0FB8 01 ADD 0FB9 52 MSTORE 0FBA 7F PUSH32 0x4d757374206f776e20746f6b656e20746f206269667572636174652e00000000 0FDB 60 PUSH1 0x44 0FDD 82 DUP3 0FDE 01 ADD 0FDF 52 MSTORE 0FE0 60 PUSH1 0x64 0FE2 01 ADD 0FE3 61 PUSH2 0x0541 0FE6 56 *JUMP 0FE7 5B JUMPDEST 0FE8 80 DUP1 0FE9 60 PUSH1 0x03 0FEB 60 PUSH1 0x00 0FED 87 DUP8 0FEE 87 DUP8 0FEF 86 DUP7 0FF0 81 DUP2 0FF1 81 DUP2 0FF2 10 LT 0FF3 61 PUSH2 0x0ffe 0FF6 57 *JUMPI 0FF7 61 PUSH2 0x0ffe 0FFA 61 PUSH2 0x2458 0FFD 56 *JUMP 0FFE 5B JUMPDEST 0FFF 90 SWAP1 1000 50 POP 1001 60 PUSH1 0x20 1003 02 MUL 1004 01 ADD 1005 35 CALLDATALOAD 1006 81 DUP2 1007 52 MSTORE 1008 60 PUSH1 0x20 100A 01 ADD 100B 90 SWAP1 100C 81 DUP2 100D 52 MSTORE 100E 60 PUSH1 0x20 1010 01 ADD 1011 60 PUSH1 0x00 1013 20 SHA3 1014 60 PUSH1 0x00 1016 61 PUSH2 0x0100 1019 0A EXP 101A 81 DUP2 101B 54 SLOAD 101C 81 DUP2 101D 60 PUSH1 0x01 101F 60 PUSH1 0x01 1021 60 PUSH1 0xa0 1023 1B SHL 1024 03 SUB 1025 02 MUL 1026 19 NOT 1027 16 AND 1028 90 SWAP1 1029 83 DUP4 102A 60 PUSH1 0x01 102C 60 PUSH1 0x01 102E 60 PUSH1 0xa0 1030 1B SHL 1031 03 SUB 1032 16 AND 1033 02 MUL 1034 17 OR 1035 90 SWAP1 1036 55 SSTORE 1037 50 POP 1038 50 POP 1039 80 DUP1 103A 80 DUP1 103B 61 PUSH2 0x1043 103E 90 SWAP1 103F 61 PUSH2 0x2484 1042 56 *JUMP 1043 5B JUMPDEST 1044 91 SWAP2 1045 50 POP 1046 50 POP 1047 61 PUSH2 0x0f5a 104A 56 *JUMP label_104B: // Incoming jump from 0x0F62, if !(0x00 < stack[-3]) // Incoming jump from 0x1F36, if !(stack[-1] > stack[-4]) // Inputs[1] { @1050 stack[-5] } 104B 5B JUMPDEST 104C 50 POP 104D 50 POP 104E 50 POP 104F 50 POP 1050 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_1051: // Incoming jump from 0x03FD // Inputs[3] // { // @1055 msg.sender // @1056 stack[-2] // @1057 stack[-1] // } 1051 5B JUMPDEST 1052 61 PUSH2 0x105c 1055 33 CALLER 1056 83 DUP4 1057 83 DUP4 1058 61 PUSH2 0x1a54 105B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1052 stack[0] = 0x105c // @1055 stack[1] = msg.sender // @1056 stack[2] = stack[-2] // @1057 stack[3] = stack[-1] // } // Block ends with call to 0x1a54, returns to 0x105C label_105C: // Incoming return from call to 0x1A54 at 0x105B // Incoming jump from 0x1371, if !!((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x1371, if !stack[-1] // Inputs[1] { @105F stack[-3] } 105C 5B JUMPDEST 105D 50 POP 105E 50 POP 105F 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1060: // Incoming jump from 0x0410 // Incoming jump from 0x0A0B // Inputs[2] // { // @1064 msg.sender // @1065 stack[-2] // } 1060 5B JUMPDEST 1061 61 PUSH2 0x106a 1064 33 CALLER 1065 83 DUP4 1066 61 PUSH2 0x1606 1069 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1061 stack[0] = 0x106a // @1064 stack[1] = msg.sender // @1065 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x1606 106A 5B JUMPDEST 106B 61 PUSH2 0x1086 106E 57 *JUMPI 106F 60 PUSH1 0x40 1071 51 MLOAD 1072 62 PUSH3 0x461bcd 1076 60 PUSH1 0xe5 1078 1B SHL 1079 81 DUP2 107A 52 MSTORE 107B 60 PUSH1 0x04 107D 01 ADD 107E 61 PUSH2 0x0541 1081 90 SWAP1 1082 61 PUSH2 0x2407 1085 56 *JUMP 1086 5B JUMPDEST 1087 61 PUSH2 0x104b 108A 84 DUP5 108B 84 DUP5 108C 84 DUP5 108D 84 DUP5 108E 61 PUSH2 0x1b23 1091 56 *JUMP label_1092: // Incoming jump from 0x0423 // Inputs[2] // { // @1095 storage[0x00] // @109F msg.sender // } 1092 5B JUMPDEST 1093 60 PUSH1 0x00 1095 54 SLOAD 1096 60 PUSH1 0x01 1098 60 PUSH1 0x01 109A 60 PUSH1 0xa0 109C 1B SHL 109D 03 SUB 109E 16 AND 109F 33 CALLER 10A0 14 EQ 10A1 61 PUSH2 0x10bc 10A4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10bc, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_10A5: // Incoming jump from 0x10A4, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @10A7 memory[0x40:0x60] } 10A5 60 PUSH1 0x40 10A7 51 MLOAD 10A8 62 PUSH3 0x461bcd 10AC 60 PUSH1 0xe5 10AE 1B SHL 10AF 81 DUP2 10B0 52 MSTORE 10B1 60 PUSH1 0x04 10B3 01 ADD 10B4 61 PUSH2 0x0541 10B7 90 SWAP1 10B8 61 PUSH2 0x234c 10BB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @10B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10B7 stack[0] = 0x0541 // @10B7 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x234c, returns to 0x0541 label_10BC: // Incoming jump from 0x10A4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @10BF storage[0x0a] } 10BC 5B JUMPDEST 10BD 60 PUSH1 0x0a 10BF 54 SLOAD 10C0 61 PUSH2 0x0100 10C3 90 SWAP1 10C4 04 DIV 10C5 60 PUSH1 0xff 10C7 16 AND 10C8 15 ISZERO 10C9 61 PUSH2 0x1120 10CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1120, if !(0xff & storage[0x0a] / 0x0100) label_10CD: // Incoming jump from 0x10CC, if not !(0xff & storage[0x0a] / 0x0100) // Inputs[1] { @10CF memory[0x40:0x60] } 10CD 60 PUSH1 0x40 10CF 51 MLOAD 10D0 62 PUSH3 0x461bcd 10D4 60 PUSH1 0xe5 10D6 1B SHL 10D7 81 DUP2 10D8 52 MSTORE 10D9 60 PUSH1 0x20 10DB 60 PUSH1 0x04 10DD 82 DUP3 10DE 01 ADD 10DF 52 MSTORE 10E0 60 PUSH1 0x23 10E2 60 PUSH1 0x24 10E4 82 DUP3 10E5 01 ADD 10E6 52 MSTORE 10E7 7F PUSH32 0x43616e6e6f74206368616e6765206e616d652061667465722066696e616c697a 1108 60 PUSH1 0x44 110A 82 DUP3 110B 01 ADD 110C 52 MSTORE 110D 62 PUSH3 0x32b217 1111 60 PUSH1 0xe9 1113 1B SHL 1114 60 PUSH1 0x64 1116 82 DUP3 1117 01 ADD 1118 52 MSTORE 1119 60 PUSH1 0x84 111B 01 ADD 111C 61 PUSH2 0x0541 111F 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @10D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10DF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10E6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x23 // @110C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616e6e6f74206368616e6765206e616d652061667465722066696e616c697a // @1118 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x32b217 << 0xe9 // @111B stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0541 label_1120: // Incoming jump from 0x10CC, if !(0xff & storage[0x0a] / 0x0100) // Inputs[2] // { // @1121 stack[-1] // @1122 memory[stack[-1]:stack[-1] + 0x20] // } 1120 5B JUMPDEST 1121 80 DUP1 1122 51 MLOAD 1123 61 PUSH2 0x105c 1126 90 SWAP1 1127 60 PUSH1 0x01 1129 90 SWAP1 112A 60 PUSH1 0x20 112C 84 DUP5 112D 01 ADD 112E 90 SWAP1 112F 61 PUSH2 0x1de5 1132 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1126 stack[0] = 0x105c // @1129 stack[1] = 0x01 // @112E stack[2] = stack[-1] + 0x20 // @112E stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1de5 label_1133: // Incoming jump from 0x0436 // Inputs[1] { @1139 stack[-1] } 1133 5B JUMPDEST 1134 60 PUSH1 0x60 1136 61 PUSH2 0x113e 1139 82 DUP3 113A 61 PUSH2 0x1436 113D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1134 stack[0] = 0x60 // @1136 stack[1] = 0x113e // @1139 stack[2] = stack[-1] // } // Block ends with call to 0x1436, returns to 0x113E label_113E: // Incoming return from call to 0x1436 at 0x113D // Incoming return from call to 0x1436 at 0x113D // Incoming return from call to 0x1436 at 0x113D // Inputs[1] { @1142 stack[-1] } 113E 5B JUMPDEST 113F 61 PUSH2 0x11a2 1142 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x11a2, if stack[-1] label_1143: // Incoming jump from 0x1142, if not stack[-1] // Inputs[1] { @1145 memory[0x40:0x60] } 1143 60 PUSH1 0x40 1145 51 MLOAD 1146 62 PUSH3 0x461bcd 114A 60 PUSH1 0xe5 114C 1B SHL 114D 81 DUP2 114E 52 MSTORE 114F 60 PUSH1 0x20 1151 60 PUSH1 0x04 1153 82 DUP3 1154 01 ADD 1155 52 MSTORE 1156 60 PUSH1 0x2f 1158 60 PUSH1 0x24 115A 82 DUP3 115B 01 ADD 115C 52 MSTORE 115D 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 117E 60 PUSH1 0x44 1180 82 DUP3 1181 01 ADD 1182 52 MSTORE 1183 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 1193 60 PUSH1 0x89 1195 1B SHL 1196 60 PUSH1 0x64 1198 82 DUP3 1199 01 ADD 119A 52 MSTORE 119B 60 PUSH1 0x84 119D 01 ADD 119E 61 PUSH2 0x0541 11A1 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @114E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1155 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @115C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @1182 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @119A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3732bc34b9ba32b73a103a37b5b2b7 << 0x89 // @119D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0541 label_11A2: // Incoming jump from 0x1142, if stack[-1] // Inputs[1] { @11A8 storage[0x06] } 11A2 5B JUMPDEST 11A3 60 PUSH1 0x00 11A5 60 PUSH1 0x06 11A7 80 DUP1 11A8 54 SLOAD 11A9 61 PUSH2 0x11b1 11AC 90 SWAP1 11AD 61 PUSH2 0x2381 11B0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @11A3 stack[0] = 0x00 // @11A5 stack[1] = 0x06 // @11AC stack[2] = 0x11b1 // @11AC stack[3] = storage[0x06] // } // Block ends with call to 0x2381, returns to 0x11B1 label_11B1: // Incoming return from call to 0x2381 at 0x11B0 // Inputs[4] // { // @11B2 stack[-1] // @11C1 memory[0x40:0x60] // @11C9 stack[-2] // @11D4 storage[stack[-2]] // } 11B1 5B JUMPDEST 11B2 80 DUP1 11B3 60 PUSH1 0x1f 11B5 01 ADD 11B6 60 PUSH1 0x20 11B8 80 DUP1 11B9 91 SWAP2 11BA 04 DIV 11BB 02 MUL 11BC 60 PUSH1 0x20 11BE 01 ADD 11BF 60 PUSH1 0x40 11C1 51 MLOAD 11C2 90 SWAP1 11C3 81 DUP2 11C4 01 ADD 11C5 60 PUSH1 0x40 11C7 52 MSTORE 11C8 80 DUP1 11C9 92 SWAP3 11CA 91 SWAP2 11CB 90 SWAP1 11CC 81 DUP2 11CD 81 DUP2 11CE 52 MSTORE 11CF 60 PUSH1 0x20 11D1 01 ADD 11D2 82 DUP3 11D3 80 DUP1 11D4 54 SLOAD 11D5 61 PUSH2 0x11dd 11D8 90 SWAP1 11D9 61 PUSH2 0x2381 11DC 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @11C7 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @11C9 stack[-2] = memory[0x40:0x60] // @11CA stack[-1] = stack[-2] // @11CB stack[0] = stack[-1] // @11CE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @11D1 stack[1] = 0x20 + memory[0x40:0x60] // @11D2 stack[2] = stack[-2] // @11D8 stack[4] = storage[stack[-2]] // @11D8 stack[3] = 0x11dd // } // Block ends with call to 0x2381, returns to 0x11DD label_11DD: // Incoming return from call to 0x2381 at 0x11DC // Inputs[1] { @11DE stack[-1] } 11DD 5B JUMPDEST 11DE 80 DUP1 11DF 15 ISZERO 11E0 61 PUSH2 0x122a 11E3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x122a, if !stack[-1] label_11E4: // Incoming jump from 0x11E3, if not !stack[-1] // Inputs[1] { @11E4 stack[-1] } 11E4 80 DUP1 11E5 60 PUSH1 0x1f 11E7 10 LT 11E8 61 PUSH2 0x11ff 11EB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11ff, if 0x1f < stack[-1] label_11EC: // Incoming jump from 0x11EB, if not 0x1f < stack[-1] // Inputs[4] // { // @11F0 stack[-2] // @11F1 storage[stack[-2]] // @11F4 stack[-3] // @11F6 stack[-1] // } 11EC 61 PUSH2 0x0100 11EF 80 DUP1 11F0 83 DUP4 11F1 54 SLOAD 11F2 04 DIV 11F3 02 MUL 11F4 83 DUP4 11F5 52 MSTORE 11F6 91 SWAP2 11F7 60 PUSH1 0x20 11F9 01 ADD 11FA 91 SWAP2 11FB 61 PUSH2 0x122a 11FE 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @11F5 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @11FA stack[-1] = stack[-1] // @11FA stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x122a label_11FF: // Incoming jump from 0x11EB, if 0x1f < stack[-1] // Inputs[5] // { // @1200 stack[-3] // @1201 stack[-1] // @1203 stack[-2] // @120B memory[0x00:0x20] // @120F storage[keccak256(memory[0x00:0x20])] // } 11FF 5B JUMPDEST 1200 82 DUP3 1201 01 ADD 1202 91 SWAP2 1203 90 SWAP1 1204 60 PUSH1 0x00 1206 52 MSTORE 1207 60 PUSH1 0x20 1209 60 PUSH1 0x00 120B 20 SHA3 120C 90 SWAP1 120D 5B JUMPDEST 120E 81 DUP2 120F 54 SLOAD 1210 81 DUP2 1211 52 MSTORE 1212 90 SWAP1 1213 60 PUSH1 0x01 1215 01 ADD 1216 90 SWAP1 1217 60 PUSH1 0x20 1219 01 ADD 121A 80 DUP1 121B 83 DUP4 121C 11 GT 121D 61 PUSH2 0x120d 1220 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1202 stack[-3] = stack[-3] + stack[-1] // @1206 memory[0x00:0x20] = stack[-2] // @1211 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1216 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1219 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x120d, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1221: // Incoming jump from 0x1220, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1220, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @1221 stack[-3] // @1222 stack[-1] // } 1221 82 DUP3 1222 90 SWAP1 1223 03 SUB 1224 60 PUSH1 0x1f 1226 16 AND 1227 82 DUP3 1228 01 ADD 1229 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1229 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1229 stack[-1] = stack[-3] // } // Block continues label_122A: // Incoming jump from 0x1229 // Incoming jump from 0x11E3, if !stack[-1] // Incoming jump from 0x11FE // Inputs[3] // { // @1230 stack[-6] // @1230 stack[-7] // @1235 memory[stack[-6]:stack[-6] + 0x20] // } 122A 5B JUMPDEST 122B 50 POP 122C 50 POP 122D 50 POP 122E 50 POP 122F 50 POP 1230 90 SWAP1 1231 50 POP 1232 60 PUSH1 0x00 1234 81 DUP2 1235 51 MLOAD 1236 11 GT 1237 61 PUSH2 0x124f 123A 57 *JUMPI // Stack delta = -6 // Outputs[1] { @1230 stack[-7] = stack[-6] } // Block ends with conditional jump to 0x124f, if memory[stack[-6]:stack[-6] + 0x20] > 0x00 label_123B: // Incoming jump from 0x123A, if not memory[stack[-6]:stack[-6] + 0x20] > 0x00 // Inputs[1] { @123D memory[0x40:0x60] } 123B 60 PUSH1 0x40 123D 51 MLOAD 123E 80 DUP1 123F 60 PUSH1 0x20 1241 01 ADD 1242 60 PUSH1 0x40 1244 52 MSTORE 1245 80 DUP1 1246 60 PUSH1 0x00 1248 81 DUP2 1249 52 MSTORE 124A 50 POP 124B 61 PUSH2 0x1299 124E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @123D stack[0] = memory[0x40:0x60] // @1244 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1249 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x1299 label_124F: // Incoming jump from 0x123A, if memory[stack[-6]:stack[-6] + 0x20] > 0x00 // Inputs[2] // { // @1250 stack[-1] // @1254 stack[-3] // } 124F 5B JUMPDEST 1250 80 DUP1 1251 61 PUSH2 0x1259 1254 84 DUP5 1255 61 PUSH2 0x1b56 1258 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1250 stack[0] = stack[-1] // @1251 stack[1] = 0x1259 // @1254 stack[2] = stack[-3] // } // Block ends with call to 0x1b56, returns to 0x1259 label_1259: // Incoming return from call to 0x1B56 at 0x1258 // Inputs[4] // { // @125C memory[0x40:0x60] // @127A memory[0x40:0x60] // @1281 stack[-2] // @1282 stack[-1] // } 1259 5B JUMPDEST 125A 60 PUSH1 0x40 125C 51 MLOAD 125D 80 DUP1 125E 60 PUSH1 0x40 1260 01 ADD 1261 60 PUSH1 0x40 1263 52 MSTORE 1264 80 DUP1 1265 60 PUSH1 0x05 1267 81 DUP2 1268 52 MSTORE 1269 60 PUSH1 0x20 126B 01 ADD 126C 64 PUSH5 0x173539b7b7 1272 60 PUSH1 0xd9 1274 1B SHL 1275 81 DUP2 1276 52 MSTORE 1277 50 POP 1278 60 PUSH1 0x40 127A 51 MLOAD 127B 60 PUSH1 0x20 127D 01 ADD 127E 61 PUSH2 0x1289 1281 93 SWAP4 1282 92 SWAP3 1283 91 SWAP2 1284 90 SWAP1 1285 61 PUSH2 0x24ce 1288 56 *JUMP // Stack delta = +3 // Outputs[8] // { // @1263 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1268 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x05 // @1276 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x173539b7b7 << 0xd9 // @1281 stack[-2] = 0x1289 // @1282 stack[-1] = stack[-2] // @1283 stack[0] = stack[-1] // @1284 stack[1] = memory[0x40:0x60] // @1284 stack[2] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x24ce, returns to 0x1289 label_1289: // Incoming return from call to 0x24CE at 0x1288 // Inputs[2] // { // @128C memory[0x40:0x60] // @1290 stack[-1] // } 1289 5B JUMPDEST 128A 60 PUSH1 0x40 128C 51 MLOAD 128D 60 PUSH1 0x20 128F 81 DUP2 1290 83 DUP4 1291 03 SUB 1292 03 SUB 1293 81 DUP2 1294 52 MSTORE 1295 90 SWAP1 1296 60 PUSH1 0x40 1298 52 MSTORE // Stack delta = +0 // Outputs[3] // { // @1294 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @1295 stack[-1] = memory[0x40:0x60] // @1298 memory[0x40:0x60] = stack[-1] // } // Block continues label_1299: // Incoming return from call to 0x1E6E at 0x1EA0 // Incoming jump from 0x1298 // Incoming return from call to 0x1F97 at 0x252D // Incoming return from call to 0x1FF5 at 0x201F // Incoming jump from 0x19D2, if stack[-1] // Incoming jump from 0x124E // Incoming return from call to 0x1F3F at 0x1F7D // Incoming return from call to 0x1F97 at 0x1FF4 // Inputs[3] // { // @129A stack[-5] // @129A stack[-1] // @129B stack[-4] // } 1299 5B JUMPDEST 129A 93 SWAP4 129B 92 SWAP3 129C 50 POP 129D 50 POP 129E 50 POP 129F 56 *JUMP // Stack delta = -4 // Outputs[1] { @129A stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_12A0: // Incoming call from 0x0462, returns to 0x0250 // Inputs[1] { @12A6 storage[0x07] } 12A0 5B JUMPDEST 12A1 60 PUSH1 0x60 12A3 60 PUSH1 0x07 12A5 80 DUP1 12A6 54 SLOAD 12A7 61 PUSH2 0x05d0 12AA 90 SWAP1 12AB 61 PUSH2 0x2381 12AE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @12A1 stack[0] = 0x60 // @12A3 stack[1] = 0x07 // @12AA stack[2] = 0x05d0 // @12AA stack[3] = storage[0x07] // } // Block ends with call to 0x2381, returns to 0x05D0 label_12AF: // Incoming jump from 0x04B1 // Inputs[2] // { // @12B2 storage[0x0c] // @12BC msg.sender // } 12AF 5B JUMPDEST 12B0 60 PUSH1 0x0c 12B2 54 SLOAD 12B3 60 PUSH1 0x01 12B5 60 PUSH1 0x01 12B7 60 PUSH1 0xa0 12B9 1B SHL 12BA 03 SUB 12BB 16 AND 12BC 33 CALLER 12BD 60 PUSH1 0x01 12BF 60 PUSH1 0x01 12C1 60 PUSH1 0xa0 12C3 1B SHL 12C4 03 SUB 12C5 16 AND 12C6 14 EQ 12C7 61 PUSH2 0x1338 12CA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1338, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0c] label_12CB: // Incoming jump from 0x12CA, if not (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0c] // Inputs[1] { @12CD memory[0x40:0x60] } 12CB 60 PUSH1 0x40 12CD 51 MLOAD 12CE 62 PUSH3 0x461bcd 12D2 60 PUSH1 0xe5 12D4 1B SHL 12D5 81 DUP2 12D6 52 MSTORE 12D7 60 PUSH1 0x20 12D9 60 PUSH1 0x04 12DB 82 DUP3 12DC 01 ADD 12DD 52 MSTORE 12DE 60 PUSH1 0x39 12E0 60 PUSH1 0x24 12E2 82 DUP3 12E3 01 ADD 12E4 52 MSTORE 12E5 7F PUSH32 0x546869732066756e6374696f6e206d7573742062652063616c6c656420627920 1306 60 PUSH1 0x44 1308 82 DUP3 1309 01 ADD 130A 52 MSTORE 130B 7F PUSH32 0x7468652061697264726f7020746f6b656e20706172656e742e00000000000000 132C 60 PUSH1 0x64 132E 82 DUP3 132F 01 ADD 1330 52 MSTORE 1331 60 PUSH1 0x84 1333 01 ADD 1334 61 PUSH2 0x0541 1337 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @12D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12DD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @12E4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x39 // @130A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x546869732066756e6374696f6e206d7573742062652063616c6c656420627920 // @1330 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7468652061697264726f7020746f6b656e20706172656e742e00000000000000 // @1333 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0541 label_1338: // Incoming jump from 0x12CA, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0c] // Inputs[1] { @133F stack[-1] } 1338 5B JUMPDEST 1339 61 PUSH2 0x1344 133C 61 PUSH2 0x2724 133F 82 DUP3 1340 61 PUSH2 0x249f 1343 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1339 stack[0] = 0x1344 // @133C stack[1] = 0x2724 // @133F stack[2] = stack[-1] // } // Block ends with call to 0x249f, returns to 0x1344 label_1344: // Incoming return from call to 0x249F at 0x1343 // Inputs[2] // { // @1345 stack[-1] // @1345 stack[-2] // } 1344 5B JUMPDEST 1345 90 SWAP1 1346 50 POP 1347 61 PUSH2 0x3aad 134A 81 DUP2 134B 10 LT 134C 80 DUP1 134D 15 ISZERO 134E 61 PUSH2 0x136c 1351 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1345 stack[-2] = stack[-1] // @134B stack[-1] = stack[-1] < 0x3aad // } // Block ends with conditional jump to 0x136c, if !(stack[-1] < 0x3aad) label_1352: // Incoming jump from 0x1351, if not !(stack[-1] < 0x3aad) // Inputs[3] // { // @1355 stack[-2] // @1360 memory[0x00:0x40] // @1361 storage[keccak256(memory[0x00:0x40])] // } 1352 50 POP 1353 60 PUSH1 0x00 1355 81 DUP2 1356 81 DUP2 1357 52 MSTORE 1358 60 PUSH1 0x03 135A 60 PUSH1 0x20 135C 52 MSTORE 135D 60 PUSH1 0x40 135F 90 SWAP1 1360 20 SHA3 1361 54 SLOAD 1362 60 PUSH1 0x01 1364 60 PUSH1 0x01 1366 60 PUSH1 0xa0 1368 1B SHL 1369 03 SUB 136A 16 AND 136B 15 ISZERO 136C 5B JUMPDEST 136D 15 ISZERO 136E 61 PUSH2 0x105c 1371 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1357 memory[0x00:0x20] = stack[-2] // @135C memory[0x20:0x40] = 0x03 // } // Block ends with conditional jump to 0x105c, if !!((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_1372: // Incoming jump from 0x1371, if not !!((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x1371, if not !stack[-1] // Inputs[5] // { // @1374 stack[-1] // @137F memory[0x00:0x40] // @1381 storage[keccak256(memory[0x00:0x40])] // @138A stack[-2] // @139D stack[-3] // } 1372 60 PUSH1 0x00 1374 81 DUP2 1375 81 DUP2 1376 52 MSTORE 1377 60 PUSH1 0x03 1379 60 PUSH1 0x20 137B 52 MSTORE 137C 60 PUSH1 0x40 137E 90 SWAP1 137F 20 SHA3 1380 80 DUP1 1381 54 SLOAD 1382 60 PUSH1 0x01 1384 60 PUSH1 0x01 1386 60 PUSH1 0xa0 1388 1B SHL 1389 03 SUB 138A 84 DUP5 138B 16 AND 138C 60 PUSH1 0x01 138E 60 PUSH1 0x01 1390 60 PUSH1 0xa0 1392 1B SHL 1393 03 SUB 1394 19 NOT 1395 90 SWAP1 1396 91 SWAP2 1397 16 AND 1398 17 OR 1399 90 SWAP1 139A 55 SSTORE 139B 50 POP 139C 50 POP 139D 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1376 memory[0x00:0x20] = stack[-1] // @137B memory[0x20:0x40] = 0x03 // @139A storage[keccak256(memory[0x00:0x40])] = (storage[keccak256(memory[0x00:0x40])] & ~((0x01 << 0xa0) - 0x01)) | (stack[-2] & (0x01 << 0xa0) - 0x01) // } // Block ends with unconditional jump to stack[-3] label_139E: // Incoming jump from 0x04C4 // Inputs[2] // { // @13A1 storage[0x00] // @13AB msg.sender // } 139E 5B JUMPDEST 139F 60 PUSH1 0x00 13A1 54 SLOAD 13A2 60 PUSH1 0x01 13A4 60 PUSH1 0x01 13A6 60 PUSH1 0xa0 13A8 1B SHL 13A9 03 SUB 13AA 16 AND 13AB 33 CALLER 13AC 14 EQ 13AD 61 PUSH2 0x13c8 13B0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13c8, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_13B1: // Incoming jump from 0x13B0, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @13B3 memory[0x40:0x60] } 13B1 60 PUSH1 0x40 13B3 51 MLOAD 13B4 62 PUSH3 0x461bcd 13B8 60 PUSH1 0xe5 13BA 1B SHL 13BB 81 DUP2 13BC 52 MSTORE 13BD 60 PUSH1 0x04 13BF 01 ADD 13C0 61 PUSH2 0x0541 13C3 90 SWAP1 13C4 61 PUSH2 0x234c 13C7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @13BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13C3 stack[0] = 0x0541 // @13C3 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x234c, returns to 0x0541 label_13C8: // Incoming jump from 0x13B0, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @13D1 stack[-1] } 13C8 5B JUMPDEST 13C9 60 PUSH1 0x01 13CB 60 PUSH1 0x01 13CD 60 PUSH1 0xa0 13CF 1B SHL 13D0 03 SUB 13D1 81 DUP2 13D2 16 AND 13D3 61 PUSH2 0x142d 13D6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x142d, if stack[-1] & (0x01 << 0xa0) - 0x01 label_13D7: // Incoming jump from 0x13D6, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @13D9 memory[0x40:0x60] } 13D7 60 PUSH1 0x40 13D9 51 MLOAD 13DA 62 PUSH3 0x461bcd 13DE 60 PUSH1 0xe5 13E0 1B SHL 13E1 81 DUP2 13E2 52 MSTORE 13E3 60 PUSH1 0x20 13E5 60 PUSH1 0x04 13E7 82 DUP3 13E8 01 ADD 13E9 52 MSTORE 13EA 60 PUSH1 0x26 13EC 60 PUSH1 0x24 13EE 82 DUP3 13EF 01 ADD 13F0 52 MSTORE 13F1 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 1412 60 PUSH1 0x44 1414 82 DUP3 1415 01 ADD 1416 52 MSTORE 1417 65 PUSH6 0x646472657373 141E 60 PUSH1 0xd0 1420 1B SHL 1421 60 PUSH1 0x64 1423 82 DUP3 1424 01 ADD 1425 52 MSTORE 1426 60 PUSH1 0x84 1428 01 ADD 1429 61 PUSH2 0x0541 142C 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @13E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13E9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @13F0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1416 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @1425 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @1428 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0541 label_142D: // Incoming jump from 0x13D6, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1431 stack[-1] } 142D 5B JUMPDEST 142E 61 PUSH2 0x0a15 1431 81 DUP2 1432 61 PUSH2 0x19da 1435 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @142E stack[0] = 0x0a15 // @1431 stack[1] = stack[-1] // } // Block ends with call to 0x19da, returns to 0x0A15 label_1436: // Incoming call from 0x113D, returns to 0x113E // Incoming call from 0x065D, returns to 0x065E // Inputs[2] // { // @143B storage[0x08] // @143C stack[-1] // } 1436 5B JUMPDEST 1437 60 PUSH1 0x00 1439 60 PUSH1 0x08 143B 54 SLOAD 143C 82 DUP3 143D 10 LT 143E 61 PUSH2 0x1449 1441 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1437 stack[0] = 0x00 } // Block ends with conditional jump to 0x1449, if stack[-1] < storage[0x08] label_1442: // Incoming jump from 0x1441, if not stack[-1] < storage[0x08] // Inputs[2] // { // @1445 stack[-3] // @1446 stack[-2] // } 1442 50 POP 1443 60 PUSH1 0x00 1445 91 SWAP2 1446 90 SWAP1 1447 50 POP 1448 56 *JUMP // Stack delta = -2 // Outputs[1] { @1445 stack[-3] = 0x00 } // Block ends with unconditional jump to stack[-3] label_1449: // Incoming jump from 0x1441, if stack[-1] < storage[0x08] 1449 5B JUMPDEST 144A 61 PUSH2 0x1456 144D 60 PUSH1 0x01 144F 61 PUSH2 0x3aad 1452 61 PUSH2 0x24b7 1455 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @144A stack[0] = 0x1456 // @144D stack[1] = 0x01 // @144F stack[2] = 0x3aad // } // Block ends with call to 0x24b7, returns to 0x1456 label_1456: // Incoming return from call to 0x24B7 at 0x1455 // Inputs[2] // { // @1457 stack[-3] // @1458 stack[-1] // } 1456 5B JUMPDEST 1457 82 DUP3 1458 11 GT 1459 15 ISZERO 145A 61 PUSH2 0x1465 145D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1465, if !(stack[-3] > stack[-1]) label_145E: // Incoming jump from 0x145D, if not !(stack[-3] > stack[-1]) // Inputs[2] // { // @1461 stack[-3] // @1462 stack[-2] // } 145E 50 POP 145F 60 PUSH1 0x00 1461 91 SWAP2 1462 90 SWAP1 1463 50 POP 1464 56 *JUMP // Stack delta = -2 // Outputs[1] { @1461 stack[-3] = 0x00 } // Block ends with unconditional jump to stack[-3] label_1465: // Incoming jump from 0x145D, if !(stack[-3] > stack[-1]) // Inputs[4] // { // @1468 storage[0x0a] // @146B stack[-2] // @1476 memory[0x00:0x40] // @1477 storage[keccak256(memory[0x00:0x40])] // } 1465 5B JUMPDEST 1466 60 PUSH1 0x0a 1468 54 SLOAD 1469 60 PUSH1 0x00 146B 83 DUP4 146C 81 DUP2 146D 52 MSTORE 146E 60 PUSH1 0x03 1470 60 PUSH1 0x20 1472 52 MSTORE 1473 60 PUSH1 0x40 1475 90 SWAP1 1476 20 SHA3 1477 54 SLOAD 1478 60 PUSH1 0x01 147A 60 PUSH1 0x01 147C 60 PUSH1 0xa0 147E 1B SHL 147F 03 SUB 1480 90 SWAP1 1481 81 DUP2 1482 16 AND 1483 62 PUSH3 0x010000 1487 90 SWAP1 1488 92 SWAP3 1489 04 DIV 148A 16 AND 148B 14 EQ 148C 15 ISZERO 148D 61 PUSH2 0x1498 1490 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @146D memory[0x00:0x20] = stack[-2] // @1472 memory[0x20:0x40] = 0x03 // } // Block ends with conditional jump to 0x1498, if !(storage[0x0a] / 0x010000 & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_1491: // Incoming jump from 0x1490, if not !(storage[0x0a] / 0x010000 & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @1494 stack[-3] // @1495 stack[-2] // } 1491 50 POP 1492 60 PUSH1 0x00 1494 91 SWAP2 1495 90 SWAP1 1496 50 POP 1497 56 *JUMP // Stack delta = -2 // Outputs[1] { @1494 stack[-3] = 0x00 } // Block ends with unconditional jump to stack[-3] label_1498: // Incoming jump from 0x1490, if !(storage[0x0a] / 0x010000 & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @149B stack[-2] // @14A6 memory[0x00:0x40] // @14A7 storage[keccak256(memory[0x00:0x40])] // } 1498 5B JUMPDEST 1499 60 PUSH1 0x00 149B 82 DUP3 149C 81 DUP2 149D 52 MSTORE 149E 60 PUSH1 0x03 14A0 60 PUSH1 0x20 14A2 52 MSTORE 14A3 60 PUSH1 0x40 14A5 90 SWAP1 14A6 20 SHA3 14A7 54 SLOAD 14A8 60 PUSH1 0x01 14AA 60 PUSH1 0x01 14AC 60 PUSH1 0xa0 14AE 1B SHL 14AF 03 SUB 14B0 16 AND 14B1 15 ISZERO 14B2 61 PUSH2 0x14bd 14B5 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @149D memory[0x00:0x20] = stack[-2] // @14A2 memory[0x20:0x40] = 0x03 // } // Block ends with conditional jump to 0x14bd, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_14B6: // Incoming jump from 0x14B5, if not !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @14B9 stack[-3] // @14BA stack[-2] // } 14B6 50 POP 14B7 60 PUSH1 0x01 14B9 91 SWAP2 14BA 90 SWAP1 14BB 50 POP 14BC 56 *JUMP // Stack delta = -2 // Outputs[1] { @14B9 stack[-3] = 0x01 } // Block ends with unconditional jump to stack[-3] label_14BD: // Incoming jump from 0x14B5, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @14C1 stack[-2] } 14BD 5B JUMPDEST 14BE 61 PUSH2 0x2724 14C1 82 DUP3 14C2 11 GT 14C3 61 PUSH2 0x1555 14C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1555, if stack[-2] > 0x2724 label_14C7: // Incoming jump from 0x14C6, if not stack[-2] > 0x2724 // Inputs[5] // { // @14C9 storage[0x0d] // @14CC memory[0x40:0x60] // @14DB stack[-2] // @14F9 memory[0x40:0x60] // @1500 address((0x01 << 0xa0) - 0x01 & storage[0x0d]).code.length // } 14C7 60 PUSH1 0x0d 14C9 54 SLOAD 14CA 60 PUSH1 0x40 14CC 51 MLOAD 14CD 63 PUSH4 0x31a9108f 14D2 60 PUSH1 0xe1 14D4 1B SHL 14D5 81 DUP2 14D6 52 MSTORE 14D7 60 PUSH1 0x04 14D9 81 DUP2 14DA 01 ADD 14DB 84 DUP5 14DC 90 SWAP1 14DD 52 MSTORE 14DE 60 PUSH1 0x00 14E0 91 SWAP2 14E1 60 PUSH1 0x01 14E3 60 PUSH1 0x01 14E5 60 PUSH1 0xa0 14E7 1B SHL 14E8 03 SUB 14E9 16 AND 14EA 90 SWAP1 14EB 63 PUSH4 0x6352211e 14F0 90 SWAP1 14F1 60 PUSH1 0x24 14F3 01 ADD 14F4 5B JUMPDEST 14F5 60 PUSH1 0x20 14F7 60 PUSH1 0x40 14F9 51 MLOAD 14FA 80 DUP1 14FB 83 DUP4 14FC 03 SUB 14FD 81 DUP2 14FE 86 DUP7 14FF 80 DUP1 1500 3B EXTCODESIZE 1501 15 ISZERO 1502 80 DUP1 1503 15 ISZERO 1504 61 PUSH2 0x150c 1507 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @14D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x31a9108f << 0xe1 // @14DD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-2] // @14E0 stack[0] = 0x00 // @14EA stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x0d] // @14F0 stack[2] = 0x6352211e // @14F3 stack[3] = 0x24 + memory[0x40:0x60] // @14F5 stack[4] = 0x20 // @14F9 stack[5] = memory[0x40:0x60] // @14FC stack[6] = (0x24 + memory[0x40:0x60]) - memory[0x40:0x60] // @14FD stack[7] = memory[0x40:0x60] // @14FE stack[8] = (0x01 << 0xa0) - 0x01 & storage[0x0d] // @1501 stack[9] = !address((0x01 << 0xa0) - 0x01 & storage[0x0d]).code.length // } // Block ends with conditional jump to 0x150c, if !!address((0x01 << 0xa0) - 0x01 & storage[0x0d]).code.length label_1508: // Incoming jump from 0x1507, if not !!address(stack[-3]).code.length // Incoming jump from 0x1507, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x0d]).code.length // Inputs[1] { @150B memory[0x00:0x00] } 1508 60 PUSH1 0x00 150A 80 DUP1 150B FD *REVERT // Stack delta = +0 // Outputs[1] { @150B revert(memory[0x00:0x00]); } // Block terminates label_150C: // Incoming jump from 0x1507, if !!address(stack[-3]).code.length // Incoming jump from 0x1507, if !!address((0x01 << 0xa0) - 0x01 & storage[0x0d]).code.length // Inputs[8] // { // @150E msg.gas // @150F stack[-3] // @150F stack[-4] // @150F stack[-2] // @150F stack[-6] // @150F address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @150F memory[stack[-3]:stack[-3] + stack[-4]] // @150F stack[-5] // } 150C 5B JUMPDEST 150D 50 POP 150E 5A GAS 150F FA STATICCALL 1510 15 ISZERO 1511 80 DUP1 1512 15 ISZERO 1513 61 PUSH2 0x1520 1516 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @150F memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1510 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1520, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1517: // Incoming jump from 0x1516, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1517 returndata.length // @151B returndata[0x00:0x00 + returndata.length] // @151C returndata.length // @151F memory[0x00:0x00 + returndata.length] // } 1517 3D RETURNDATASIZE 1518 60 PUSH1 0x00 151A 80 DUP1 151B 3E RETURNDATACOPY 151C 3D RETURNDATASIZE 151D 60 PUSH1 0x00 151F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @151B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @151F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1520: // Incoming jump from 0x1516, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1527 memory[0x40:0x60] // @1528 returndata.length // } 1520 5B JUMPDEST 1521 50 POP 1522 50 POP 1523 50 POP 1524 50 POP 1525 60 PUSH1 0x40 1527 51 MLOAD 1528 3D RETURNDATASIZE 1529 60 PUSH1 0x1f 152B 19 NOT 152C 60 PUSH1 0x1f 152E 82 DUP3 152F 01 ADD 1530 16 AND 1531 82 DUP3 1532 01 ADD 1533 80 DUP1 1534 60 PUSH1 0x40 1536 52 MSTORE 1537 50 POP 1538 81 DUP2 1539 01 ADD 153A 90 SWAP1 153B 61 PUSH2 0x1544 153E 91 SWAP2 153F 90 SWAP1 1540 61 PUSH2 0x2511 1543 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1536 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @153E stack[-4] = 0x1544 // @153F stack[-2] = memory[0x40:0x60] // @153F stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x2511, returns to 0x1544 label_1544: // Incoming return from call to 0x2511 at 0x1543 // Inputs[4] // { // @154D stack[-1] // @154E stack[-2] // @1550 stack[-5] // @1551 stack[-4] // } 1544 5B JUMPDEST 1545 60 PUSH1 0x01 1547 60 PUSH1 0x01 1549 60 PUSH1 0xa0 154B 1B SHL 154C 03 SUB 154D 16 AND 154E 14 EQ 154F 15 ISZERO 1550 92 SWAP3 1551 91 SWAP2 1552 50 POP 1553 50 POP 1554 56 *JUMP // Stack delta = -4 // Outputs[1] { @1550 stack[-5] = !((0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2]) } // Block ends with unconditional jump to stack[-5] label_1555: // Incoming jump from 0x14C6, if stack[-2] > 0x2724 // Inputs[2] // { // @1558 storage[0x0e] // @1570 stack[-2] // } 1555 5B JUMPDEST 1556 60 PUSH1 0x0e 1558 54 SLOAD 1559 60 PUSH1 0x00 155B 90 SWAP1 155C 60 PUSH1 0x01 155E 60 PUSH1 0x01 1560 60 PUSH1 0xa0 1562 1B SHL 1563 03 SUB 1564 16 AND 1565 63 PUSH4 0x6352211e 156A 61 PUSH2 0x1575 156D 61 PUSH2 0x2724 1570 86 DUP7 1571 61 PUSH2 0x24b7 1574 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @155B stack[0] = 0x00 // @1564 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x0e] // @1565 stack[2] = 0x6352211e // @156A stack[3] = 0x1575 // @156D stack[4] = 0x2724 // @1570 stack[5] = stack[-2] // } // Block ends with call to 0x24b7, returns to 0x1575 label_1575: // Incoming return from call to 0x24B7 at 0x1574 // Inputs[3] // { // @1578 memory[0x40:0x60] // @1579 stack[-2] // @158B stack[-1] // } 1575 5B JUMPDEST 1576 60 PUSH1 0x40 1578 51 MLOAD 1579 82 DUP3 157A 63 PUSH4 0xffffffff 157F 16 AND 1580 60 PUSH1 0xe0 1582 1B SHL 1583 81 DUP2 1584 52 MSTORE 1585 60 PUSH1 0x04 1587 01 ADD 1588 61 PUSH2 0x14f4 158B 91 SWAP2 158C 81 DUP2 158D 52 MSTORE 158E 60 PUSH1 0x20 1590 01 ADD 1591 90 SWAP1 1592 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1584 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-2]) << 0xe0 // @158D memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-1] // @1591 stack[-1] = 0x20 + 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x14f4 label_1593: // Incoming jump from 0x2000, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @1594 stack[-3] // @1594 stack[-1] // @1595 stack[-2] // } 1593 5B JUMPDEST 1594 91 SWAP2 1595 90 SWAP1 1596 50 POP 1597 56 *JUMP // Stack delta = -2 // Outputs[1] { @1594 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] 1598 5B JUMPDEST 1599 60 PUSH1 0x00 159B 81 DUP2 159C 81 DUP2 159D 52 MSTORE 159E 60 PUSH1 0x04 15A0 60 PUSH1 0x20 15A2 52 MSTORE 15A3 60 PUSH1 0x40 15A5 90 SWAP1 15A6 20 SHA3 15A7 80 DUP1 15A8 54 SLOAD 15A9 60 PUSH1 0x01 15AB 60 PUSH1 0x01 15AD 60 PUSH1 0xa0 15AF 1B SHL 15B0 03 SUB 15B1 19 NOT 15B2 16 AND 15B3 60 PUSH1 0x01 15B5 60 PUSH1 0x01 15B7 60 PUSH1 0xa0 15B9 1B SHL 15BA 03 SUB 15BB 84 DUP5 15BC 16 AND 15BD 90 SWAP1 15BE 81 DUP2 15BF 17 OR 15C0 90 SWAP1 15C1 91 SWAP2 15C2 55 SSTORE 15C3 81 DUP2 15C4 90 SWAP1 15C5 61 PUSH2 0x15cd 15C8 82 DUP3 15C9 61 PUSH2 0x0bb8 15CC 56 *JUMP 15CD 5B JUMPDEST 15CE 60 PUSH1 0x01 15D0 60 PUSH1 0x01 15D2 60 PUSH1 0xa0 15D4 1B SHL 15D5 03 SUB 15D6 16 AND 15D7 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 15F8 60 PUSH1 0x40 15FA 51 MLOAD 15FB 60 PUSH1 0x40 15FD 51 MLOAD 15FE 80 DUP1 15FF 91 SWAP2 1600 03 SUB 1601 90 SWAP1 1602 A4 LOG4 1603 50 POP 1604 50 POP 1605 56 *JUMP label_1606: // Incoming jump from 0x1069 // Incoming jump from 0x091D // Inputs[1] { @160D stack[-1] } 1606 5B JUMPDEST 1607 60 PUSH1 0x00 1609 80 DUP1 160A 61 PUSH2 0x1612 160D 83 DUP4 160E 61 PUSH2 0x0bb8 1611 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1607 stack[0] = 0x00 // @1609 stack[1] = 0x00 // @160A stack[2] = 0x1612 // @160D stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x0bb8 1612 5B JUMPDEST 1613 90 SWAP1 1614 50 POP 1615 80 DUP1 1616 60 PUSH1 0x01 1618 60 PUSH1 0x01 161A 60 PUSH1 0xa0 161C 1B SHL 161D 03 SUB 161E 16 AND 161F 84 DUP5 1620 60 PUSH1 0x01 1622 60 PUSH1 0x01 1624 60 PUSH1 0xa0 1626 1B SHL 1627 03 SUB 1628 16 AND 1629 14 EQ 162A 80 DUP1 162B 61 PUSH2 0x164d 162E 57 *JUMPI 162F 50 POP 1630 60 PUSH1 0x00 1632 83 DUP4 1633 81 DUP2 1634 52 MSTORE 1635 60 PUSH1 0x04 1637 60 PUSH1 0x20 1639 52 MSTORE 163A 60 PUSH1 0x40 163C 90 SWAP1 163D 20 SHA3 163E 54 SLOAD 163F 60 PUSH1 0x01 1641 60 PUSH1 0x01 1643 60 PUSH1 0xa0 1645 1B SHL 1646 03 SUB 1647 85 DUP6 1648 81 DUP2 1649 16 AND 164A 91 SWAP2 164B 16 AND 164C 14 EQ 164D 5B JUMPDEST 164E 80 DUP1 164F 61 PUSH2 0x167d 1652 57 *JUMPI 1653 50 POP 1654 60 PUSH1 0x01 1656 60 PUSH1 0x01 1658 60 PUSH1 0xa0 165A 1B SHL 165B 03 SUB 165C 80 DUP1 165D 82 DUP3 165E 16 AND 165F 60 PUSH1 0x00 1661 90 SWAP1 1662 81 DUP2 1663 52 MSTORE 1664 60 PUSH1 0x05 1666 60 PUSH1 0x20 1668 90 SWAP1 1669 81 DUP2 166A 52 MSTORE 166B 60 PUSH1 0x40 166D 80 DUP1 166E 83 DUP4 166F 20 SHA3 1670 93 SWAP4 1671 88 DUP9 1672 16 AND 1673 83 DUP4 1674 52 MSTORE 1675 92 SWAP3 1676 90 SWAP1 1677 52 MSTORE 1678 20 SHA3 1679 54 SLOAD 167A 60 PUSH1 0xff 167C 16 AND label_167D: // Incoming jump from 0x1BF3, if !stack[-5] // Incoming jump from 0x1BF3, if !stack[-7] // Incoming jump from 0x1BF3, if !stack[-7] // Incoming return from call to 0x21D4 at 0x2312 // Inputs[3] // { // @167E stack[-1] // @167E stack[-6] // @167F stack[-5] // } 167D 5B JUMPDEST 167E 94 SWAP5 167F 93 SWAP4 1680 50 POP 1681 50 POP 1682 50 POP 1683 50 POP 1684 56 *JUMP // Stack delta = -5 // Outputs[1] { @167E stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] 1685 5B JUMPDEST 1686 82 DUP3 1687 60 PUSH1 0x01 1689 60 PUSH1 0x01 168B 60 PUSH1 0xa0 168D 1B SHL 168E 03 SUB 168F 16 AND 1690 61 PUSH2 0x1698 1693 82 DUP3 1694 61 PUSH2 0x188d 1697 56 *JUMP 1698 5B JUMPDEST 1699 60 PUSH1 0x01 169B 60 PUSH1 0x01 169D 60 PUSH1 0xa0 169F 1B SHL 16A0 03 SUB 16A1 16 AND 16A2 14 EQ 16A3 61 PUSH2 0x1700 16A6 57 *JUMPI 16A7 60 PUSH1 0x40 16A9 51 MLOAD 16AA 62 PUSH3 0x461bcd 16AE 60 PUSH1 0xe5 16B0 1B SHL 16B1 81 DUP2 16B2 52 MSTORE 16B3 60 PUSH1 0x20 16B5 60 PUSH1 0x04 16B7 82 DUP3 16B8 01 ADD 16B9 52 MSTORE 16BA 60 PUSH1 0x29 16BC 60 PUSH1 0x24 16BE 82 DUP3 16BF 01 ADD 16C0 52 MSTORE 16C1 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 16E2 60 PUSH1 0x44 16E4 82 DUP3 16E5 01 ADD 16E6 52 MSTORE 16E7 68 PUSH9 0x39903737ba1037bbb7 16F1 60 PUSH1 0xb9 16F3 1B SHL 16F4 60 PUSH1 0x64 16F6 82 DUP3 16F7 01 ADD 16F8 52 MSTORE 16F9 60 PUSH1 0x84 16FB 01 ADD 16FC 61 PUSH2 0x0541 16FF 56 *JUMP 1700 5B JUMPDEST 1701 60 PUSH1 0x01 1703 60 PUSH1 0x01 1705 60 PUSH1 0xa0 1707 1B SHL 1708 03 SUB 1709 82 DUP3 170A 16 AND 170B 61 PUSH2 0x1762 170E 57 *JUMPI 170F 60 PUSH1 0x40 1711 51 MLOAD 1712 62 PUSH3 0x461bcd 1716 60 PUSH1 0xe5 1718 1B SHL 1719 81 DUP2 171A 52 MSTORE 171B 60 PUSH1 0x20 171D 60 PUSH1 0x04 171F 82 DUP3 1720 01 ADD 1721 52 MSTORE 1722 60 PUSH1 0x24 1724 80 DUP1 1725 82 DUP3 1726 01 ADD 1727 52 MSTORE 1728 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 1749 60 PUSH1 0x44 174B 82 DUP3 174C 01 ADD 174D 52 MSTORE 174E 63 PUSH4 0x72657373 1753 60 PUSH1 0xe0 1755 1B SHL 1756 60 PUSH1 0x64 1758 82 DUP3 1759 01 ADD 175A 52 MSTORE 175B 60 PUSH1 0x84 175D 01 ADD 175E 61 PUSH2 0x0541 1761 56 *JUMP 1762 5B JUMPDEST 1763 61 PUSH2 0x176d 1766 60 PUSH1 0x00 1768 82 DUP3 1769 61 PUSH2 0x1598 176C 56 *JUMP 176D 5B JUMPDEST 176E 60 PUSH1 0x00 1770 81 DUP2 1771 81 DUP2 1772 52 MSTORE 1773 60 PUSH1 0x03 1775 60 PUSH1 0x20 1777 52 MSTORE 1778 60 PUSH1 0x40 177A 80 DUP1 177B 82 DUP3 177C 20 SHA3 177D 80 DUP1 177E 54 SLOAD 177F 60 PUSH1 0x01 1781 60 PUSH1 0x01 1783 60 PUSH1 0xa0 1785 1B SHL 1786 03 SUB 1787 19 NOT 1788 16 AND 1789 60 PUSH1 0x01 178B 60 PUSH1 0x01 178D 60 PUSH1 0xa0 178F 1B SHL 1790 03 SUB 1791 86 DUP7 1792 81 DUP2 1793 16 AND 1794 91 SWAP2 1795 82 DUP3 1796 17 OR 1797 90 SWAP1 1798 92 SWAP3 1799 55 SSTORE 179A 91 SWAP2 179B 51 MLOAD 179C 84 DUP5 179D 93 SWAP4 179E 91 SWAP2 179F 87 DUP8 17A0 16 AND 17A1 91 SWAP2 17A2 60 PUSH1 0x00 17A4 80 DUP1 17A5 51 MLOAD 17A6 60 PUSH1 0x20 17A8 61 PUSH2 0x2619 17AB 83 DUP4 17AC 39 CODECOPY 17AD 81 DUP2 17AE 51 MLOAD 17AF 91 SWAP2 17B0 52 MSTORE 17B1 91 SWAP2 17B2 A4 LOG4 17B3 50 POP 17B4 50 POP 17B5 50 POP 17B6 56 *JUMP label_17B7: // Incoming jump from 0x0A14 // Inputs[1] { @17BD stack[-1] } 17B7 5B JUMPDEST 17B8 60 PUSH1 0x00 17BA 61 PUSH2 0x17c2 17BD 82 DUP3 17BE 61 PUSH2 0x0bb8 17C1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @17B8 stack[0] = 0x00 // @17BA stack[1] = 0x17c2 // @17BD stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x0bb8 17C2 5B JUMPDEST 17C3 60 PUSH1 0x0a 17C5 54 SLOAD 17C6 90 SWAP1 17C7 91 SWAP2 17C8 50 POP 17C9 62 PUSH3 0x010000 17CD 90 SWAP1 17CE 04 DIV 17CF 60 PUSH1 0x01 17D1 60 PUSH1 0x01 17D3 60 PUSH1 0xa0 17D5 1B SHL 17D6 03 SUB 17D7 16 AND 17D8 33 CALLER 17D9 60 PUSH1 0x01 17DB 60 PUSH1 0x01 17DD 60 PUSH1 0xa0 17DF 1B SHL 17E0 03 SUB 17E1 16 AND 17E2 82 DUP3 17E3 60 PUSH1 0x01 17E5 60 PUSH1 0x01 17E7 60 PUSH1 0xa0 17E9 1B SHL 17EA 03 SUB 17EB 16 AND 17EC 14 EQ 17ED 61 PUSH2 0x1838 17F0 57 *JUMPI 17F1 60 PUSH1 0x40 17F3 51 MLOAD 17F4 62 PUSH3 0x461bcd 17F8 60 PUSH1 0xe5 17FA 1B SHL 17FB 81 DUP2 17FC 52 MSTORE 17FD 60 PUSH1 0x20 17FF 60 PUSH1 0x04 1801 82 DUP3 1802 01 ADD 1803 52 MSTORE 1804 60 PUSH1 0x17 1806 60 PUSH1 0x24 1808 82 DUP3 1809 01 ADD 180A 52 MSTORE 180B 7F PUSH32 0x4d757374206f776e20746f6b656e20746f206275726e2e000000000000000000 182C 60 PUSH1 0x44 182E 82 DUP3 182F 01 ADD 1830 52 MSTORE 1831 60 PUSH1 0x64 1833 01 ADD 1834 61 PUSH2 0x0541 1837 56 *JUMP 1838 5B JUMPDEST 1839 61 PUSH2 0x1843 183C 60 PUSH1 0x00 183E 84 DUP5 183F 61 PUSH2 0x1598 1842 56 *JUMP 1843 5B JUMPDEST 1844 60 PUSH1 0x00 1846 83 DUP4 1847 81 DUP2 1848 52 MSTORE 1849 60 PUSH1 0x03 184B 60 PUSH1 0x20 184D 52 MSTORE 184E 60 PUSH1 0x40 1850 80 DUP1 1851 82 DUP3 1852 20 SHA3 1853 80 DUP1 1854 54 SLOAD 1855 60 PUSH1 0x01 1857 60 PUSH1 0x01 1859 60 PUSH1 0xa0 185B 1B SHL 185C 03 SUB 185D 19 NOT 185E 16 AND 185F 60 PUSH1 0x01 1861 60 PUSH1 0x01 1863 60 PUSH1 0xa0 1865 1B SHL 1866 03 SUB 1867 85 DUP6 1868 81 DUP2 1869 16 AND 186A 91 SWAP2 186B 82 DUP3 186C 17 OR 186D 90 SWAP1 186E 92 SWAP3 186F 55 SSTORE 1870 91 SWAP2 1871 51 MLOAD 1872 86 DUP7 1873 93 SWAP4 1874 91 SWAP2 1875 86 DUP7 1876 16 AND 1877 91 SWAP2 1878 60 PUSH1 0x00 187A 80 DUP1 187B 51 MLOAD 187C 60 PUSH1 0x20 187E 61 PUSH2 0x2619 1881 83 DUP4 1882 39 CODECOPY 1883 81 DUP2 1884 51 MLOAD 1885 91 SWAP2 1886 52 MSTORE 1887 91 SWAP2 1888 A4 LOG4 1889 50 POP 188A 50 POP 188B 50 POP 188C 56 *JUMP label_188D: // Incoming jump from 0x0CB8 // Incoming call from 0x0BC3, returns to 0x0000 // Inputs[3] // { // @1890 stack[-1] // @189B memory[0x00:0x40] // @189C storage[keccak256(memory[0x00:0x40])] // } 188D 5B JUMPDEST 188E 60 PUSH1 0x00 1890 81 DUP2 1891 81 DUP2 1892 52 MSTORE 1893 60 PUSH1 0x03 1895 60 PUSH1 0x20 1897 52 MSTORE 1898 60 PUSH1 0x40 189A 81 DUP2 189B 20 SHA3 189C 54 SLOAD 189D 60 PUSH1 0x01 189F 60 PUSH1 0x01 18A1 60 PUSH1 0xa0 18A3 1B SHL 18A4 03 SUB 18A5 16 AND 18A6 80 DUP1 18A7 15 ISZERO 18A8 80 DUP1 18A9 15 ISZERO 18AA 61 PUSH2 0x18b6 18AD 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @188E stack[0] = 0x00 // @1892 memory[0x00:0x20] = stack[-1] // @1897 memory[0x20:0x40] = 0x03 // @18A5 stack[1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // @18A7 stack[2] = !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with conditional jump to 0x18b6, if !!((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_18AE: // Incoming jump from 0x18AD, if not !!((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @18B1 storage[0x0a] } 18AE 50 POP 18AF 60 PUSH1 0x0a 18B1 54 SLOAD 18B2 60 PUSH1 0xff 18B4 16 AND 18B5 15 ISZERO 18B6 5B JUMPDEST 18B7 15 ISZERO 18B8 61 PUSH2 0x0511 18BB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0511, if !!(0xff & storage[0x0a]) label_18BC: // Incoming jump from 0x18BB, if not !!(0xff & storage[0x0a]) // Incoming jump from 0x18BB, if not !stack[-1] // Inputs[1] { @18BF stack[-3] } 18BC 61 PUSH2 0x2724 18BF 83 DUP4 18C0 11 GT 18C1 61 PUSH2 0x194b 18C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x194b, if stack[-3] > 0x2724 label_18C5: // Incoming jump from 0x18C4, if not stack[-3] > 0x2724 // Inputs[5] // { // @18C7 storage[0x0d] // @18CA memory[0x40:0x60] // @18D9 stack[-3] // @18F5 memory[0x40:0x60] // @18FC address(storage[0x0d] & (0x01 << 0xa0) - 0x01).code.length // } 18C5 60 PUSH1 0x0d 18C7 54 SLOAD 18C8 60 PUSH1 0x40 18CA 51 MLOAD 18CB 63 PUSH4 0x31a9108f 18D0 60 PUSH1 0xe1 18D2 1B SHL 18D3 81 DUP2 18D4 52 MSTORE 18D5 60 PUSH1 0x04 18D7 81 DUP2 18D8 01 ADD 18D9 85 DUP6 18DA 90 SWAP1 18DB 52 MSTORE 18DC 60 PUSH1 0x01 18DE 60 PUSH1 0x01 18E0 60 PUSH1 0xa0 18E2 1B SHL 18E3 03 SUB 18E4 90 SWAP1 18E5 91 SWAP2 18E6 16 AND 18E7 90 SWAP1 18E8 63 PUSH4 0x6352211e 18ED 90 SWAP1 18EE 60 PUSH1 0x24 18F0 01 ADD 18F1 60 PUSH1 0x20 18F3 60 PUSH1 0x40 18F5 51 MLOAD 18F6 80 DUP1 18F7 83 DUP4 18F8 03 SUB 18F9 81 DUP2 18FA 86 DUP7 18FB 80 DUP1 18FC 3B EXTCODESIZE 18FD 15 ISZERO 18FE 80 DUP1 18FF 15 ISZERO 1900 61 PUSH2 0x1908 1903 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @18D4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x31a9108f << 0xe1 // @18DB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-3] // @18E7 stack[0] = storage[0x0d] & (0x01 << 0xa0) - 0x01 // @18ED stack[1] = 0x6352211e // @18F0 stack[2] = 0x24 + memory[0x40:0x60] // @18F1 stack[3] = 0x20 // @18F5 stack[4] = memory[0x40:0x60] // @18F8 stack[5] = (0x24 + memory[0x40:0x60]) - memory[0x40:0x60] // @18F9 stack[6] = memory[0x40:0x60] // @18FA stack[7] = storage[0x0d] & (0x01 << 0xa0) - 0x01 // @18FD stack[8] = !address(storage[0x0d] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x1908, if !!address(storage[0x0d] & (0x01 << 0xa0) - 0x01).code.length label_1904: // Incoming jump from 0x1903, if not !!address(storage[0x0d] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @1907 memory[0x00:0x00] } 1904 60 PUSH1 0x00 1906 80 DUP1 1907 FD *REVERT // Stack delta = +0 // Outputs[1] { @1907 revert(memory[0x00:0x00]); } // Block terminates label_1908: // Incoming jump from 0x1903, if !!address(storage[0x0d] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @190A msg.gas // @190B memory[stack[-3]:stack[-3] + stack[-4]] // @190B stack[-6] // @190B stack[-5] // @190B stack[-3] // @190B stack[-4] // @190B stack[-2] // @190B address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @190C stack[-9] // } 1908 5B JUMPDEST 1909 50 POP 190A 5A GAS 190B FA STATICCALL 190C 92 SWAP3 190D 50 POP 190E 50 POP 190F 50 POP 1910 80 DUP1 1911 15 ISZERO 1912 61 PUSH2 0x1938 1915 57 *JUMPI // Stack delta = -8 // Outputs[2] // { // @190B memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @190C stack[-9] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1938, if !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1916: // Incoming jump from 0x1915, if not !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @191A memory[0x40:0x60] // @191D returndata.length // } 1916 50 POP 1917 60 PUSH1 0x40 1919 80 DUP1 191A 51 MLOAD 191B 60 PUSH1 0x1f 191D 3D RETURNDATASIZE 191E 90 SWAP1 191F 81 DUP2 1920 01 ADD 1921 60 PUSH1 0x1f 1923 19 NOT 1924 16 AND 1925 82 DUP3 1926 01 ADD 1927 90 SWAP1 1928 92 SWAP3 1929 52 MSTORE 192A 61 PUSH2 0x1935 192D 91 SWAP2 192E 81 DUP2 192F 01 ADD 1930 90 SWAP1 1931 61 PUSH2 0x2511 1934 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1929 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @192D stack[-1] = 0x1935 // @1930 stack[1] = memory[0x40:0x60] // @1930 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x2511, returns to 0x1935 label_1935: // Incoming return from call to 0x2511 at 0x1934 1935 5B JUMPDEST 1936 60 PUSH1 0x01 // Stack delta = +1 // Outputs[1] { @1936 stack[0] = 0x01 } // Block continues label_1938: // Incoming jump from 0x1936 // Incoming jump from 0x1915, if !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[1] { @193C stack[-1] } 1938 5B JUMPDEST 1939 61 PUSH2 0x1944 193C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1944, if stack[-1] label_193D: // Incoming jump from 0x193C, if not stack[-1] 193D 50 POP 193E 60 PUSH1 0x00 1940 61 PUSH2 0x0511 1943 56 *JUMP // Stack delta = +0 // Outputs[1] { @193E stack[-1] = 0x00 } // Block ends with unconditional jump to 0x0511 label_1944: // Incoming jump from 0x193C, if stack[-1] // Inputs[2] // { // @1945 stack[-2] // @1945 stack[-1] // } 1944 5B JUMPDEST 1945 90 SWAP1 1946 50 POP 1947 61 PUSH2 0x0511 194A 56 *JUMP // Stack delta = -1 // Outputs[1] { @1945 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x0511 label_194B: // Incoming jump from 0x18C4, if stack[-3] > 0x2724 // Inputs[2] // { // @194E storage[0x0e] // @1963 stack[-3] // } 194B 5B JUMPDEST 194C 60 PUSH1 0x0e 194E 54 SLOAD 194F 60 PUSH1 0x01 1951 60 PUSH1 0x01 1953 60 PUSH1 0xa0 1955 1B SHL 1956 03 SUB 1957 16 AND 1958 63 PUSH4 0x6352211e 195D 61 PUSH2 0x1968 1960 61 PUSH2 0x2724 1963 86 DUP7 1964 61 PUSH2 0x24b7 1967 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1957 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0e] // @1958 stack[1] = 0x6352211e // @195D stack[2] = 0x1968 // @1960 stack[3] = 0x2724 // @1963 stack[4] = stack[-3] // } // Block ends with call to 0x24b7, returns to 0x1968 label_1968: // Incoming return from call to 0x24B7 at 0x1967 // Inputs[3] // { // @196B memory[0x40:0x60] // @196C stack[-2] // @197E stack[-1] // } 1968 5B JUMPDEST 1969 60 PUSH1 0x40 196B 51 MLOAD 196C 82 DUP3 196D 63 PUSH4 0xffffffff 1972 16 AND 1973 60 PUSH1 0xe0 1975 1B SHL 1976 81 DUP2 1977 52 MSTORE 1978 60 PUSH1 0x04 197A 01 ADD 197B 61 PUSH2 0x1986 197E 91 SWAP2 197F 81 DUP2 1980 52 MSTORE 1981 60 PUSH1 0x20 1983 01 ADD 1984 90 SWAP1 1985 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1977 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-2]) << 0xe0 // @1980 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-1] // @1984 stack[-1] = 0x20 + 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1986 label_1986: // Incoming jump from 0x1985 // Inputs[4] // { // @198B memory[0x40:0x60] // @198D stack[-1] // @1990 stack[-3] // @1992 address(stack[-3]).code.length // } 1986 5B JUMPDEST 1987 60 PUSH1 0x20 1989 60 PUSH1 0x40 198B 51 MLOAD 198C 80 DUP1 198D 83 DUP4 198E 03 SUB 198F 81 DUP2 1990 86 DUP7 1991 80 DUP1 1992 3B EXTCODESIZE 1993 15 ISZERO 1994 80 DUP1 1995 15 ISZERO 1996 61 PUSH2 0x199e 1999 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @1987 stack[0] = 0x20 // @198B stack[1] = memory[0x40:0x60] // @198E stack[2] = stack[-1] - memory[0x40:0x60] // @198F stack[3] = memory[0x40:0x60] // @1990 stack[4] = stack[-3] // @1993 stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x199e, if !!address(stack[-3]).code.length label_199A: // Incoming jump from 0x1999, if not !!address(stack[-3]).code.length // Inputs[1] { @199D memory[0x00:0x00] } 199A 60 PUSH1 0x00 199C 80 DUP1 199D FD *REVERT // Stack delta = +0 // Outputs[1] { @199D revert(memory[0x00:0x00]); } // Block terminates label_199E: // Incoming jump from 0x1999, if !!address(stack[-3]).code.length // Inputs[9] // { // @19A0 msg.gas // @19A1 stack[-3] // @19A1 stack[-6] // @19A1 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @19A1 stack[-5] // @19A1 stack[-4] // @19A1 stack[-2] // @19A1 memory[stack[-3]:stack[-3] + stack[-4]] // @19A2 stack[-9] // } 199E 5B JUMPDEST 199F 50 POP 19A0 5A GAS 19A1 FA STATICCALL 19A2 92 SWAP3 19A3 50 POP 19A4 50 POP 19A5 50 POP 19A6 80 DUP1 19A7 15 ISZERO 19A8 61 PUSH2 0x19ce 19AB 57 *JUMPI // Stack delta = -8 // Outputs[2] // { // @19A1 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @19A2 stack[-9] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x19ce, if !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_19AC: // Incoming jump from 0x19AB, if not !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @19B0 memory[0x40:0x60] // @19B3 returndata.length // } 19AC 50 POP 19AD 60 PUSH1 0x40 19AF 80 DUP1 19B0 51 MLOAD 19B1 60 PUSH1 0x1f 19B3 3D RETURNDATASIZE 19B4 90 SWAP1 19B5 81 DUP2 19B6 01 ADD 19B7 60 PUSH1 0x1f 19B9 19 NOT 19BA 16 AND 19BB 82 DUP3 19BC 01 ADD 19BD 90 SWAP1 19BE 92 SWAP3 19BF 52 MSTORE 19C0 61 PUSH2 0x19cb 19C3 91 SWAP2 19C4 81 DUP2 19C5 01 ADD 19C6 90 SWAP1 19C7 61 PUSH2 0x2511 19CA 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @19BF memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @19C3 stack[-1] = 0x19cb // @19C6 stack[1] = memory[0x40:0x60] // @19C6 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x2511, returns to 0x19CB label_19CB: // Incoming return from call to 0x2511 at 0x19CA 19CB 5B JUMPDEST 19CC 60 PUSH1 0x01 // Stack delta = +1 // Outputs[1] { @19CC stack[0] = 0x01 } // Block continues label_19CE: // Incoming jump from 0x19AB, if !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Incoming jump from 0x19CC // Inputs[1] { @19D2 stack[-1] } 19CE 5B JUMPDEST 19CF 61 PUSH2 0x1299 19D2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1299, if stack[-1] label_19D3: // Incoming jump from 0x19D2, if not stack[-1] 19D3 50 POP 19D4 60 PUSH1 0x00 19D6 61 PUSH2 0x0511 19D9 56 *JUMP // Stack delta = +0 // Outputs[1] { @19D4 stack[-1] = 0x00 } // Block ends with unconditional jump to 0x0511 label_19DA: // Incoming call from 0x1435, returns to 0x0A15 // Incoming call from 0x0D22, returns to 0x0D23 // Inputs[5] // { // @19DE storage[0x00] // @19E7 stack[-1] // @19FB memory[0x40:0x60] // @1A26 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1A29 stack[-2] // } 19DA 5B JUMPDEST 19DB 60 PUSH1 0x00 19DD 80 DUP1 19DE 54 SLOAD 19DF 60 PUSH1 0x01 19E1 60 PUSH1 0x01 19E3 60 PUSH1 0xa0 19E5 1B SHL 19E6 03 SUB 19E7 83 DUP4 19E8 81 DUP2 19E9 16 AND 19EA 60 PUSH1 0x01 19EC 60 PUSH1 0x01 19EE 60 PUSH1 0xa0 19F0 1B SHL 19F1 03 SUB 19F2 19 NOT 19F3 83 DUP4 19F4 16 AND 19F5 81 DUP2 19F6 17 OR 19F7 84 DUP5 19F8 55 SSTORE 19F9 60 PUSH1 0x40 19FB 51 MLOAD 19FC 91 SWAP2 19FD 90 SWAP1 19FE 92 SWAP3 19FF 16 AND 1A00 92 SWAP3 1A01 83 DUP4 1A02 91 SWAP2 1A03 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1A24 91 SWAP2 1A25 90 SWAP1 1A26 A3 LOG3 1A27 50 POP 1A28 50 POP 1A29 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @19F8 storage[0x00] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x00] & ~((0x01 << 0xa0) - 0x01)) // @1A26 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_1A2A: // Incoming jump from 0x0E61 // Inputs[7] // { // @1A2D memory[0x40:0x60] // @1A2E stack[-1] // @1A38 stack[-2] // @1A41 memory[0x00:0x20] // @1A4A memory[0x00:0x20] // @1A50 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1A53 stack[-3] // } 1A2A 5B JUMPDEST 1A2B 60 PUSH1 0x40 1A2D 51 MLOAD 1A2E 81 DUP2 1A2F 90 SWAP1 1A30 60 PUSH1 0x01 1A32 60 PUSH1 0x01 1A34 60 PUSH1 0xa0 1A36 1B SHL 1A37 03 SUB 1A38 84 DUP5 1A39 16 AND 1A3A 90 SWAP1 1A3B 60 PUSH1 0x00 1A3D 90 SWAP1 1A3E 60 PUSH1 0x00 1A40 80 DUP1 1A41 51 MLOAD 1A42 60 PUSH1 0x20 1A44 61 PUSH2 0x2619 1A47 83 DUP4 1A48 39 CODECOPY 1A49 81 DUP2 1A4A 51 MLOAD 1A4B 91 SWAP2 1A4C 52 MSTORE 1A4D 90 SWAP1 1A4E 82 DUP3 1A4F 90 SWAP1 1A50 A4 LOG4 1A51 50 POP 1A52 50 POP 1A53 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1A48 memory[0x00:0x20] = code[0x2619:0x2639] // @1A4C memory[0x00:0x20] = memory[0x00:0x20] // @1A50 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [memory[0x00:0x20], 0x00, stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1]]); // } // Block ends with unconditional jump to stack[-3] label_1A54: // Incoming call from 0x105B, returns to 0x105C // Inputs[2] // { // @1A55 stack[-2] // @1A5F stack[-3] // } 1A54 5B JUMPDEST 1A55 81 DUP2 1A56 60 PUSH1 0x01 1A58 60 PUSH1 0x01 1A5A 60 PUSH1 0xa0 1A5C 1B SHL 1A5D 03 SUB 1A5E 16 AND 1A5F 83 DUP4 1A60 60 PUSH1 0x01 1A62 60 PUSH1 0x01 1A64 60 PUSH1 0xa0 1A66 1B SHL 1A67 03 SUB 1A68 16 AND 1A69 14 EQ 1A6A 15 ISZERO 1A6B 61 PUSH2 0x1ab6 1A6E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ab6, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2]) label_1A6F: // Incoming jump from 0x1A6E, if not !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2]) // Inputs[1] { @1A71 memory[0x40:0x60] } 1A6F 60 PUSH1 0x40 1A71 51 MLOAD 1A72 62 PUSH3 0x461bcd 1A76 60 PUSH1 0xe5 1A78 1B SHL 1A79 81 DUP2 1A7A 52 MSTORE 1A7B 60 PUSH1 0x20 1A7D 60 PUSH1 0x04 1A7F 82 DUP3 1A80 01 ADD 1A81 52 MSTORE 1A82 60 PUSH1 0x19 1A84 60 PUSH1 0x24 1A86 82 DUP3 1A87 01 ADD 1A88 52 MSTORE 1A89 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 1AAA 60 PUSH1 0x44 1AAC 82 DUP3 1AAD 01 ADD 1AAE 52 MSTORE 1AAF 60 PUSH1 0x64 1AB1 01 ADD 1AB2 61 PUSH2 0x0541 1AB5 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1A7A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1A81 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1A88 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @1AAE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @1AB1 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0541 label_1AB6: // Incoming jump from 0x1A6E, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2]) // Inputs[10] // { // @1ABF stack[-3] // @1AD2 memory[0x00:0x40] // @1AD4 stack[-2] // @1ADF memory[0x00:0x40] // @1AE1 storage[keccak256(memory[0x00:0x40])] // @1AE6 stack[-1] // @1AF0 memory[0x40:0x60] // @1B19 memory[0x40:0x60] // @1B1E memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x20) - memory[0x40:0x60]] // @1B22 stack[-4] // } 1AB6 5B JUMPDEST 1AB7 60 PUSH1 0x01 1AB9 60 PUSH1 0x01 1ABB 60 PUSH1 0xa0 1ABD 1B SHL 1ABE 03 SUB 1ABF 83 DUP4 1AC0 81 DUP2 1AC1 16 AND 1AC2 60 PUSH1 0x00 1AC4 81 DUP2 1AC5 81 DUP2 1AC6 52 MSTORE 1AC7 60 PUSH1 0x05 1AC9 60 PUSH1 0x20 1ACB 90 SWAP1 1ACC 81 DUP2 1ACD 52 MSTORE 1ACE 60 PUSH1 0x40 1AD0 80 DUP1 1AD1 83 DUP4 1AD2 20 SHA3 1AD3 94 SWAP5 1AD4 87 DUP8 1AD5 16 AND 1AD6 80 DUP1 1AD7 84 DUP5 1AD8 52 MSTORE 1AD9 94 SWAP5 1ADA 82 DUP3 1ADB 52 MSTORE 1ADC 91 SWAP2 1ADD 82 DUP3 1ADE 90 SWAP1 1ADF 20 SHA3 1AE0 80 DUP1 1AE1 54 SLOAD 1AE2 60 PUSH1 0xff 1AE4 19 NOT 1AE5 16 AND 1AE6 86 DUP7 1AE7 15 ISZERO 1AE8 15 ISZERO 1AE9 90 SWAP1 1AEA 81 DUP2 1AEB 17 OR 1AEC 90 SWAP1 1AED 91 SWAP2 1AEE 55 SSTORE 1AEF 91 SWAP2 1AF0 51 MLOAD 1AF1 91 SWAP2 1AF2 82 DUP3 1AF3 52 MSTORE 1AF4 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1B15 91 SWAP2 1B16 01 ADD 1B17 60 PUSH1 0x40 1B19 51 MLOAD 1B1A 80 DUP1 1B1B 91 SWAP2 1B1C 03 SUB 1B1D 90 SWAP1 1B1E A3 LOG3 1B1F 50 POP 1B20 50 POP 1B21 50 POP 1B22 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @1AC6 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1ACD memory[0x20:0x40] = 0x05 // @1AD8 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1ADB memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1AEE storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1AF3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @1B1E log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x20) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-4] 1B23 5B JUMPDEST 1B24 61 PUSH2 0x1b2e 1B27 84 DUP5 1B28 84 DUP5 1B29 84 DUP5 1B2A 61 PUSH2 0x1685 1B2D 56 *JUMP 1B2E 5B JUMPDEST 1B2F 61 PUSH2 0x1b3a 1B32 84 DUP5 1B33 84 DUP5 1B34 84 DUP5 1B35 84 DUP5 1B36 61 PUSH2 0x1c54 1B39 56 *JUMP 1B3A 5B JUMPDEST 1B3B 61 PUSH2 0x104b 1B3E 57 *JUMPI 1B3F 60 PUSH1 0x40 1B41 51 MLOAD 1B42 62 PUSH3 0x461bcd 1B46 60 PUSH1 0xe5 1B48 1B SHL 1B49 81 DUP2 1B4A 52 MSTORE 1B4B 60 PUSH1 0x04 1B4D 01 ADD 1B4E 61 PUSH2 0x0541 1B51 90 SWAP1 1B52 61 PUSH2 0x252e 1B55 56 *JUMP label_1B56: // Incoming call from 0x1258, returns to 0x1259 // Inputs[1] { @1B59 stack[-1] } 1B56 5B JUMPDEST 1B57 60 PUSH1 0x60 1B59 81 DUP2 1B5A 61 PUSH2 0x1b7a 1B5D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B57 stack[0] = 0x60 } // Block ends with conditional jump to 0x1b7a, if stack[-1] label_1B5E: // Incoming jump from 0x1B5D, if not stack[-1] // Inputs[2] // { // @1B63 memory[0x40:0x60] // @1B78 stack[-3] // } 1B5E 50 POP 1B5F 50 POP 1B60 60 PUSH1 0x40 1B62 80 DUP1 1B63 51 MLOAD 1B64 80 DUP1 1B65 82 DUP3 1B66 01 ADD 1B67 90 SWAP1 1B68 91 SWAP2 1B69 52 MSTORE 1B6A 60 PUSH1 0x01 1B6C 81 DUP2 1B6D 52 MSTORE 1B6E 60 PUSH1 0x03 1B70 60 PUSH1 0xfc 1B72 1B SHL 1B73 60 PUSH1 0x20 1B75 82 DUP3 1B76 01 ADD 1B77 52 MSTORE 1B78 90 SWAP1 1B79 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @1B69 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1B6D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @1B77 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x03 << 0xfc // @1B78 stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_1B7A: // Incoming jump from 0x1B5D, if stack[-1] // Inputs[1] { @1B7B stack[-2] } 1B7A 5B JUMPDEST 1B7B 81 DUP2 1B7C 60 PUSH1 0x00 1B7E 5B JUMPDEST 1B7F 81 DUP2 1B80 15 ISZERO 1B81 61 PUSH2 0x1ba4 1B84 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1B7B stack[0] = stack[-2] // @1B7C stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ba4, if !stack[-2] label_1B85: // Incoming jump from 0x1B84, if not !stack[-2] // Incoming jump from 0x1B84, if not !stack[-2] // Inputs[1] { @1B85 stack[-1] } 1B85 80 DUP1 1B86 61 PUSH2 0x1b8e 1B89 81 DUP2 1B8A 61 PUSH2 0x2484 1B8D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B85 stack[0] = stack[-1] // @1B86 stack[1] = 0x1b8e // @1B89 stack[2] = stack[-1] // } // Block ends with call to 0x2484, returns to 0x1B8E label_1B8E: // Incoming return from call to 0x2484 at 0x1B8D // Inputs[4] // { // @1B8F stack[-1] // @1B8F stack[-3] // @1B94 stack[-2] // @1B98 stack[-4] // } 1B8E 5B JUMPDEST 1B8F 91 SWAP2 1B90 50 POP 1B91 61 PUSH2 0x1b9d 1B94 90 SWAP1 1B95 50 POP 1B96 60 PUSH1 0x0a 1B98 83 DUP4 1B99 61 PUSH2 0x2596 1B9C 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1B8F stack[-3] = stack[-1] // @1B94 stack[-2] = 0x1b9d // @1B96 stack[-1] = 0x0a // @1B98 stack[0] = stack[-4] // } // Block ends with call to 0x2596, returns to 0x1B9D label_1B9D: // Incoming return from call to 0x2596 at 0x1B9C // Inputs[2] // { // @1B9E stack[-3] // @1B9E stack[-1] // } 1B9D 5B JUMPDEST 1B9E 91 SWAP2 1B9F 50 POP 1BA0 61 PUSH2 0x1b7e 1BA3 56 *JUMP // Stack delta = -1 // Outputs[1] { @1B9E stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1b7e label_1BA4: // Incoming jump from 0x1B84, if !stack[-2] // Incoming jump from 0x1B84, if !stack[-2] // Inputs[1] { @1BA7 stack[-1] } 1BA4 5B JUMPDEST 1BA5 60 PUSH1 0x00 1BA7 81 DUP2 1BA8 67 PUSH8 0xffffffffffffffff 1BB1 81 DUP2 1BB2 11 GT 1BB3 15 ISZERO 1BB4 61 PUSH2 0x1bbf 1BB7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1BA5 stack[0] = 0x00 // @1BA7 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1bbf, if !(stack[-1] > 0xffffffffffffffff) label_1BB8: // Incoming jump from 0x1BB7, if not !(stack[-1] > 0xffffffffffffffff) 1BB8 61 PUSH2 0x1bbf 1BBB 61 PUSH2 0x21be 1BBE 56 *JUMP // Stack delta = +1 // Outputs[1] { @1BB8 stack[0] = 0x1bbf } // Block ends with unconditional jump to 0x21be label_1BBF: // Incoming jump from 0x1BB7, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @1BC2 memory[0x40:0x60] // @1BC3 stack[-1] // } 1BBF 5B JUMPDEST 1BC0 60 PUSH1 0x40 1BC2 51 MLOAD 1BC3 90 SWAP1 1BC4 80 DUP1 1BC5 82 DUP3 1BC6 52 MSTORE 1BC7 80 DUP1 1BC8 60 PUSH1 0x1f 1BCA 01 ADD 1BCB 60 PUSH1 0x1f 1BCD 19 NOT 1BCE 16 AND 1BCF 60 PUSH1 0x20 1BD1 01 ADD 1BD2 82 DUP3 1BD3 01 ADD 1BD4 60 PUSH1 0x40 1BD6 52 MSTORE 1BD7 80 DUP1 1BD8 15 ISZERO 1BD9 61 PUSH2 0x1be9 1BDC 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1BC3 stack[-1] = memory[0x40:0x60] // @1BC3 stack[0] = stack[-1] // @1BC6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1BD6 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x1be9, if !stack[-1] label_1BDD: // Incoming jump from 0x1BDC, if not !stack[-1] // Inputs[6] // { // @1BDF stack[-2] // @1BE1 stack[-1] // @1BE3 msg.data.length // @1BE5 msg.data[msg.data.length:msg.data.length + stack[-1]] // @1BEB stack[-3] // @1BEE stack[-7] // } 1BDD 60 PUSH1 0x20 1BDF 82 DUP3 1BE0 01 ADD 1BE1 81 DUP2 1BE2 80 DUP1 1BE3 36 CALLDATASIZE 1BE4 83 DUP4 1BE5 37 CALLDATACOPY 1BE6 01 ADD 1BE7 90 SWAP1 1BE8 50 POP 1BE9 5B JUMPDEST 1BEA 50 POP 1BEB 90 SWAP1 1BEC 50 POP 1BED 5B JUMPDEST 1BEE 84 DUP5 1BEF 15 ISZERO 1BF0 61 PUSH2 0x167d 1BF3 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1BE5 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @1BEB stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x167d, if !stack[-7] label_1BF4: // Incoming jump from 0x1BF3, if not !stack[-5] // Incoming jump from 0x1BF3, if not !stack[-7] // Incoming jump from 0x1BF3, if not !stack[-7] // Inputs[1] { @1BF9 stack[-2] } 1BF4 61 PUSH2 0x1bfe 1BF7 60 PUSH1 0x01 1BF9 83 DUP4 1BFA 61 PUSH2 0x24b7 1BFD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1BF4 stack[0] = 0x1bfe // @1BF7 stack[1] = 0x01 // @1BF9 stack[2] = stack[-2] // } // Block ends with call to 0x24b7, returns to 0x1BFE label_1BFE: // Incoming return from call to 0x24B7 at 0x1BFD // Inputs[3] // { // @1BFF stack[-3] // @1BFF stack[-1] // @1C06 stack[-6] // } 1BFE 5B JUMPDEST 1BFF 91 SWAP2 1C00 50 POP 1C01 61 PUSH2 0x1c0b 1C04 60 PUSH1 0x0a 1C06 86 DUP7 1C07 61 PUSH2 0x25aa 1C0A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1BFF stack[-3] = stack[-1] // @1C01 stack[-1] = 0x1c0b // @1C04 stack[0] = 0x0a // @1C06 stack[1] = stack[-6] // } // Block ends with call to 0x25aa, returns to 0x1C0B label_1C0B: // Incoming return from call to 0x25AA at 0x1C0A // Inputs[1] { @1C0F stack[-1] } 1C0B 5B JUMPDEST 1C0C 61 PUSH2 0x1c16 1C0F 90 SWAP1 1C10 60 PUSH1 0x30 1C12 61 PUSH2 0x249f 1C15 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1C0F stack[0] = stack[-1] // @1C0F stack[-1] = 0x1c16 // @1C10 stack[1] = 0x30 // } // Block ends with call to 0x249f, returns to 0x1C16 label_1C16: // Incoming return from call to 0x249F at 0x1C15 // Inputs[4] // { // @1C19 stack[-1] // @1C1A stack[-2] // @1C1B stack[-3] // @1C1D memory[stack[-2]:stack[-2] + 0x20] // } 1C16 5B JUMPDEST 1C17 60 PUSH1 0xf8 1C19 1B SHL 1C1A 81 DUP2 1C1B 83 DUP4 1C1C 81 DUP2 1C1D 51 MLOAD 1C1E 81 DUP2 1C1F 10 LT 1C20 61 PUSH2 0x1c2b 1C23 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1C19 stack[-1] = stack[-1] << 0xf8 // @1C1A stack[0] = stack[-2] // @1C1B stack[1] = stack[-3] // } // Block ends with conditional jump to 0x1c2b, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_1C24: // Incoming jump from 0x1C23, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] 1C24 61 PUSH2 0x1c2b 1C27 61 PUSH2 0x2458 1C2A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C24 stack[0] = 0x1c2b } // Block ends with unconditional jump to 0x2458 label_1C2B: // Incoming jump from 0x1C23, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @1C2E stack[-1] // @1C2F stack[-2] // @1C30 stack[-3] // @1C48 stack[-8] // } 1C2B 5B JUMPDEST 1C2C 60 PUSH1 0x20 1C2E 01 ADD 1C2F 01 ADD 1C30 90 SWAP1 1C31 60 PUSH1 0x01 1C33 60 PUSH1 0x01 1C35 60 PUSH1 0xf8 1C37 1B SHL 1C38 03 SUB 1C39 19 NOT 1C3A 16 AND 1C3B 90 SWAP1 1C3C 81 DUP2 1C3D 60 PUSH1 0x00 1C3F 1A BYTE 1C40 90 SWAP1 1C41 53 MSTORE8 1C42 50 POP 1C43 61 PUSH2 0x1c4d 1C46 60 PUSH1 0x0a 1C48 86 DUP7 1C49 61 PUSH2 0x2596 1C4C 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1C41 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @1C43 stack[-3] = 0x1c4d // @1C46 stack[-2] = 0x0a // @1C48 stack[-1] = stack[-8] // } // Block ends with call to 0x2596, returns to 0x1C4D label_1C4D: // Incoming return from call to 0x2596 at 0x1C4C // Inputs[2] // { // @1C4E stack[-6] // @1C4E stack[-1] // } 1C4D 5B JUMPDEST 1C4E 94 SWAP5 1C4F 50 POP 1C50 61 PUSH2 0x1bed 1C53 56 *JUMP // Stack delta = -1 // Outputs[1] { @1C4E stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x1bed 1C54 5B JUMPDEST 1C55 60 PUSH1 0x00 1C57 60 PUSH1 0x01 1C59 60 PUSH1 0x01 1C5B 60 PUSH1 0xa0 1C5D 1B SHL 1C5E 03 SUB 1C5F 84 DUP5 1C60 16 AND 1C61 3B EXTCODESIZE 1C62 15 ISZERO 1C63 61 PUSH2 0x1d56 1C66 57 *JUMPI 1C67 60 PUSH1 0x40 1C69 51 MLOAD 1C6A 63 PUSH4 0x0a85bd01 1C6F 60 PUSH1 0xe1 1C71 1B SHL 1C72 81 DUP2 1C73 52 MSTORE 1C74 60 PUSH1 0x01 1C76 60 PUSH1 0x01 1C78 60 PUSH1 0xa0 1C7A 1B SHL 1C7B 03 SUB 1C7C 85 DUP6 1C7D 16 AND 1C7E 90 SWAP1 1C7F 63 PUSH4 0x150b7a02 1C84 90 SWAP1 1C85 61 PUSH2 0x1c98 1C88 90 SWAP1 1C89 33 CALLER 1C8A 90 SWAP1 1C8B 89 DUP10 1C8C 90 SWAP1 1C8D 88 DUP9 1C8E 90 SWAP1 1C8F 88 DUP9 1C90 90 SWAP1 1C91 60 PUSH1 0x04 1C93 01 ADD 1C94 61 PUSH2 0x25be 1C97 56 *JUMP 1C98 5B JUMPDEST 1C99 60 PUSH1 0x20 1C9B 60 PUSH1 0x40 1C9D 51 MLOAD 1C9E 80 DUP1 1C9F 83 DUP4 1CA0 03 SUB 1CA1 81 DUP2 1CA2 60 PUSH1 0x00 1CA4 87 DUP8 1CA5 80 DUP1 1CA6 3B EXTCODESIZE 1CA7 15 ISZERO 1CA8 80 DUP1 1CA9 15 ISZERO 1CAA 61 PUSH2 0x1cb2 1CAD 57 *JUMPI 1CAE 60 PUSH1 0x00 1CB0 80 DUP1 1CB1 FD *REVERT 1CB2 5B JUMPDEST 1CB3 50 POP 1CB4 5A GAS 1CB5 F1 CALL 1CB6 92 SWAP3 1CB7 50 POP 1CB8 50 POP 1CB9 50 POP 1CBA 80 DUP1 1CBB 15 ISZERO 1CBC 61 PUSH2 0x1ce2 1CBF 57 *JUMPI 1CC0 50 POP 1CC1 60 PUSH1 0x40 1CC3 80 DUP1 1CC4 51 MLOAD 1CC5 60 PUSH1 0x1f 1CC7 3D RETURNDATASIZE 1CC8 90 SWAP1 1CC9 81 DUP2 1CCA 01 ADD 1CCB 60 PUSH1 0x1f 1CCD 19 NOT 1CCE 16 AND 1CCF 82 DUP3 1CD0 01 ADD 1CD1 90 SWAP1 1CD2 92 SWAP3 1CD3 52 MSTORE 1CD4 61 PUSH2 0x1cdf 1CD7 91 SWAP2 1CD8 81 DUP2 1CD9 01 ADD 1CDA 90 SWAP1 1CDB 61 PUSH2 0x25fb 1CDE 56 *JUMP 1CDF 5B JUMPDEST 1CE0 60 PUSH1 0x01 1CE2 5B JUMPDEST 1CE3 61 PUSH2 0x1d3c 1CE6 57 *JUMPI 1CE7 3D RETURNDATASIZE 1CE8 80 DUP1 1CE9 80 DUP1 1CEA 15 ISZERO 1CEB 61 PUSH2 0x1d10 1CEE 57 *JUMPI 1CEF 60 PUSH1 0x40 1CF1 51 MLOAD 1CF2 91 SWAP2 1CF3 50 POP 1CF4 60 PUSH1 0x1f 1CF6 19 NOT 1CF7 60 PUSH1 0x3f 1CF9 3D RETURNDATASIZE 1CFA 01 ADD 1CFB 16 AND 1CFC 82 DUP3 1CFD 01 ADD 1CFE 60 PUSH1 0x40 1D00 52 MSTORE 1D01 3D RETURNDATASIZE 1D02 82 DUP3 1D03 52 MSTORE 1D04 3D RETURNDATASIZE 1D05 60 PUSH1 0x00 1D07 60 PUSH1 0x20 1D09 84 DUP5 1D0A 01 ADD 1D0B 3E RETURNDATACOPY 1D0C 61 PUSH2 0x1d15 1D0F 56 *JUMP 1D10 5B JUMPDEST 1D11 60 PUSH1 0x60 1D13 91 SWAP2 1D14 50 POP 1D15 5B JUMPDEST 1D16 50 POP 1D17 80 DUP1 1D18 51 MLOAD 1D19 61 PUSH2 0x1d34 1D1C 57 *JUMPI 1D1D 60 PUSH1 0x40 1D1F 51 MLOAD 1D20 62 PUSH3 0x461bcd 1D24 60 PUSH1 0xe5 1D26 1B SHL 1D27 81 DUP2 1D28 52 MSTORE 1D29 60 PUSH1 0x04 1D2B 01 ADD 1D2C 61 PUSH2 0x0541 1D2F 90 SWAP1 1D30 61 PUSH2 0x252e 1D33 56 *JUMP 1D34 5B JUMPDEST 1D35 80 DUP1 1D36 51 MLOAD 1D37 81 DUP2 1D38 60 PUSH1 0x20 1D3A 01 ADD 1D3B FD *REVERT 1D3C 5B JUMPDEST 1D3D 60 PUSH1 0x01 1D3F 60 PUSH1 0x01 1D41 60 PUSH1 0xe0 1D43 1B SHL 1D44 03 SUB 1D45 19 NOT 1D46 16 AND 1D47 63 PUSH4 0x0a85bd01 1D4C 60 PUSH1 0xe1 1D4E 1B SHL 1D4F 14 EQ 1D50 90 SWAP1 1D51 50 POP 1D52 61 PUSH2 0x167d 1D55 56 *JUMP 1D56 5B JUMPDEST 1D57 50 POP 1D58 60 PUSH1 0x01 1D5A 94 SWAP5 1D5B 93 SWAP4 1D5C 50 POP 1D5D 50 POP 1D5E 50 POP 1D5F 50 POP 1D60 56 *JUMP label_1D61: // Incoming jump from 0x05BB // Inputs[2] // { // @1D62 stack[-3] // @1D64 storage[stack[-3]] // } 1D61 5B JUMPDEST 1D62 82 DUP3 1D63 80 DUP1 1D64 54 SLOAD 1D65 61 PUSH2 0x1d6d 1D68 90 SWAP1 1D69 61 PUSH2 0x2381 1D6C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D62 stack[0] = stack[-3] // @1D68 stack[1] = 0x1d6d // @1D68 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x2381, returns to 0x1D6D label_1D6D: // Incoming return from call to 0x2381 at 0x1D6C // Inputs[5] // { // @1D6E stack[-2] // @1D6E stack[-1] // @1D76 memory[0x00:0x20] // @1D81 stack[-4] // @1D82 stack[-3] // } 1D6D 5B JUMPDEST 1D6E 90 SWAP1 1D6F 60 PUSH1 0x00 1D71 52 MSTORE 1D72 60 PUSH1 0x20 1D74 60 PUSH1 0x00 1D76 20 SHA3 1D77 90 SWAP1 1D78 60 PUSH1 0x1f 1D7A 01 ADD 1D7B 60 PUSH1 0x20 1D7D 90 SWAP1 1D7E 04 DIV 1D7F 81 DUP2 1D80 01 ADD 1D81 92 SWAP3 1D82 82 DUP3 1D83 61 PUSH2 0x1d8f 1D86 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1D71 memory[0x00:0x20] = stack[-2] // @1D77 stack[-2] = keccak256(memory[0x00:0x20]) // @1D81 stack[-1] = stack[-4] // @1D81 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x1d8f, if stack[-3] label_1D87: // Incoming jump from 0x1D86, if not stack[-3] // Inputs[1] { @1D89 stack[-5] } 1D87 60 PUSH1 0x00 1D89 85 DUP6 1D8A 55 SSTORE 1D8B 61 PUSH2 0x1dd5 1D8E 56 *JUMP // Stack delta = +0 // Outputs[1] { @1D8A storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x1dd5 label_1D8F: // Incoming jump from 0x1D86, if stack[-3] // Inputs[1] { @1D90 stack[-3] } 1D8F 5B JUMPDEST 1D90 82 DUP3 1D91 60 PUSH1 0x1f 1D93 10 LT 1D94 61 PUSH2 0x1da8 1D97 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1da8, if 0x1f < stack[-3] label_1D98: // Incoming jump from 0x1D97, if not 0x1f < stack[-3] // Inputs[4] // { // @1D98 stack[-3] // @1D9E stack[-1] // @1D9F msg.data[stack[-1]:stack[-1] + 0x20] // @1DA2 stack[-5] // } 1D98 82 DUP3 1D99 80 DUP1 1D9A 01 ADD 1D9B 60 PUSH1 0xff 1D9D 19 NOT 1D9E 82 DUP3 1D9F 35 CALLDATALOAD 1DA0 16 AND 1DA1 17 OR 1DA2 85 DUP6 1DA3 55 SSTORE 1DA4 61 PUSH2 0x1dd5 1DA7 56 *JUMP // Stack delta = +0 // Outputs[1] { @1DA3 storage[stack[-5]] = (msg.data[stack[-1]:stack[-1] + 0x20] & ~0xff) | stack[-3] + stack[-3] } // Block ends with unconditional jump to 0x1dd5 label_1DA8: // Incoming jump from 0x1D97, if 0x1f < stack[-3] // Inputs[2] // { // @1DA9 stack[-3] // @1DAF stack[-5] // } 1DA8 5B JUMPDEST 1DA9 82 DUP3 1DAA 80 DUP1 1DAB 01 ADD 1DAC 60 PUSH1 0x01 1DAE 01 ADD 1DAF 85 DUP6 1DB0 55 SSTORE 1DB1 82 DUP3 1DB2 15 ISZERO 1DB3 61 PUSH2 0x1dd5 1DB6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1DB0 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1dd5, if !stack[-3] label_1DB7: // Incoming jump from 0x1DB6, if not !stack[-3] // Inputs[2] // { // @1DB7 stack[-1] // @1DB7 stack[-3] // } 1DB7 91 SWAP2 1DB8 82 DUP3 1DB9 01 ADD 1DBA 5B JUMPDEST 1DBB 82 DUP3 1DBC 81 DUP2 1DBD 11 GT 1DBE 15 ISZERO 1DBF 61 PUSH2 0x1dd5 1DC2 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1DB7 stack[-3] = stack[-1] // @1DB9 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1dd5, if !(stack[-1] + stack[-3] > stack[-1]) label_1DC3: // Incoming jump from 0x1DC2, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1DC2, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @1DC3 stack[-3] // @1DC4 msg.data[stack[-3]:stack[-3] + 0x20] // @1DC5 stack[-2] // @1DC7 stack[-1] // } 1DC3 82 DUP3 1DC4 35 CALLDATALOAD 1DC5 82 DUP3 1DC6 55 SSTORE 1DC7 91 SWAP2 1DC8 60 PUSH1 0x20 1DCA 01 ADD 1DCB 91 SWAP2 1DCC 90 SWAP1 1DCD 60 PUSH1 0x01 1DCF 01 ADD 1DD0 90 SWAP1 1DD1 61 PUSH2 0x1dba 1DD4 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1DC6 storage[stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20] // @1DCB stack[-3] = 0x20 + stack[-3] // @1DD0 stack[-2] = 0x01 + stack[-2] // @1DD0 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1dba label_1DD5: // Incoming jump from 0x1DA7 // Incoming jump from 0x1E46, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1E12 // Incoming jump from 0x1E2B // Incoming jump from 0x1DB6, if !stack[-3] // Incoming jump from 0x1E46, if !(stack[-1] > stack[-3]) // Incoming jump from 0x1DC2, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1DC2, if !(stack[-1] > stack[-3]) // Incoming jump from 0x1D8E // Incoming jump from 0x1E3A, if !stack[-3] // Inputs[2] // { // @1DDA stack[-4] // @1DDB stack[-3] // } 1DD5 5B JUMPDEST 1DD6 50 POP 1DD7 61 PUSH2 0x1de1 1DDA 92 SWAP3 1DDB 91 SWAP2 1DDC 50 POP 1DDD 61 PUSH2 0x1e59 1DE0 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1DDA stack[-4] = 0x1de1 // @1DDB stack[-3] = stack[-4] // } // Block ends with call to 0x1e59, returns to 0x1DE1 label_1DE1: // Incoming jump from 0x1E62, if !(stack[-2] > stack[-1]) // Incoming jump from 0x1E62, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x1E59 at 0x1DE0 // Inputs[2] // { // @1DE3 stack[-2] // @1DE3 stack[-3] // } 1DE1 5B JUMPDEST 1DE2 50 POP 1DE3 90 SWAP1 1DE4 56 *JUMP // Stack delta = -2 // Outputs[1] { @1DE3 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1DE5: // Incoming jump from 0x1132 // Inputs[2] // { // @1DE6 stack[-3] // @1DE8 storage[stack[-3]] // } 1DE5 5B JUMPDEST 1DE6 82 DUP3 1DE7 80 DUP1 1DE8 54 SLOAD 1DE9 61 PUSH2 0x1df1 1DEC 90 SWAP1 1DED 61 PUSH2 0x2381 1DF0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1DE6 stack[0] = stack[-3] // @1DEC stack[1] = 0x1df1 // @1DEC stack[2] = storage[stack[-3]] // } // Block ends with call to 0x2381, returns to 0x1DF1 label_1DF1: // Incoming return from call to 0x2381 at 0x1DF0 // Inputs[5] // { // @1DF2 stack[-2] // @1DF2 stack[-1] // @1DFA memory[0x00:0x20] // @1E05 stack[-4] // @1E06 stack[-3] // } 1DF1 5B JUMPDEST 1DF2 90 SWAP1 1DF3 60 PUSH1 0x00 1DF5 52 MSTORE 1DF6 60 PUSH1 0x20 1DF8 60 PUSH1 0x00 1DFA 20 SHA3 1DFB 90 SWAP1 1DFC 60 PUSH1 0x1f 1DFE 01 ADD 1DFF 60 PUSH1 0x20 1E01 90 SWAP1 1E02 04 DIV 1E03 81 DUP2 1E04 01 ADD 1E05 92 SWAP3 1E06 82 DUP3 1E07 61 PUSH2 0x1e13 1E0A 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1DF5 memory[0x00:0x20] = stack[-2] // @1DFB stack[-2] = keccak256(memory[0x00:0x20]) // @1E05 stack[-1] = stack[-4] // @1E05 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x1e13, if stack[-3] label_1E0B: // Incoming jump from 0x1E0A, if not stack[-3] // Inputs[1] { @1E0D stack[-5] } 1E0B 60 PUSH1 0x00 1E0D 85 DUP6 1E0E 55 SSTORE 1E0F 61 PUSH2 0x1dd5 1E12 56 *JUMP // Stack delta = +0 // Outputs[1] { @1E0E storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x1dd5 label_1E13: // Incoming jump from 0x1E0A, if stack[-3] // Inputs[1] { @1E14 stack[-3] } 1E13 5B JUMPDEST 1E14 82 DUP3 1E15 60 PUSH1 0x1f 1E17 10 LT 1E18 61 PUSH2 0x1e2c 1E1B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e2c, if 0x1f < stack[-3] label_1E1C: // Incoming jump from 0x1E1B, if not 0x1f < stack[-3] // Inputs[4] // { // @1E1C stack[-1] // @1E1D memory[stack[-1]:stack[-1] + 0x20] // @1E22 stack[-3] // @1E26 stack[-5] // } 1E1C 80 DUP1 1E1D 51 MLOAD 1E1E 60 PUSH1 0xff 1E20 19 NOT 1E21 16 AND 1E22 83 DUP4 1E23 80 DUP1 1E24 01 ADD 1E25 17 OR 1E26 85 DUP6 1E27 55 SSTORE 1E28 61 PUSH2 0x1dd5 1E2B 56 *JUMP // Stack delta = +0 // Outputs[1] { @1E27 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x1dd5 label_1E2C: // Incoming jump from 0x1E1B, if 0x1f < stack[-3] // Inputs[2] // { // @1E2D stack[-3] // @1E33 stack[-5] // } 1E2C 5B JUMPDEST 1E2D 82 DUP3 1E2E 80 DUP1 1E2F 01 ADD 1E30 60 PUSH1 0x01 1E32 01 ADD 1E33 85 DUP6 1E34 55 SSTORE 1E35 82 DUP3 1E36 15 ISZERO 1E37 61 PUSH2 0x1dd5 1E3A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1E34 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1dd5, if !stack[-3] label_1E3B: // Incoming jump from 0x1E3A, if not !stack[-3] // Inputs[2] // { // @1E3B stack[-3] // @1E3B stack[-1] // } 1E3B 91 SWAP2 1E3C 82 DUP3 1E3D 01 ADD 1E3E 5B JUMPDEST 1E3F 82 DUP3 1E40 81 DUP2 1E41 11 GT 1E42 15 ISZERO 1E43 61 PUSH2 0x1dd5 1E46 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1E3B stack[-3] = stack[-1] // @1E3D stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1dd5, if !(stack[-1] + stack[-3] > stack[-1]) label_1E47: // Incoming jump from 0x1E46, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1E46, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @1E47 stack[-3] // @1E48 memory[stack[-3]:stack[-3] + 0x20] // @1E49 stack[-2] // @1E4B stack[-1] // } 1E47 82 DUP3 1E48 51 MLOAD 1E49 82 DUP3 1E4A 55 SSTORE 1E4B 91 SWAP2 1E4C 60 PUSH1 0x20 1E4E 01 ADD 1E4F 91 SWAP2 1E50 90 SWAP1 1E51 60 PUSH1 0x01 1E53 01 ADD 1E54 90 SWAP1 1E55 61 PUSH2 0x1e3e 1E58 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1E4A storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1E4F stack[-3] = 0x20 + stack[-3] // @1E54 stack[-2] = 0x01 + stack[-2] // @1E54 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1e3e label_1E59: // Incoming call from 0x1DE0, returns to 0x1DE1 // Inputs[2] // { // @1E5B stack[-1] // @1E5C stack[-2] // } 1E59 5B JUMPDEST 1E5A 5B JUMPDEST 1E5B 80 DUP1 1E5C 82 DUP3 1E5D 11 GT 1E5E 15 ISZERO 1E5F 61 PUSH2 0x1de1 1E62 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1de1, if !(stack[-2] > stack[-1]) label_1E63: // Incoming jump from 0x1E62, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1E62, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1E65 stack[-1] } 1E63 60 PUSH1 0x00 1E65 81 DUP2 1E66 55 SSTORE 1E67 60 PUSH1 0x01 1E69 01 ADD 1E6A 61 PUSH2 0x1e5a 1E6D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1E66 storage[stack[-1]] = 0x00 // @1E69 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1e5a label_1E6E: // Incoming call from 0x1EA0, returns to 0x1299 // Inputs[1] { @1E78 stack[-1] } 1E6E 5B JUMPDEST 1E6F 60 PUSH1 0x01 1E71 60 PUSH1 0x01 1E73 60 PUSH1 0xe0 1E75 1B SHL 1E76 03 SUB 1E77 19 NOT 1E78 81 DUP2 1E79 16 AND 1E7A 81 DUP2 1E7B 14 EQ 1E7C 61 PUSH2 0x0a15 1E7F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a15, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1E80: // Incoming jump from 0x1E7F, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1E83 memory[0x00:0x00] } 1E80 60 PUSH1 0x00 1E82 80 DUP1 1E83 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E83 revert(memory[0x00:0x00]); } // Block terminates label_1E84: // Incoming call from 0x0218, returns to 0x0219 // Inputs[2] // { // @1E89 stack[-1] // @1E8A stack[-2] // } 1E84 5B JUMPDEST 1E85 60 PUSH1 0x00 1E87 60 PUSH1 0x20 1E89 82 DUP3 1E8A 84 DUP5 1E8B 03 SUB 1E8C 12 SLT 1E8D 15 ISZERO 1E8E 61 PUSH2 0x1e96 1E91 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E85 stack[0] = 0x00 } // Block ends with conditional jump to 0x1e96, if !(stack[-2] - stack[-1] i< 0x20) label_1E92: // Incoming jump from 0x1E91, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1E95 memory[0x00:0x00] } 1E92 60 PUSH1 0x00 1E94 80 DUP1 1E95 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E95 revert(memory[0x00:0x00]); } // Block terminates label_1E96: // Incoming jump from 0x1E91, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E97 stack[-2] // @1E98 msg.data[stack[-2]:stack[-2] + 0x20] // } 1E96 5B JUMPDEST 1E97 81 DUP2 1E98 35 CALLDATALOAD 1E99 61 PUSH2 0x1299 1E9C 81 DUP2 1E9D 61 PUSH2 0x1e6e 1EA0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E98 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1E99 stack[1] = 0x1299 // @1E9C stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1e6e, returns to 0x1299 label_1EA1: // Incoming call from 0x0240, returns to 0x0241 // Inputs[2] // { // @1EA7 stack[-1] // @1EA8 stack[-2] // } 1EA1 5B JUMPDEST 1EA2 60 PUSH1 0x00 1EA4 80 DUP1 1EA5 60 PUSH1 0x20 1EA7 83 DUP4 1EA8 85 DUP6 1EA9 03 SUB 1EAA 12 SLT 1EAB 15 ISZERO 1EAC 61 PUSH2 0x1eb4 1EAF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1EA2 stack[0] = 0x00 // @1EA4 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1eb4, if !(stack[-2] - stack[-1] i< 0x20) label_1EB0: // Incoming jump from 0x1EAF, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1EB3 memory[0x00:0x00] } 1EB0 60 PUSH1 0x00 1EB2 80 DUP1 1EB3 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EB3 revert(memory[0x00:0x00]); } // Block terminates label_1EB4: // Incoming jump from 0x1EAF, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1EB5 stack[-3] // @1EB6 msg.data[stack[-3]:stack[-3] + 0x20] // } 1EB4 5B JUMPDEST 1EB5 82 DUP3 1EB6 35 CALLDATALOAD 1EB7 67 PUSH8 0xffffffffffffffff 1EC0 80 DUP1 1EC1 82 DUP3 1EC2 11 GT 1EC3 15 ISZERO 1EC4 61 PUSH2 0x1ecc 1EC7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1EB6 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1EB7 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1ecc, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1EC8: // Incoming jump from 0x1EC7, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1ECB memory[0x00:0x00] } 1EC8 60 PUSH1 0x00 1ECA 80 DUP1 1ECB FD *REVERT // Stack delta = +0 // Outputs[1] { @1ECB revert(memory[0x00:0x00]); } // Block terminates label_1ECC: // Incoming jump from 0x1EC7, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1ECD stack[-2] // @1ECE stack[-5] // @1ED2 stack[-6] // } 1ECC 5B JUMPDEST 1ECD 81 DUP2 1ECE 85 DUP6 1ECF 01 ADD 1ED0 91 SWAP2 1ED1 50 POP 1ED2 85 DUP6 1ED3 60 PUSH1 0x1f 1ED5 83 DUP4 1ED6 01 ADD 1ED7 12 SLT 1ED8 61 PUSH2 0x1ee0 1EDB 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1ED0 stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x1ee0, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_1EDC: // Incoming jump from 0x1EDB, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @1EDF memory[0x00:0x00] } 1EDC 60 PUSH1 0x00 1EDE 80 DUP1 1EDF FD *REVERT // Stack delta = +0 // Outputs[1] { @1EDF revert(memory[0x00:0x00]); } // Block terminates label_1EE0: // Incoming jump from 0x1EDB, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @1EE1 stack[-2] // @1EE2 msg.data[stack[-2]:stack[-2] + 0x20] // @1EE3 stack[-1] // } 1EE0 5B JUMPDEST 1EE1 81 DUP2 1EE2 35 CALLDATALOAD 1EE3 81 DUP2 1EE4 81 DUP2 1EE5 11 GT 1EE6 15 ISZERO 1EE7 61 PUSH2 0x1eef 1EEA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1EE2 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1eef, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_1EEB: // Incoming jump from 0x1EEA, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @1EEE memory[0x00:0x00] } 1EEB 60 PUSH1 0x00 1EED 80 DUP1 1EEE FD *REVERT // Stack delta = +0 // Outputs[1] { @1EEE revert(memory[0x00:0x00]); } // Block terminates label_1EEF: // Incoming jump from 0x1EEA, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @1EF0 stack[-7] // @1EF3 stack[-1] // @1EF4 stack[-3] // } 1EEF 5B JUMPDEST 1EF0 86 DUP7 1EF1 60 PUSH1 0x20 1EF3 82 DUP3 1EF4 85 DUP6 1EF5 01 ADD 1EF6 01 ADD 1EF7 11 GT 1EF8 15 ISZERO 1EF9 61 PUSH2 0x1f01 1EFC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f01, if !(stack[-3] + stack[-1] + 0x20 > stack[-7]) label_1EFD: // Incoming jump from 0x1EFC, if not !(stack[-3] + stack[-1] + 0x20 > stack[-7]) // Inputs[1] { @1F00 memory[0x00:0x00] } 1EFD 60 PUSH1 0x00 1EFF 80 DUP1 1F00 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F00 revert(memory[0x00:0x00]); } // Block terminates label_1F01: // Incoming jump from 0x1EFC, if !(stack[-3] + stack[-1] + 0x20 > stack[-7]) // Inputs[6] // { // @1F04 stack[-3] // @1F05 stack[-1] // @1F08 stack[-8] // @1F0A stack[-7] // @1F0C stack[-2] // @1F0D stack[-6] // } 1F01 5B JUMPDEST 1F02 60 PUSH1 0x20 1F04 92 SWAP3 1F05 90 SWAP1 1F06 92 SWAP3 1F07 01 ADD 1F08 96 SWAP7 1F09 91 SWAP2 1F0A 95 SWAP6 1F0B 50 POP 1F0C 90 SWAP1 1F0D 93 SWAP4 1F0E 50 POP 1F0F 50 POP 1F10 50 POP 1F11 50 POP 1F12 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @1F08 stack[-8] = 0x20 + stack[-3] // @1F0A stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_1F13: // Incoming call from 0x1F56, returns to 0x1F57 // Incoming call from 0x24F3, returns to 0x24F4 // Incoming call from 0x24DF, returns to 0x24E0 // Incoming call from 0x2506, returns to 0x2507 // Inputs[1] { @1F17 stack[-3] } 1F13 5B JUMPDEST 1F14 60 PUSH1 0x00 1F16 5B JUMPDEST 1F17 83 DUP4 1F18 81 DUP2 1F19 10 LT 1F1A 15 ISZERO 1F1B 61 PUSH2 0x1f2e 1F1E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F14 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f2e, if !(0x00 < stack[-3]) label_1F1F: // Incoming jump from 0x1F1E, if not !(0x00 < stack[-3]) // Incoming jump from 0x1F1E, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @1F1F stack[-2] // @1F20 stack[-1] // @1F22 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1F23 stack[-3] // } 1F1F 81 DUP2 1F20 81 DUP2 1F21 01 ADD 1F22 51 MLOAD 1F23 83 DUP4 1F24 82 DUP3 1F25 01 ADD 1F26 52 MSTORE 1F27 60 PUSH1 0x20 1F29 01 ADD 1F2A 61 PUSH2 0x1f16 1F2D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1F26 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1F29 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1f16 label_1F2E: // Incoming jump from 0x1F1E, if !(0x00 < stack[-3]) // Incoming jump from 0x1F1E, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @1F2F stack[-4] // @1F30 stack[-1] // } 1F2E 5B JUMPDEST 1F2F 83 DUP4 1F30 81 DUP2 1F31 11 GT 1F32 15 ISZERO 1F33 61 PUSH2 0x104b 1F36 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x104b, if !(stack[-1] > stack[-4]) label_1F37: // Incoming jump from 0x1F36, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @1F3B stack[-4] // @1F3C stack[-3] // @1F3E stack[-5] // } 1F37 50 POP 1F38 50 POP 1F39 60 PUSH1 0x00 1F3B 91 SWAP2 1F3C 01 ADD 1F3D 52 MSTORE 1F3E 56 *JUMP // Stack delta = -5 // Outputs[1] { @1F3D memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1F3F: // Incoming call from 0x1F7D, returns to 0x1299 // Inputs[3] // { // @1F42 stack[-1] // @1F43 memory[stack[-1]:stack[-1] + 0x20] // @1F45 stack[-2] // } 1F3F 5B JUMPDEST 1F40 60 PUSH1 0x00 1F42 81 DUP2 1F43 51 MLOAD 1F44 80 DUP1 1F45 84 DUP5 1F46 52 MSTORE 1F47 61 PUSH2 0x1f57 1F4A 81 DUP2 1F4B 60 PUSH1 0x20 1F4D 86 DUP7 1F4E 01 ADD 1F4F 60 PUSH1 0x20 1F51 86 DUP7 1F52 01 ADD 1F53 61 PUSH2 0x1f13 1F56 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1F40 stack[0] = 0x00 // @1F43 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1F46 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1F47 stack[2] = 0x1f57 // @1F4A stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1F4E stack[4] = stack[-2] + 0x20 // @1F52 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x1f13, returns to 0x1F57 label_1F57: // Incoming return from call to 0x1F13 at 0x1F56 // Inputs[4] // { // @1F5A stack[-1] // @1F5F stack[-4] // @1F60 stack[-2] // @1F66 stack[-5] // } 1F57 5B JUMPDEST 1F58 60 PUSH1 0x1f 1F5A 01 ADD 1F5B 60 PUSH1 0x1f 1F5D 19 NOT 1F5E 16 AND 1F5F 92 SWAP3 1F60 90 SWAP1 1F61 92 SWAP3 1F62 01 ADD 1F63 60 PUSH1 0x20 1F65 01 ADD 1F66 92 SWAP3 1F67 91 SWAP2 1F68 50 POP 1F69 50 POP 1F6A 56 *JUMP // Stack delta = -4 // Outputs[1] { @1F66 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1F6B: // Incoming call from 0x025C, returns to 0x022A // Inputs[2] // { // @1F6E stack[-1] // @1F79 stack[-2] // } 1F6B 5B JUMPDEST 1F6C 60 PUSH1 0x20 1F6E 81 DUP2 1F6F 52 MSTORE 1F70 60 PUSH1 0x00 1F72 61 PUSH2 0x1299 1F75 60 PUSH1 0x20 1F77 83 DUP4 1F78 01 ADD 1F79 84 DUP5 1F7A 61 PUSH2 0x1f3f 1F7D 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1F6F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1F70 stack[0] = 0x00 // @1F72 stack[1] = 0x1299 // @1F78 stack[2] = stack[-1] + 0x20 // @1F79 stack[3] = stack[-2] // } // Block ends with call to 0x1f3f, returns to 0x1299 label_1F7E: // Incoming call from 0x0322, returns to 0x0323 // Incoming call from 0x026A, returns to 0x026B // Incoming call from 0x0348, returns to 0x0349 // Incoming call from 0x0431, returns to 0x0432 // Incoming call from 0x0364, returns to 0x0365 // Inputs[2] // { // @1F83 stack[-1] // @1F84 stack[-2] // } 1F7E 5B JUMPDEST 1F7F 60 PUSH1 0x00 1F81 60 PUSH1 0x20 1F83 82 DUP3 1F84 84 DUP5 1F85 03 SUB 1F86 12 SLT 1F87 15 ISZERO 1F88 61 PUSH2 0x1f90 1F8B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F7F stack[0] = 0x00 } // Block ends with conditional jump to 0x1f90, if !(stack[-2] - stack[-1] i< 0x20) label_1F8C: // Incoming jump from 0x1F8B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1F8F memory[0x00:0x00] } 1F8C 60 PUSH1 0x00 1F8E 80 DUP1 1F8F FD *REVERT // Stack delta = +0 // Outputs[1] { @1F8F revert(memory[0x00:0x00]); } // Block terminates label_1F90: // Incoming jump from 0x1F8B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1F92 msg.data[stack[-2]:stack[-2] + 0x20] // @1F92 stack[-2] // @1F93 stack[-4] // @1F94 stack[-3] // } 1F90 5B JUMPDEST 1F91 50 POP 1F92 35 CALLDATALOAD 1F93 91 SWAP2 1F94 90 SWAP1 1F95 50 POP 1F96 56 *JUMP // Stack delta = -3 // Outputs[1] { @1F93 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1F97: // Incoming call from 0x204F, returns to 0x2050 // Incoming call from 0x227A, returns to 0x227B // Incoming call from 0x252D, returns to 0x1299 // Incoming call from 0x21A6, returns to 0x21A7 // Incoming call from 0x226A, returns to 0x226B // Incoming call from 0x203F, returns to 0x2040 // Incoming call from 0x2330, returns to 0x2331 // Incoming call from 0x1FC9, returns to 0x1FCA // Incoming call from 0x2340, returns to 0x2341 // Incoming call from 0x1FF4, returns to 0x1299 // Inputs[1] { @1FA0 stack[-1] } 1F97 5B JUMPDEST 1F98 60 PUSH1 0x01 1F9A 60 PUSH1 0x01 1F9C 60 PUSH1 0xa0 1F9E 1B SHL 1F9F 03 SUB 1FA0 81 DUP2 1FA1 16 AND 1FA2 81 DUP2 1FA3 14 EQ 1FA4 61 PUSH2 0x0a15 1FA7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a15, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 label_1FA8: // Incoming jump from 0x1FA7, if not stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1FAB memory[0x00:0x00] } 1FA8 60 PUSH1 0x00 1FAA 80 DUP1 1FAB FD *REVERT // Stack delta = +0 // Outputs[1] { @1FAB revert(memory[0x00:0x00]); } // Block terminates label_1FAC: // Incoming call from 0x04AC, returns to 0x04AD // Incoming call from 0x0295, returns to 0x0296 // Inputs[2] // { // @1FB2 stack[-1] // @1FB3 stack[-2] // } 1FAC 5B JUMPDEST 1FAD 60 PUSH1 0x00 1FAF 80 DUP1 1FB0 60 PUSH1 0x40 1FB2 83 DUP4 1FB3 85 DUP6 1FB4 03 SUB 1FB5 12 SLT 1FB6 15 ISZERO 1FB7 61 PUSH2 0x1fbf 1FBA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1FAD stack[0] = 0x00 // @1FAF stack[1] = 0x00 // } // Block ends with conditional jump to 0x1fbf, if !(stack[-2] - stack[-1] i< 0x40) label_1FBB: // Incoming jump from 0x1FBA, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1FBE memory[0x00:0x00] } 1FBB 60 PUSH1 0x00 1FBD 80 DUP1 1FBE FD *REVERT // Stack delta = +0 // Outputs[1] { @1FBE revert(memory[0x00:0x00]); } // Block terminates label_1FBF: // Incoming jump from 0x1FBA, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1FC0 stack[-3] // @1FC1 msg.data[stack[-3]:stack[-3] + 0x20] // } 1FBF 5B JUMPDEST 1FC0 82 DUP3 1FC1 35 CALLDATALOAD 1FC2 61 PUSH2 0x1fca 1FC5 81 DUP2 1FC6 61 PUSH2 0x1f97 1FC9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1FC1 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1FC2 stack[1] = 0x1fca // @1FC5 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x1f97, returns to 0x1FCA label_1FCA: // Incoming return from call to 0x1F97 at 0x1FC9 // Inputs[5] // { // @1FCB stack[-1] // @1FCB stack[-6] // @1FCE stack[-4] // @1FD2 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1FD3 stack[-5] // } 1FCA 5B JUMPDEST 1FCB 94 SWAP5 1FCC 60 PUSH1 0x20 1FCE 93 SWAP4 1FCF 90 SWAP1 1FD0 93 SWAP4 1FD1 01 ADD 1FD2 35 CALLDATALOAD 1FD3 93 SWAP4 1FD4 50 POP 1FD5 50 POP 1FD6 50 POP 1FD7 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1FCB stack[-6] = stack[-1] // @1FD3 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_1FD8: // Incoming call from 0x0B1D, returns to 0x0B1E // Incoming call from 0x0B4D, returns to 0x0B4E // Incoming call from 0x0E52, returns to 0x0E53 // Incoming call from 0x03CA, returns to 0x03CB // Incoming call from 0x0377, returns to 0x0378 // Incoming call from 0x02A8, returns to 0x02A9 // Incoming call from 0x04BF, returns to 0x04C0 // Inputs[2] // { // @1FDD stack[-1] // @1FDE stack[-2] // } 1FD8 5B JUMPDEST 1FD9 60 PUSH1 0x00 1FDB 60 PUSH1 0x20 1FDD 82 DUP3 1FDE 84 DUP5 1FDF 03 SUB 1FE0 12 SLT 1FE1 15 ISZERO 1FE2 61 PUSH2 0x1fea 1FE5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1FD9 stack[0] = 0x00 } // Block ends with conditional jump to 0x1fea, if !(stack[-2] - stack[-1] i< 0x20) label_1FE6: // Incoming jump from 0x1FE5, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1FE9 memory[0x00:0x00] } 1FE6 60 PUSH1 0x00 1FE8 80 DUP1 1FE9 FD *REVERT // Stack delta = +0 // Outputs[1] { @1FE9 revert(memory[0x00:0x00]); } // Block terminates label_1FEA: // Incoming jump from 0x1FE5, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1FEB stack[-2] // @1FEC msg.data[stack[-2]:stack[-2] + 0x20] // } 1FEA 5B JUMPDEST 1FEB 81 DUP2 1FEC 35 CALLDATALOAD 1FED 61 PUSH2 0x1299 1FF0 81 DUP2 1FF1 61 PUSH2 0x1f97 1FF4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1FEC stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1FED stack[1] = 0x1299 // @1FF0 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1f97, returns to 0x1299 label_1FF5: // Incoming call from 0x21B4, returns to 0x21B5 // Incoming call from 0x201F, returns to 0x1299 // Inputs[2] // { // @1FF6 stack[-1] // @1FF7 msg.data[stack[-1]:stack[-1] + 0x20] // } 1FF5 5B JUMPDEST 1FF6 80 DUP1 1FF7 35 CALLDATALOAD 1FF8 80 DUP1 1FF9 15 ISZERO 1FFA 15 ISZERO 1FFB 81 DUP2 1FFC 14 EQ 1FFD 61 PUSH2 0x1593 2000 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1FF7 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1593, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_2001: // Incoming jump from 0x2000, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @2004 memory[0x00:0x00] } 2001 60 PUSH1 0x00 2003 80 DUP1 2004 FD *REVERT // Stack delta = +0 // Outputs[1] { @2004 revert(memory[0x00:0x00]); } // Block terminates label_2005: // Incoming call from 0x02F3, returns to 0x02F4 // Incoming call from 0x02BB, returns to 0x02BC // Inputs[2] // { // @200A stack[-1] // @200B stack[-2] // } 2005 5B JUMPDEST 2006 60 PUSH1 0x00 2008 60 PUSH1 0x20 200A 82 DUP3 200B 84 DUP5 200C 03 SUB 200D 12 SLT 200E 15 ISZERO 200F 61 PUSH2 0x2017 2012 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2006 stack[0] = 0x00 } // Block ends with conditional jump to 0x2017, if !(stack[-2] - stack[-1] i< 0x20) label_2013: // Incoming jump from 0x2012, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2016 memory[0x00:0x00] } 2013 60 PUSH1 0x00 2015 80 DUP1 2016 FD *REVERT // Stack delta = +0 // Outputs[1] { @2016 revert(memory[0x00:0x00]); } // Block terminates label_2017: // Incoming jump from 0x2012, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @201B stack[-2] } 2017 5B JUMPDEST 2018 61 PUSH2 0x1299 201B 82 DUP3 201C 61 PUSH2 0x1ff5 201F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2018 stack[0] = 0x1299 // @201B stack[1] = stack[-2] // } // Block ends with call to 0x1ff5, returns to 0x1299 label_2020: // Incoming call from 0x030F, returns to 0x0310 // Incoming call from 0x02E0, returns to 0x02E1 // Inputs[2] // { // @2028 stack[-1] // @2029 stack[-2] // } 2020 5B JUMPDEST 2021 60 PUSH1 0x00 2023 80 DUP1 2024 60 PUSH1 0x00 2026 60 PUSH1 0x60 2028 84 DUP5 2029 86 DUP7 202A 03 SUB 202B 12 SLT 202C 15 ISZERO 202D 61 PUSH2 0x2035 2030 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2021 stack[0] = 0x00 // @2023 stack[1] = 0x00 // @2024 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2035, if !(stack[-2] - stack[-1] i< 0x60) label_2031: // Incoming jump from 0x2030, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2034 memory[0x00:0x00] } 2031 60 PUSH1 0x00 2033 80 DUP1 2034 FD *REVERT // Stack delta = +0 // Outputs[1] { @2034 revert(memory[0x00:0x00]); } // Block terminates label_2035: // Incoming jump from 0x2030, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @2036 stack[-4] // @2037 msg.data[stack[-4]:stack[-4] + 0x20] // } 2035 5B JUMPDEST 2036 83 DUP4 2037 35 CALLDATALOAD 2038 61 PUSH2 0x2040 203B 81 DUP2 203C 61 PUSH2 0x1f97 203F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2037 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @2038 stack[1] = 0x2040 // @203B stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x1f97, returns to 0x2040 label_2040: // Incoming return from call to 0x1F97 at 0x203F // Inputs[4] // { // @2041 stack[-1] // @2041 stack[-4] // @2045 stack[-5] // @2047 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 2040 5B JUMPDEST 2041 92 SWAP3 2042 50 POP 2043 60 PUSH1 0x20 2045 84 DUP5 2046 01 ADD 2047 35 CALLDATALOAD 2048 61 PUSH2 0x2050 204B 81 DUP2 204C 61 PUSH2 0x1f97 204F 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2041 stack[-4] = stack[-1] // @2047 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2048 stack[0] = 0x2050 // @204B stack[1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x1f97, returns to 0x2050 label_2050: // Incoming return from call to 0x1F97 at 0x204F // Inputs[6] // { // @2051 stack[-1] // @2051 stack[-4] // @2052 stack[-7] // @2054 stack[-6] // @205A stack[-5] // @205E msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } 2050 5B JUMPDEST 2051 92 SWAP3 2052 95 SWAP6 2053 92 SWAP3 2054 94 SWAP5 2055 50 POP 2056 50 POP 2057 50 POP 2058 60 PUSH1 0x40 205A 91 SWAP2 205B 90 SWAP1 205C 91 SWAP2 205D 01 ADD 205E 35 CALLDATALOAD 205F 90 SWAP1 2060 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2052 stack[-7] = stack[-4] // @2054 stack[-6] = stack[-1] // @205F stack[-5] = msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } // Block ends with unconditional jump to stack[-7] label_2061: // Incoming call from 0x2134, returns to 0x2135 // Incoming call from 0x210E, returns to 0x210F // Incoming call from 0x20E9, returns to 0x20EA // Incoming call from 0x217C, returns to 0x217D // Inputs[2] // { // @2065 stack[-2] // @2068 stack[-1] // } 2061 5B JUMPDEST 2062 60 PUSH1 0x00 2064 80 DUP1 2065 83 DUP4 2066 60 PUSH1 0x1f 2068 84 DUP5 2069 01 ADD 206A 12 SLT 206B 61 PUSH2 0x2073 206E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2062 stack[0] = 0x00 // @2064 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2073, if stack[-1] + 0x1f i< stack[-2] label_206F: // Incoming jump from 0x206E, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @2072 memory[0x00:0x00] } 206F 60 PUSH1 0x00 2071 80 DUP1 2072 FD *REVERT // Stack delta = +0 // Outputs[1] { @2072 revert(memory[0x00:0x00]); } // Block terminates label_2073: // Incoming jump from 0x206E, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @2075 stack[-3] // @2076 msg.data[stack[-3]:stack[-3] + 0x20] // } 2073 5B JUMPDEST 2074 50 POP 2075 81 DUP2 2076 35 CALLDATALOAD 2077 67 PUSH8 0xffffffffffffffff 2080 81 DUP2 2081 11 GT 2082 15 ISZERO 2083 61 PUSH2 0x208b 2086 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2076 stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x208b, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_2087: // Incoming jump from 0x2086, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @208A memory[0x00:0x00] } 2087 60 PUSH1 0x00 2089 80 DUP1 208A FD *REVERT // Stack delta = +0 // Outputs[1] { @208A revert(memory[0x00:0x00]); } // Block terminates label_208B: // Incoming jump from 0x2086, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @208E stack[-3] // @2090 stack[-2] // @2092 stack[-4] // @2095 stack[-1] // } 208B 5B JUMPDEST 208C 60 PUSH1 0x20 208E 83 DUP4 208F 01 ADD 2090 91 SWAP2 2091 50 POP 2092 83 DUP4 2093 60 PUSH1 0x20 2095 82 DUP3 2096 60 PUSH1 0x05 2098 1B SHL 2099 85 DUP6 209A 01 ADD 209B 01 ADD 209C 11 GT 209D 15 ISZERO 209E 61 PUSH2 0x20a6 20A1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2090 stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x20a6, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) label_20A2: // Incoming jump from 0x20A1, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Inputs[1] { @20A5 memory[0x00:0x00] } 20A2 60 PUSH1 0x00 20A4 80 DUP1 20A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @20A5 revert(memory[0x00:0x00]); } // Block terminates label_20A6: // Incoming jump from 0x20A1, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Inputs[5] // { // @20A7 stack[-4] // @20A7 stack[-1] // @20A9 stack[-2] // @20A9 stack[-5] // @20AA stack[-3] // } 20A6 5B JUMPDEST 20A7 92 SWAP3 20A8 50 POP 20A9 92 SWAP3 20AA 90 SWAP1 20AB 50 POP 20AC 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @20A7 stack[-4] = stack[-1] // @20A9 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_20AD: // Incoming call from 0x0335, returns to 0x0336 // Inputs[2] // { // @20B9 stack[-1] // @20BA stack[-2] // } 20AD 5B JUMPDEST 20AE 60 PUSH1 0x00 20B0 80 DUP1 20B1 60 PUSH1 0x00 20B3 80 DUP1 20B4 60 PUSH1 0x00 20B6 80 DUP1 20B7 60 PUSH1 0x60 20B9 87 DUP8 20BA 89 DUP10 20BB 03 SUB 20BC 12 SLT 20BD 15 ISZERO 20BE 61 PUSH2 0x20c6 20C1 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @20AE stack[0] = 0x00 // @20B0 stack[1] = 0x00 // @20B1 stack[2] = 0x00 // @20B3 stack[3] = 0x00 // @20B4 stack[4] = 0x00 // @20B6 stack[5] = 0x00 // } // Block ends with conditional jump to 0x20c6, if !(stack[-2] - stack[-1] i< 0x60) label_20C2: // Incoming jump from 0x20C1, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @20C5 memory[0x00:0x00] } 20C2 60 PUSH1 0x00 20C4 80 DUP1 20C5 FD *REVERT // Stack delta = +0 // Outputs[1] { @20C5 revert(memory[0x00:0x00]); } // Block terminates label_20C6: // Incoming jump from 0x20C1, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @20C7 stack[-7] // @20C8 msg.data[stack[-7]:stack[-7] + 0x20] // } 20C6 5B JUMPDEST 20C7 86 DUP7 20C8 35 CALLDATALOAD 20C9 67 PUSH8 0xffffffffffffffff 20D2 80 DUP1 20D3 82 DUP3 20D4 11 GT 20D5 15 ISZERO 20D6 61 PUSH2 0x20de 20D9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20C8 stack[0] = msg.data[stack[-7]:stack[-7] + 0x20] // @20C9 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x20de, if !(msg.data[stack[-7]:stack[-7] + 0x20] > 0xffffffffffffffff) label_20DA: // Incoming jump from 0x20D9, if not !(msg.data[stack[-7]:stack[-7] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @20DD memory[0x00:0x00] } 20DA 60 PUSH1 0x00 20DC 80 DUP1 20DD FD *REVERT // Stack delta = +0 // Outputs[1] { @20DD revert(memory[0x00:0x00]); } // Block terminates label_20DE: // Incoming jump from 0x20D9, if !(msg.data[stack[-7]:stack[-7] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @20E2 stack[-10] // @20E3 stack[-2] // @20E4 stack[-9] // } 20DE 5B JUMPDEST 20DF 61 PUSH2 0x20ea 20E2 8A DUP11 20E3 83 DUP4 20E4 8B DUP12 20E5 01 ADD 20E6 61 PUSH2 0x2061 20E9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @20DF stack[0] = 0x20ea // @20E2 stack[1] = stack[-10] // @20E5 stack[2] = stack[-9] + stack[-2] // } // Block ends with call to 0x2061, returns to 0x20EA label_20EA: // Incoming return from call to 0x2061 at 0x20E9 // Inputs[8] // { // @20EB stack[-2] // @20EB stack[-1] // @20EC stack[-10] // @20EE stack[-9] // @20F2 stack[-11] // @20F4 msg.data[stack[-11] + 0x20:stack[-11] + 0x20 + 0x20] // @20F5 stack[-4] // @20F7 stack[-3] // } 20EA 5B JUMPDEST 20EB 90 SWAP1 20EC 98 SWAP9 20ED 50 POP 20EE 96 SWAP7 20EF 50 POP 20F0 60 PUSH1 0x20 20F2 89 DUP10 20F3 01 ADD 20F4 35 CALLDATALOAD 20F5 91 SWAP2 20F6 50 POP 20F7 80 DUP1 20F8 82 DUP3 20F9 11 GT 20FA 15 ISZERO 20FB 61 PUSH2 0x2103 20FE 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @20EC stack[-10] = stack[-2] // @20EE stack[-9] = stack[-1] // @20F5 stack[-4] = msg.data[stack[-11] + 0x20:stack[-11] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2103, if !(msg.data[stack[-11] + 0x20:stack[-11] + 0x20 + 0x20] > stack[-3]) label_20FF: // Incoming jump from 0x20FE, if not !(msg.data[stack[-11] + 0x20:stack[-11] + 0x20 + 0x20] > stack[-3]) // Inputs[1] { @2102 memory[0x00:0x00] } 20FF 60 PUSH1 0x00 2101 80 DUP1 2102 FD *REVERT // Stack delta = +0 // Outputs[1] { @2102 revert(memory[0x00:0x00]); } // Block terminates label_2103: // Incoming jump from 0x20FE, if !(msg.data[stack[-11] + 0x20:stack[-11] + 0x20 + 0x20] > stack[-3]) // Inputs[3] // { // @2107 stack[-10] // @2108 stack[-2] // @2109 stack[-9] // } 2103 5B JUMPDEST 2104 61 PUSH2 0x210f 2107 8A DUP11 2108 83 DUP4 2109 8B DUP12 210A 01 ADD 210B 61 PUSH2 0x2061 210E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2104 stack[0] = 0x210f // @2107 stack[1] = stack[-10] // @210A stack[2] = stack[-9] + stack[-2] // } // Block ends with call to 0x2061, returns to 0x210F label_210F: // Incoming return from call to 0x2061 at 0x210E // Inputs[8] // { // @2110 stack[-2] // @2110 stack[-1] // @2111 stack[-8] // @2113 stack[-7] // @2117 stack[-11] // @2119 msg.data[stack[-11] + 0x40:stack[-11] + 0x40 + 0x20] // @211A stack[-4] // @211C stack[-3] // } 210F 5B JUMPDEST 2110 90 SWAP1 2111 96 SWAP7 2112 50 POP 2113 94 SWAP5 2114 50 POP 2115 60 PUSH1 0x40 2117 89 DUP10 2118 01 ADD 2119 35 CALLDATALOAD 211A 91 SWAP2 211B 50 POP 211C 80 DUP1 211D 82 DUP3 211E 11 GT 211F 15 ISZERO 2120 61 PUSH2 0x2128 2123 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @2111 stack[-8] = stack[-2] // @2113 stack[-7] = stack[-1] // @211A stack[-4] = msg.data[stack[-11] + 0x40:stack[-11] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x2128, if !(msg.data[stack[-11] + 0x40:stack[-11] + 0x40 + 0x20] > stack[-3]) label_2124: // Incoming jump from 0x2123, if not !(msg.data[stack[-11] + 0x40:stack[-11] + 0x40 + 0x20] > stack[-3]) // Inputs[1] { @2127 memory[0x00:0x00] } 2124 60 PUSH1 0x00 2126 80 DUP1 2127 FD *REVERT // Stack delta = +0 // Outputs[1] { @2127 revert(memory[0x00:0x00]); } // Block terminates label_2128: // Incoming jump from 0x2123, if !(msg.data[stack[-11] + 0x40:stack[-11] + 0x40 + 0x20] > stack[-3]) // Inputs[3] // { // @212D stack[-10] // @212E stack[-2] // @212F stack[-9] // } 2128 5B JUMPDEST 2129 50 POP 212A 61 PUSH2 0x2135 212D 89 DUP10 212E 82 DUP3 212F 8A DUP11 2130 01 ADD 2131 61 PUSH2 0x2061 2134 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @212A stack[-1] = 0x2135 // @212D stack[0] = stack[-10] // @2130 stack[1] = stack[-9] + stack[-2] // } // Block ends with call to 0x2061, returns to 0x2135 label_2135: // Incoming return from call to 0x2061 at 0x2134 // Inputs[10] // { // @2136 stack[-1] // @2136 stack[-9] // @2137 stack[-12] // @2138 stack[-8] // @2139 stack[-11] // @213B stack[-7] // @213B stack[-2] // @213C stack[-10] // @213E stack[-3] // @213E stack[-6] // } 2135 5B JUMPDEST 2136 97 SWAP8 2137 9A SWAP11 2138 96 SWAP7 2139 99 SWAP10 213A 50 POP 213B 94 SWAP5 213C 97 SWAP8 213D 50 POP 213E 92 SWAP3 213F 95 SWAP6 2140 93 SWAP4 2141 94 SWAP5 2142 92 SWAP3 2143 50 POP 2144 50 POP 2145 50 POP 2146 56 *JUMP // Stack delta = -6 // Outputs[6] // { // @2137 stack[-12] = stack[-9] // @2139 stack[-11] = stack[-8] // @213C stack[-10] = stack[-7] // @213F stack[-9] = stack[-6] // @2140 stack[-7] = stack[-1] // @2141 stack[-8] = stack[-2] // } // Block ends with unconditional jump to stack[-12] label_2147: // Incoming call from 0x03E5, returns to 0x03E6 // Incoming call from 0x0392, returns to 0x0393 // Inputs[2] // { // @214D stack[-1] // @214E stack[-2] // } 2147 5B JUMPDEST 2148 60 PUSH1 0x00 214A 80 DUP1 214B 60 PUSH1 0x20 214D 83 DUP4 214E 85 DUP6 214F 03 SUB 2150 12 SLT 2151 15 ISZERO 2152 61 PUSH2 0x215a 2155 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2148 stack[0] = 0x00 // @214A stack[1] = 0x00 // } // Block ends with conditional jump to 0x215a, if !(stack[-2] - stack[-1] i< 0x20) label_2156: // Incoming jump from 0x2155, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2159 memory[0x00:0x00] } 2156 60 PUSH1 0x00 2158 80 DUP1 2159 FD *REVERT // Stack delta = +0 // Outputs[1] { @2159 revert(memory[0x00:0x00]); } // Block terminates label_215A: // Incoming jump from 0x2155, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @215B stack[-3] // @215C msg.data[stack[-3]:stack[-3] + 0x20] // } 215A 5B JUMPDEST 215B 82 DUP3 215C 35 CALLDATALOAD 215D 67 PUSH8 0xffffffffffffffff 2166 81 DUP2 2167 11 GT 2168 15 ISZERO 2169 61 PUSH2 0x2171 216C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @215C stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x2171, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_216D: // Incoming jump from 0x216C, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2170 memory[0x00:0x00] } 216D 60 PUSH1 0x00 216F 80 DUP1 2170 FD *REVERT // Stack delta = +0 // Outputs[1] { @2170 revert(memory[0x00:0x00]); } // Block terminates label_2171: // Incoming jump from 0x216C, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2175 stack[-5] // @2176 stack[-1] // @2177 stack[-4] // } 2171 5B JUMPDEST 2172 61 PUSH2 0x217d 2175 85 DUP6 2176 82 DUP3 2177 86 DUP7 2178 01 ADD 2179 61 PUSH2 0x2061 217C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2172 stack[0] = 0x217d // @2175 stack[1] = stack[-5] // @2178 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x2061, returns to 0x217D label_217D: // Incoming return from call to 0x2061 at 0x217C // Inputs[5] // { // @217E stack[-2] // @217E stack[-1] // @217F stack[-8] // @2181 stack[-7] // @2183 stack[-6] // } 217D 5B JUMPDEST 217E 90 SWAP1 217F 96 SWAP7 2180 90 SWAP1 2181 95 SWAP6 2182 50 POP 2183 93 SWAP4 2184 50 POP 2185 50 POP 2186 50 POP 2187 50 POP 2188 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @217F stack[-8] = stack[-2] // @2181 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_2189: // Incoming call from 0x03F8, returns to 0x03F9 // Inputs[2] // { // @218F stack[-1] // @2190 stack[-2] // } 2189 5B JUMPDEST 218A 60 PUSH1 0x00 218C 80 DUP1 218D 60 PUSH1 0x40 218F 83 DUP4 2190 85 DUP6 2191 03 SUB 2192 12 SLT 2193 15 ISZERO 2194 61 PUSH2 0x219c 2197 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @218A stack[0] = 0x00 // @218C stack[1] = 0x00 // } // Block ends with conditional jump to 0x219c, if !(stack[-2] - stack[-1] i< 0x40) label_2198: // Incoming jump from 0x2197, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @219B memory[0x00:0x00] } 2198 60 PUSH1 0x00 219A 80 DUP1 219B FD *REVERT // Stack delta = +0 // Outputs[1] { @219B revert(memory[0x00:0x00]); } // Block terminates label_219C: // Incoming jump from 0x2197, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @219D stack[-3] // @219E msg.data[stack[-3]:stack[-3] + 0x20] // } 219C 5B JUMPDEST 219D 82 DUP3 219E 35 CALLDATALOAD 219F 61 PUSH2 0x21a7 21A2 81 DUP2 21A3 61 PUSH2 0x1f97 21A6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @219E stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @219F stack[1] = 0x21a7 // @21A2 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x1f97, returns to 0x21A7 label_21A7: // Incoming return from call to 0x1F97 at 0x21A6 // Inputs[3] // { // @21A8 stack[-1] // @21A8 stack[-3] // @21AF stack[-4] // } 21A7 5B JUMPDEST 21A8 91 SWAP2 21A9 50 POP 21AA 61 PUSH2 0x21b5 21AD 60 PUSH1 0x20 21AF 84 DUP5 21B0 01 ADD 21B1 61 PUSH2 0x1ff5 21B4 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @21A8 stack[-3] = stack[-1] // @21AA stack[-1] = 0x21b5 // @21B0 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1ff5, returns to 0x21B5 label_21B5: // Incoming return from call to 0x1FF5 at 0x21B4 // Inputs[6] // { // @21B6 stack[-2] // @21B6 stack[-1] // @21B8 stack[-5] // @21BA stack[-6] // @21BA stack[-3] // @21BB stack[-4] // } 21B5 5B JUMPDEST 21B6 90 SWAP1 21B7 50 POP 21B8 92 SWAP3 21B9 50 POP 21BA 92 SWAP3 21BB 90 SWAP1 21BC 50 POP 21BD 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @21B8 stack[-5] = stack[-1] // @21BA stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_21BE: // Incoming jump from 0x2216 // Incoming jump from 0x21EE // Incoming jump from 0x1BBE // Inputs[1] { @21D3 memory[0x00:0x24] } 21BE 5B JUMPDEST 21BF 63 PUSH4 0x4e487b71 21C4 60 PUSH1 0xe0 21C6 1B SHL 21C7 60 PUSH1 0x00 21C9 52 MSTORE 21CA 60 PUSH1 0x41 21CC 60 PUSH1 0x04 21CE 52 MSTORE 21CF 60 PUSH1 0x24 21D1 60 PUSH1 0x00 21D3 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @21C9 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @21CE memory[0x04:0x24] = 0x41 // @21D3 revert(memory[0x00:0x24]); // } // Block terminates label_21D4: // Incoming call from 0x2312, returns to 0x167D // Incoming call from 0x22BD, returns to 0x22BE // Inputs[1] { @21E1 stack[-2] } 21D4 5B JUMPDEST 21D5 60 PUSH1 0x00 21D7 67 PUSH8 0xffffffffffffffff 21E0 80 DUP1 21E1 84 DUP5 21E2 11 GT 21E3 15 ISZERO 21E4 61 PUSH2 0x21ef 21E7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21D5 stack[0] = 0x00 // @21D7 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x21ef, if !(stack[-2] > 0xffffffffffffffff) label_21E8: // Incoming jump from 0x21E7, if not !(stack[-2] > 0xffffffffffffffff) 21E8 61 PUSH2 0x21ef 21EB 61 PUSH2 0x21be 21EE 56 *JUMP // Stack delta = +1 // Outputs[1] { @21E8 stack[0] = 0x21ef } // Block ends with unconditional jump to 0x21be label_21EF: // Incoming jump from 0x21E7, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @21F2 memory[0x40:0x60] // @21F5 stack[-4] // @2204 stack[-1] // } 21EF 5B JUMPDEST 21F0 60 PUSH1 0x40 21F2 51 MLOAD 21F3 60 PUSH1 0x1f 21F5 85 DUP6 21F6 01 ADD 21F7 60 PUSH1 0x1f 21F9 19 NOT 21FA 90 SWAP1 21FB 81 DUP2 21FC 16 AND 21FD 60 PUSH1 0x3f 21FF 01 ADD 2200 16 AND 2201 81 DUP2 2202 01 ADD 2203 90 SWAP1 2204 82 DUP3 2205 82 DUP3 2206 11 GT 2207 81 DUP2 2208 83 DUP4 2209 10 LT 220A 17 OR 220B 15 ISZERO 220C 61 PUSH2 0x2217 220F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2203 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @2203 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x2217, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_2210: // Incoming jump from 0x220F, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 2210 61 PUSH2 0x2217 2213 61 PUSH2 0x21be 2216 56 *JUMP // Stack delta = +1 // Outputs[1] { @2210 stack[0] = 0x2217 } // Block ends with unconditional jump to 0x21be label_2217: // Incoming jump from 0x220F, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @2218 stack[-2] // @221C stack[-1] // @221D stack[-4] // @221F stack[-6] // @2222 stack[-7] // @2224 stack[-5] // } 2217 5B JUMPDEST 2218 81 DUP2 2219 60 PUSH1 0x40 221B 52 MSTORE 221C 80 DUP1 221D 93 SWAP4 221E 50 POP 221F 85 DUP6 2220 81 DUP2 2221 52 MSTORE 2222 86 DUP7 2223 86 DUP7 2224 86 DUP7 2225 01 ADD 2226 11 GT 2227 15 ISZERO 2228 61 PUSH2 0x2230 222B 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @221B memory[0x40:0x60] = stack[-2] // @221D stack[-4] = stack[-1] // @2221 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x2230, if !(stack[-5] + stack[-6] > stack[-7]) label_222C: // Incoming jump from 0x222B, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @222F memory[0x00:0x00] } 222C 60 PUSH1 0x00 222E 80 DUP1 222F FD *REVERT // Stack delta = +0 // Outputs[1] { @222F revert(memory[0x00:0x00]); } // Block terminates label_2230: // Incoming jump from 0x222B, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @2231 stack[-6] // @2232 stack[-5] // @2235 stack[-1] // @2237 msg.data[stack[-5]:stack[-5] + stack[-6]] // @2244 stack[-8] // @2244 stack[-4] // @2245 stack[-7] // } 2230 5B JUMPDEST 2231 85 DUP6 2232 85 DUP6 2233 60 PUSH1 0x20 2235 83 DUP4 2236 01 ADD 2237 37 CALLDATACOPY 2238 60 PUSH1 0x00 223A 60 PUSH1 0x20 223C 87 DUP8 223D 83 DUP4 223E 01 ADD 223F 01 ADD 2240 52 MSTORE 2241 50 POP 2242 50 POP 2243 50 POP 2244 93 SWAP4 2245 92 SWAP3 2246 50 POP 2247 50 POP 2248 50 POP 2249 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @2237 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @2240 memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @2244 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_224A: // Incoming call from 0x040B, returns to 0x040C // Inputs[2] // { // @2253 stack[-1] // @2254 stack[-2] // } 224A 5B JUMPDEST 224B 60 PUSH1 0x00 224D 80 DUP1 224E 60 PUSH1 0x00 2250 80 DUP1 2251 60 PUSH1 0x80 2253 85 DUP6 2254 87 DUP8 2255 03 SUB 2256 12 SLT 2257 15 ISZERO 2258 61 PUSH2 0x2260 225B 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @224B stack[0] = 0x00 // @224D stack[1] = 0x00 // @224E stack[2] = 0x00 // @2250 stack[3] = 0x00 // } // Block ends with conditional jump to 0x2260, if !(stack[-2] - stack[-1] i< 0x80) label_225C: // Incoming jump from 0x225B, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @225F memory[0x00:0x00] } 225C 60 PUSH1 0x00 225E 80 DUP1 225F FD *REVERT // Stack delta = +0 // Outputs[1] { @225F revert(memory[0x00:0x00]); } // Block terminates label_2260: // Incoming jump from 0x225B, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @2261 stack[-5] // @2262 msg.data[stack[-5]:stack[-5] + 0x20] // } 2260 5B JUMPDEST 2261 84 DUP5 2262 35 CALLDATALOAD 2263 61 PUSH2 0x226b 2266 81 DUP2 2267 61 PUSH2 0x1f97 226A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2262 stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @2263 stack[1] = 0x226b // @2266 stack[2] = msg.data[stack[-5]:stack[-5] + 0x20] // } // Block ends with call to 0x1f97, returns to 0x226B label_226B: // Incoming return from call to 0x1F97 at 0x226A // Inputs[4] // { // @226C stack[-1] // @226C stack[-5] // @2270 stack[-6] // @2272 msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } 226B 5B JUMPDEST 226C 93 SWAP4 226D 50 POP 226E 60 PUSH1 0x20 2270 85 DUP6 2271 01 ADD 2272 35 CALLDATALOAD 2273 61 PUSH2 0x227b 2276 81 DUP2 2277 61 PUSH2 0x1f97 227A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @226C stack[-5] = stack[-1] // @2272 stack[-1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @2273 stack[0] = 0x227b // @2276 stack[1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with call to 0x1f97, returns to 0x227B label_227B: // Incoming return from call to 0x1F97 at 0x227A // Inputs[6] // { // @227C stack[-1] // @227C stack[-4] // @2280 stack[-6] // @2282 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2283 stack[-3] // @2289 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 227B 5B JUMPDEST 227C 92 SWAP3 227D 50 POP 227E 60 PUSH1 0x40 2280 85 DUP6 2281 01 ADD 2282 35 CALLDATALOAD 2283 91 SWAP2 2284 50 POP 2285 60 PUSH1 0x60 2287 85 DUP6 2288 01 ADD 2289 35 CALLDATALOAD 228A 67 PUSH8 0xffffffffffffffff 2293 81 DUP2 2294 11 GT 2295 15 ISZERO 2296 61 PUSH2 0x229e 2299 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @227C stack[-4] = stack[-1] // @2283 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2289 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x229e, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_229A: // Incoming jump from 0x2299, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @229D memory[0x00:0x00] } 229A 60 PUSH1 0x00 229C 80 DUP1 229D FD *REVERT // Stack delta = +0 // Outputs[1] { @229D revert(memory[0x00:0x00]); } // Block terminates label_229E: // Incoming jump from 0x2299, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @229F stack[-6] // @22A0 stack[-1] // @22A5 stack[-7] // } 229E 5B JUMPDEST 229F 85 DUP6 22A0 01 ADD 22A1 60 PUSH1 0x1f 22A3 81 DUP2 22A4 01 ADD 22A5 87 DUP8 22A6 13 SGT 22A7 61 PUSH2 0x22af 22AA 57 *JUMPI // Stack delta = +0 // Outputs[1] { @22A0 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x22af, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_22AB: // Incoming jump from 0x22AA, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @22AE memory[0x00:0x00] } 22AB 60 PUSH1 0x00 22AD 80 DUP1 22AE FD *REVERT // Stack delta = +0 // Outputs[1] { @22AE revert(memory[0x00:0x00]); } // Block terminates label_22AF: // Incoming jump from 0x22AA, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @22B3 stack[-7] // @22B4 stack[-1] // @22B5 msg.data[stack[-1]:stack[-1] + 0x20] // } 22AF 5B JUMPDEST 22B0 61 PUSH2 0x22be 22B3 87 DUP8 22B4 82 DUP3 22B5 35 CALLDATALOAD 22B6 60 PUSH1 0x20 22B8 84 DUP5 22B9 01 ADD 22BA 61 PUSH2 0x21d4 22BD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @22B0 stack[0] = 0x22be // @22B3 stack[1] = stack[-7] // @22B5 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @22B9 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x21d4, returns to 0x22BE label_22BE: // Incoming return from call to 0x21D4 at 0x22BD // Inputs[8] // { // @22BF stack[-3] // @22BF stack[-1] // @22C2 stack[-6] // @22C3 stack[-9] // @22C4 stack[-5] // @22C5 stack[-8] // @22C7 stack[-4] // @22C7 stack[-7] // } 22BE 5B JUMPDEST 22BF 91 SWAP2 22C0 50 POP 22C1 50 POP 22C2 92 SWAP3 22C3 95 SWAP6 22C4 91 SWAP2 22C5 94 SWAP5 22C6 50 POP 22C7 92 SWAP3 22C8 50 POP 22C9 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @22C2 stack[-6] = stack[-1] // @22C3 stack[-9] = stack[-6] // @22C5 stack[-8] = stack[-5] // @22C7 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_22CA: // Incoming call from 0x041E, returns to 0x041F // Inputs[2] // { // @22CF stack[-1] // @22D0 stack[-2] // } 22CA 5B JUMPDEST 22CB 60 PUSH1 0x00 22CD 60 PUSH1 0x20 22CF 82 DUP3 22D0 84 DUP5 22D1 03 SUB 22D2 12 SLT 22D3 15 ISZERO 22D4 61 PUSH2 0x22dc 22D7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22CB stack[0] = 0x00 } // Block ends with conditional jump to 0x22dc, if !(stack[-2] - stack[-1] i< 0x20) label_22D8: // Incoming jump from 0x22D7, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @22DB memory[0x00:0x00] } 22D8 60 PUSH1 0x00 22DA 80 DUP1 22DB FD *REVERT // Stack delta = +0 // Outputs[1] { @22DB revert(memory[0x00:0x00]); } // Block terminates label_22DC: // Incoming jump from 0x22D7, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @22DD stack[-2] // @22DE msg.data[stack[-2]:stack[-2] + 0x20] // } 22DC 5B JUMPDEST 22DD 81 DUP2 22DE 35 CALLDATALOAD 22DF 67 PUSH8 0xffffffffffffffff 22E8 81 DUP2 22E9 11 GT 22EA 15 ISZERO 22EB 61 PUSH2 0x22f3 22EE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22DE stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x22f3, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_22EF: // Incoming jump from 0x22EE, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @22F2 memory[0x00:0x00] } 22EF 60 PUSH1 0x00 22F1 80 DUP1 22F2 FD *REVERT // Stack delta = +0 // Outputs[1] { @22F2 revert(memory[0x00:0x00]); } // Block terminates label_22F3: // Incoming jump from 0x22EE, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @22F4 stack[-3] // @22F5 stack[-1] // @22FA stack[-4] // } 22F3 5B JUMPDEST 22F4 82 DUP3 22F5 01 ADD 22F6 60 PUSH1 0x1f 22F8 81 DUP2 22F9 01 ADD 22FA 84 DUP5 22FB 13 SGT 22FC 61 PUSH2 0x2304 22FF 57 *JUMPI // Stack delta = +0 // Outputs[1] { @22F5 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x2304, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_2300: // Incoming jump from 0x22FF, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @2303 memory[0x00:0x00] } 2300 60 PUSH1 0x00 2302 80 DUP1 2303 FD *REVERT // Stack delta = +0 // Outputs[1] { @2303 revert(memory[0x00:0x00]); } // Block terminates label_2304: // Incoming jump from 0x22FF, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @2308 stack[-4] // @2309 stack[-1] // @230A msg.data[stack[-1]:stack[-1] + 0x20] // } 2304 5B JUMPDEST 2305 61 PUSH2 0x167d 2308 84 DUP5 2309 82 DUP3 230A 35 CALLDATALOAD 230B 60 PUSH1 0x20 230D 84 DUP5 230E 01 ADD 230F 61 PUSH2 0x21d4 2312 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2305 stack[0] = 0x167d // @2308 stack[1] = stack[-4] // @230A stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @230E stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x21d4, returns to 0x167D label_2313: // Incoming call from 0x0470, returns to 0x0471 // Inputs[2] // { // @2319 stack[-1] // @231A stack[-2] // } 2313 5B JUMPDEST 2314 60 PUSH1 0x00 2316 80 DUP1 2317 60 PUSH1 0x40 2319 83 DUP4 231A 85 DUP6 231B 03 SUB 231C 12 SLT 231D 15 ISZERO 231E 61 PUSH2 0x2326 2321 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2314 stack[0] = 0x00 // @2316 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2326, if !(stack[-2] - stack[-1] i< 0x40) label_2322: // Incoming jump from 0x2321, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2325 memory[0x00:0x00] } 2322 60 PUSH1 0x00 2324 80 DUP1 2325 FD *REVERT // Stack delta = +0 // Outputs[1] { @2325 revert(memory[0x00:0x00]); } // Block terminates label_2326: // Incoming jump from 0x2321, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2327 stack[-3] // @2328 msg.data[stack[-3]:stack[-3] + 0x20] // } 2326 5B JUMPDEST 2327 82 DUP3 2328 35 CALLDATALOAD 2329 61 PUSH2 0x2331 232C 81 DUP2 232D 61 PUSH2 0x1f97 2330 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2328 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @2329 stack[1] = 0x2331 // @232C stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x1f97, returns to 0x2331 label_2331: // Incoming return from call to 0x1F97 at 0x2330 // Inputs[4] // { // @2332 stack[-1] // @2332 stack[-3] // @2336 stack[-4] // @2338 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 2331 5B JUMPDEST 2332 91 SWAP2 2333 50 POP 2334 60 PUSH1 0x20 2336 83 DUP4 2337 01 ADD 2338 35 CALLDATALOAD 2339 61 PUSH2 0x2341 233C 81 DUP2 233D 61 PUSH2 0x1f97 2340 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2332 stack[-3] = stack[-1] // @2338 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @2339 stack[0] = 0x2341 // @233C stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x1f97, returns to 0x2341 label_2341: // Incoming return from call to 0x1F97 at 0x2340 // Inputs[6] // { // @2342 stack[-1] // @2343 stack[-2] // @2346 stack[-5] // @2348 stack[-3] // @2348 stack[-6] // @2349 stack[-4] // } 2341 5B JUMPDEST 2342 80 DUP1 2343 91 SWAP2 2344 50 POP 2345 50 POP 2346 92 SWAP3 2347 50 POP 2348 92 SWAP3 2349 90 SWAP1 234A 50 POP 234B 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2346 stack[-5] = stack[-1] // @2348 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_234C: // Incoming call from 0x13C7, returns to 0x0541 // Incoming call from 0x0893, returns to 0x0541 // Incoming call from 0x0EDB, returns to 0x0541 // Incoming call from 0x0540, returns to 0x0541 // Incoming call from 0x0A41, returns to 0x0541 // Incoming call from 0x096E, returns to 0x0541 // Incoming call from 0x0D4E, returns to 0x0541 // Incoming call from 0x0815, returns to 0x0541 // Incoming call from 0x0D18, returns to 0x0541 // Incoming call from 0x10BB, returns to 0x0541 // Inputs[2] // { // @2350 stack[-1] // @237F stack[-2] // } 234C 5B JUMPDEST 234D 60 PUSH1 0x20 234F 80 DUP1 2350 82 DUP3 2351 52 MSTORE 2352 81 DUP2 2353 81 DUP2 2354 01 ADD 2355 52 MSTORE 2356 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 2377 60 PUSH1 0x40 2379 82 DUP3 237A 01 ADD 237B 52 MSTORE 237C 60 PUSH1 0x60 237E 01 ADD 237F 90 SWAP1 2380 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2351 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2355 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @237B memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @237F stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2381: // Incoming call from 0x0F3E, returns to 0x05D0 // Incoming call from 0x11DC, returns to 0x11DD // Incoming call from 0x1D6C, returns to 0x1D6D // Incoming call from 0x1DF0, returns to 0x1DF1 // Incoming call from 0x11B0, returns to 0x11B1 // Incoming call from 0x12AE, returns to 0x05D0 // Incoming call from 0x05CF, returns to 0x05D0 // Incoming call from 0x05FB, returns to 0x05FC // Inputs[1] { @2384 stack[-1] } 2381 5B JUMPDEST 2382 60 PUSH1 0x01 2384 81 DUP2 2385 81 DUP2 2386 1C SHR 2387 90 SWAP1 2388 82 DUP3 2389 16 AND 238A 80 DUP1 238B 61 PUSH2 0x2395 238E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2387 stack[0] = stack[-1] >> 0x01 // @2389 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2395, if stack[-1] & 0x01 label_238F: // Incoming jump from 0x238E, if not stack[-1] & 0x01 // Inputs[2] // { // @2391 stack[-2] // @239A stack[-1] // } 238F 60 PUSH1 0x7f 2391 82 DUP3 2392 16 AND 2393 91 SWAP2 2394 50 POP 2395 5B JUMPDEST 2396 60 PUSH1 0x20 2398 82 DUP3 2399 10 LT 239A 81 DUP2 239B 14 EQ 239C 15 ISZERO 239D 61 PUSH2 0x23b6 23A0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2393 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x23b6, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_23A1: // Incoming jump from 0x23A0, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x23A0, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @23B5 memory[0x00:0x24] } 23A1 63 PUSH4 0x4e487b71 23A6 60 PUSH1 0xe0 23A8 1B SHL 23A9 60 PUSH1 0x00 23AB 52 MSTORE 23AC 60 PUSH1 0x22 23AE 60 PUSH1 0x04 23B0 52 MSTORE 23B1 60 PUSH1 0x24 23B3 60 PUSH1 0x00 23B5 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @23AB memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @23B0 memory[0x04:0x24] = 0x22 // @23B5 revert(memory[0x00:0x24]); // } // Block terminates label_23B6: // Incoming jump from 0x23A0, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x23A0, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @23B8 stack[-4] // @23B8 stack[-2] // @23B9 stack[-3] // } 23B6 5B JUMPDEST 23B7 50 POP 23B8 91 SWAP2 23B9 90 SWAP1 23BA 50 POP 23BB 56 *JUMP // Stack delta = -3 // Outputs[1] { @23B8 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_23BC: // Incoming call from 0x0F03, returns to 0x0541 // Incoming call from 0x083D, returns to 0x0541 // Inputs[2] // { // @23C0 stack[-1] // @2405 stack[-2] // } 23BC 5B JUMPDEST 23BD 60 PUSH1 0x20 23BF 80 DUP1 23C0 82 DUP3 23C1 52 MSTORE 23C2 60 PUSH1 0x2b 23C4 90 SWAP1 23C5 82 DUP3 23C6 01 ADD 23C7 52 MSTORE 23C8 7F PUSH32 0x43616e6e6f74207365742074617267657420636f6e7472616374206166746572 23E9 60 PUSH1 0x40 23EB 82 DUP3 23EC 01 ADD 23ED 52 MSTORE 23EE 6A PUSH11 0x103334b730b634bd32b217 23FA 60 PUSH1 0xa9 23FC 1B SHL 23FD 60 PUSH1 0x60 23FF 82 DUP3 2400 01 ADD 2401 52 MSTORE 2402 60 PUSH1 0x80 2404 01 ADD 2405 90 SWAP1 2406 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @23C1 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @23C7 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2b // @23ED memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x43616e6e6f74207365742074617267657420636f6e7472616374206166746572 // @2401 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x103334b730b634bd32b217 << 0xa9 // @2405 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 2407 5B JUMPDEST 2408 60 PUSH1 0x20 240A 80 DUP1 240B 82 DUP3 240C 52 MSTORE 240D 60 PUSH1 0x31 240F 90 SWAP1 2410 82 DUP3 2411 01 ADD 2412 52 MSTORE 2413 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 2434 60 PUSH1 0x40 2436 82 DUP3 2437 01 ADD 2438 52 MSTORE 2439 70 PUSH17 0x1ddb995c881b9bdc88185c1c1c9bdd9959 244B 60 PUSH1 0x7a 244D 1B SHL 244E 60 PUSH1 0x60 2450 82 DUP3 2451 01 ADD 2452 52 MSTORE 2453 60 PUSH1 0x80 2455 01 ADD 2456 90 SWAP1 2457 56 *JUMP label_2458: // Incoming jump from 0x0AB4 // Incoming jump from 0x0B38 // Incoming jump from 0x0B08 // Incoming jump from 0x0AEF // Incoming jump from 0x0E3D // Incoming jump from 0x1C2A // Incoming jump from 0x0F78 // Inputs[1] { @246D memory[0x00:0x24] } 2458 5B JUMPDEST 2459 63 PUSH4 0x4e487b71 245E 60 PUSH1 0xe0 2460 1B SHL 2461 60 PUSH1 0x00 2463 52 MSTORE 2464 60 PUSH1 0x32 2466 60 PUSH1 0x04 2468 52 MSTORE 2469 60 PUSH1 0x24 246B 60 PUSH1 0x00 246D FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2463 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2468 memory[0x04:0x24] = 0x32 // @246D revert(memory[0x00:0x24]); // } // Block terminates label_246E: // Incoming jump from 0x24C8 // Incoming jump from 0x24B1 // Incoming jump from 0x2497 // Inputs[1] { @2483 memory[0x00:0x24] } 246E 5B JUMPDEST 246F 63 PUSH4 0x4e487b71 2474 60 PUSH1 0xe0 2476 1B SHL 2477 60 PUSH1 0x00 2479 52 MSTORE 247A 60 PUSH1 0x11 247C 60 PUSH1 0x04 247E 52 MSTORE 247F 60 PUSH1 0x24 2481 60 PUSH1 0x00 2483 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2479 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @247E memory[0x04:0x24] = 0x11 // @2483 revert(memory[0x00:0x24]); // } // Block terminates label_2484: // Incoming call from 0x0E6B, returns to 0x0E6C // Incoming call from 0x1B8D, returns to 0x1B8E // Incoming call from 0x0B7B, returns to 0x0B7C // Inputs[1] { @248A stack[-1] } 2484 5B JUMPDEST 2485 60 PUSH1 0x00 2487 60 PUSH1 0x00 2489 19 NOT 248A 82 DUP3 248B 14 EQ 248C 15 ISZERO 248D 61 PUSH2 0x2498 2490 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2485 stack[0] = 0x00 } // Block ends with conditional jump to 0x2498, if !(stack[-1] == ~0x00) label_2491: // Incoming jump from 0x2490, if not !(stack[-1] == ~0x00) 2491 61 PUSH2 0x2498 2494 61 PUSH2 0x246e 2497 56 *JUMP // Stack delta = +1 // Outputs[1] { @2491 stack[0] = 0x2498 } // Block ends with unconditional jump to 0x246e label_2498: // Incoming jump from 0x2490, if !(stack[-1] == ~0x00) // Inputs[2] // { // @249C stack[-2] // @249D stack[-3] // } 2498 5B JUMPDEST 2499 50 POP 249A 60 PUSH1 0x01 249C 01 ADD 249D 90 SWAP1 249E 56 *JUMP // Stack delta = -2 // Outputs[1] { @249D stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_249F: // Incoming call from 0x0E1A, returns to 0x0E1B // Incoming call from 0x0DB6, returns to 0x0DB7 // Incoming call from 0x1343, returns to 0x1344 // Incoming call from 0x0E9F, returns to 0x0EA0 // Incoming call from 0x0E83, returns to 0x0E84 // Incoming call from 0x1C15, returns to 0x1C16 // Incoming call from 0x0E5C, returns to 0x0E5D // Inputs[2] // { // @24A2 stack[-2] // @24A4 stack[-1] // } 249F 5B JUMPDEST 24A0 60 PUSH1 0x00 24A2 82 DUP3 24A3 19 NOT 24A4 82 DUP3 24A5 11 GT 24A6 15 ISZERO 24A7 61 PUSH2 0x24b2 24AA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24A0 stack[0] = 0x00 } // Block ends with conditional jump to 0x24b2, if !(stack[-1] > ~stack[-2]) label_24AB: // Incoming jump from 0x24AA, if not !(stack[-1] > ~stack[-2]) 24AB 61 PUSH2 0x24b2 24AE 61 PUSH2 0x246e 24B1 56 *JUMP // Stack delta = +1 // Outputs[1] { @24AB stack[0] = 0x24b2 } // Block ends with unconditional jump to 0x246e label_24B2: // Incoming jump from 0x24AA, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @24B4 stack[-3] // @24B4 stack[-2] // @24B5 stack[-4] // } 24B2 5B JUMPDEST 24B3 50 POP 24B4 01 ADD 24B5 90 SWAP1 24B6 56 *JUMP // Stack delta = -3 // Outputs[1] { @24B5 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_24B7: // Incoming call from 0x0EA9, returns to 0x0EAA // Incoming call from 0x1574, returns to 0x1575 // Incoming call from 0x1455, returns to 0x1456 // Incoming call from 0x1967, returns to 0x1968 // Incoming call from 0x1BFD, returns to 0x1BFE // Incoming call from 0x0E8D, returns to 0x0E8E // Inputs[2] // { // @24BA stack[-2] // @24BB stack[-1] // } 24B7 5B JUMPDEST 24B8 60 PUSH1 0x00 24BA 82 DUP3 24BB 82 DUP3 24BC 10 LT 24BD 15 ISZERO 24BE 61 PUSH2 0x24c9 24C1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24B8 stack[0] = 0x00 } // Block ends with conditional jump to 0x24c9, if !(stack[-1] < stack[-2]) label_24C2: // Incoming jump from 0x24C1, if not !(stack[-1] < stack[-2]) 24C2 61 PUSH2 0x24c9 24C5 61 PUSH2 0x246e 24C8 56 *JUMP // Stack delta = +1 // Outputs[1] { @24C2 stack[0] = 0x24c9 } // Block ends with unconditional jump to 0x246e label_24C9: // Incoming jump from 0x24C1, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @24CB stack[-3] // @24CB stack[-2] // @24CC stack[-4] // } 24C9 5B JUMPDEST 24CA 50 POP 24CB 03 SUB 24CC 90 SWAP1 24CD 56 *JUMP // Stack delta = -3 // Outputs[1] { @24CC stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_24CE: // Incoming call from 0x1288, returns to 0x1289 // Inputs[3] // { // @24D1 stack[-4] // @24D2 memory[stack[-4]:stack[-4] + 0x20] // @24D7 stack[-1] // } 24CE 5B JUMPDEST 24CF 60 PUSH1 0x00 24D1 84 DUP5 24D2 51 MLOAD 24D3 61 PUSH2 0x24e0 24D6 81 DUP2 24D7 84 DUP5 24D8 60 PUSH1 0x20 24DA 89 DUP10 24DB 01 ADD 24DC 61 PUSH2 0x1f13 24DF 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @24CF stack[0] = 0x00 // @24D2 stack[1] = memory[stack[-4]:stack[-4] + 0x20] // @24D3 stack[2] = 0x24e0 // @24D6 stack[3] = memory[stack[-4]:stack[-4] + 0x20] // @24D7 stack[4] = stack[-1] // @24DB stack[5] = stack[-4] + 0x20 // } // Block ends with call to 0x1f13, returns to 0x24E0 label_24E0: // Incoming return from call to 0x1F13 at 0x24DF // Inputs[4] // { // @24E1 stack[-5] // @24E2 memory[stack[-5]:stack[-5] + 0x20] // @24E3 stack[-1] // @24E4 stack[-3] // } 24E0 5B JUMPDEST 24E1 84 DUP5 24E2 51 MLOAD 24E3 90 SWAP1 24E4 83 DUP4 24E5 01 ADD 24E6 90 SWAP1 24E7 61 PUSH2 0x24f4 24EA 81 DUP2 24EB 83 DUP4 24EC 60 PUSH1 0x20 24EE 89 DUP10 24EF 01 ADD 24F0 61 PUSH2 0x1f13 24F3 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @24E6 stack[0] = memory[stack[-5]:stack[-5] + 0x20] // @24E6 stack[-1] = stack[-3] + stack[-1] // @24E7 stack[1] = 0x24f4 // @24EA stack[2] = memory[stack[-5]:stack[-5] + 0x20] // @24EB stack[3] = stack[-3] + stack[-1] // @24EF stack[4] = stack[-5] + 0x20 // } // Block ends with call to 0x1f13, returns to 0x24F4 label_24F4: // Incoming return from call to 0x1F13 at 0x24F3 // Inputs[4] // { // @24F5 stack[-5] // @24F6 memory[stack[-5]:stack[-5] + 0x20] // @24F7 stack[-2] // @24F8 stack[-1] // } 24F4 5B JUMPDEST 24F5 84 DUP5 24F6 51 MLOAD 24F7 91 SWAP2 24F8 01 ADD 24F9 90 SWAP1 24FA 61 PUSH2 0x2507 24FD 81 DUP2 24FE 83 DUP4 24FF 60 PUSH1 0x20 2501 88 DUP9 2502 01 ADD 2503 61 PUSH2 0x1f13 2506 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @24F9 stack[-1] = memory[stack[-5]:stack[-5] + 0x20] // @24F9 stack[-2] = stack[-2] + stack[-1] // @24FA stack[0] = 0x2507 // @24FD stack[1] = memory[stack[-5]:stack[-5] + 0x20] // @24FE stack[2] = stack[-2] + stack[-1] // @2502 stack[3] = stack[-5] + 0x20 // } // Block ends with call to 0x1f13, returns to 0x2507 label_2507: // Incoming return from call to 0x1F13 at 0x2506 // Inputs[4] // { // @2508 stack[-2] // @2508 stack[-1] // @2509 stack[-8] // @250A stack[-7] // } 2507 5B JUMPDEST 2508 01 ADD 2509 95 SWAP6 250A 94 SWAP5 250B 50 POP 250C 50 POP 250D 50 POP 250E 50 POP 250F 50 POP 2510 56 *JUMP // Stack delta = -7 // Outputs[1] { @2509 stack[-8] = stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-8] label_2511: // Incoming call from 0x1934, returns to 0x1935 // Incoming call from 0x1543, returns to 0x1544 // Incoming call from 0x19CA, returns to 0x19CB // Inputs[2] // { // @2516 stack[-1] // @2517 stack[-2] // } 2511 5B JUMPDEST 2512 60 PUSH1 0x00 2514 60 PUSH1 0x20 2516 82 DUP3 2517 84 DUP5 2518 03 SUB 2519 12 SLT 251A 15 ISZERO 251B 61 PUSH2 0x2523 251E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2512 stack[0] = 0x00 } // Block ends with conditional jump to 0x2523, if !(stack[-2] - stack[-1] i< 0x20) label_251F: // Incoming jump from 0x251E, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2522 memory[0x00:0x00] } 251F 60 PUSH1 0x00 2521 80 DUP1 2522 FD *REVERT // Stack delta = +0 // Outputs[1] { @2522 revert(memory[0x00:0x00]); } // Block terminates label_2523: // Incoming jump from 0x251E, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2524 stack[-2] // @2525 memory[stack[-2]:stack[-2] + 0x20] // } 2523 5B JUMPDEST 2524 81 DUP2 2525 51 MLOAD 2526 61 PUSH2 0x1299 2529 81 DUP2 252A 61 PUSH2 0x1f97 252D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2525 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2526 stack[1] = 0x1299 // @2529 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1f97, returns to 0x1299 252E 5B JUMPDEST 252F 60 PUSH1 0x20 2531 80 DUP1 2532 82 DUP3 2533 52 MSTORE 2534 60 PUSH1 0x32 2536 90 SWAP1 2537 82 DUP3 2538 01 ADD 2539 52 MSTORE 253A 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 255B 60 PUSH1 0x40 255D 82 DUP3 255E 01 ADD 255F 52 MSTORE 2560 71 PUSH18 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 2573 60 PUSH1 0x71 2575 1B SHL 2576 60 PUSH1 0x60 2578 82 DUP3 2579 01 ADD 257A 52 MSTORE 257B 60 PUSH1 0x80 257D 01 ADD 257E 90 SWAP1 257F 56 *JUMP label_2580: // Incoming jump from 0x25A4 // Incoming jump from 0x25B8 // Inputs[1] { @2595 memory[0x00:0x24] } 2580 5B JUMPDEST 2581 63 PUSH4 0x4e487b71 2586 60 PUSH1 0xe0 2588 1B SHL 2589 60 PUSH1 0x00 258B 52 MSTORE 258C 60 PUSH1 0x12 258E 60 PUSH1 0x04 2590 52 MSTORE 2591 60 PUSH1 0x24 2593 60 PUSH1 0x00 2595 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @258B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2590 memory[0x04:0x24] = 0x12 // @2595 revert(memory[0x00:0x24]); // } // Block terminates label_2596: // Incoming call from 0x1B9C, returns to 0x1B9D // Incoming call from 0x1C4C, returns to 0x1C4D // Inputs[1] { @2599 stack[-2] } 2596 5B JUMPDEST 2597 60 PUSH1 0x00 2599 82 DUP3 259A 61 PUSH2 0x25a5 259D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2597 stack[0] = 0x00 } // Block ends with conditional jump to 0x25a5, if stack[-2] label_259E: // Incoming jump from 0x259D, if not stack[-2] 259E 61 PUSH2 0x25a5 25A1 61 PUSH2 0x2580 25A4 56 *JUMP // Stack delta = +1 // Outputs[1] { @259E stack[0] = 0x25a5 } // Block ends with unconditional jump to 0x2580 label_25A5: // Incoming jump from 0x259D, if stack[-2] // Inputs[3] // { // @25A7 stack[-2] // @25A7 stack[-3] // @25A8 stack[-4] // } 25A5 5B JUMPDEST 25A6 50 POP 25A7 04 DIV 25A8 90 SWAP1 25A9 56 *JUMP // Stack delta = -3 // Outputs[1] { @25A8 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_25AA: // Incoming call from 0x1C0A, returns to 0x1C0B // Inputs[1] { @25AD stack[-2] } 25AA 5B JUMPDEST 25AB 60 PUSH1 0x00 25AD 82 DUP3 25AE 61 PUSH2 0x25b9 25B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25AB stack[0] = 0x00 } // Block ends with conditional jump to 0x25b9, if stack[-2] label_25B2: // Incoming jump from 0x25B1, if not stack[-2] 25B2 61 PUSH2 0x25b9 25B5 61 PUSH2 0x2580 25B8 56 *JUMP // Stack delta = +1 // Outputs[1] { @25B2 stack[0] = 0x25b9 } // Block ends with unconditional jump to 0x2580 label_25B9: // Incoming jump from 0x25B1, if stack[-2] // Inputs[3] // { // @25BB stack[-3] // @25BB stack[-2] // @25BC stack[-4] // } 25B9 5B JUMPDEST 25BA 50 POP 25BB 06 MOD 25BC 90 SWAP1 25BD 56 *JUMP // Stack delta = -3 // Outputs[1] { @25BC stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] 25BE 5B JUMPDEST 25BF 60 PUSH1 0x01 25C1 60 PUSH1 0x01 25C3 60 PUSH1 0xa0 25C5 1B SHL 25C6 03 SUB 25C7 85 DUP6 25C8 81 DUP2 25C9 16 AND 25CA 82 DUP3 25CB 52 MSTORE 25CC 84 DUP5 25CD 16 AND 25CE 60 PUSH1 0x20 25D0 82 DUP3 25D1 01 ADD 25D2 52 MSTORE 25D3 60 PUSH1 0x40 25D5 81 DUP2 25D6 01 ADD 25D7 83 DUP4 25D8 90 SWAP1 25D9 52 MSTORE 25DA 60 PUSH1 0x80 25DC 60 PUSH1 0x60 25DE 82 DUP3 25DF 01 ADD 25E0 81 DUP2 25E1 90 SWAP1 25E2 52 MSTORE 25E3 60 PUSH1 0x00 25E5 90 SWAP1 25E6 61 PUSH2 0x25f1 25E9 90 SWAP1 25EA 83 DUP4 25EB 01 ADD 25EC 84 DUP5 25ED 61 PUSH2 0x1f3f 25F0 56 *JUMP 25F1 5B JUMPDEST 25F2 96 SWAP7 25F3 95 SWAP6 25F4 50 POP 25F5 50 POP 25F6 50 POP 25F7 50 POP 25F8 50 POP 25F9 50 POP 25FA 56 *JUMP 25FB 5B JUMPDEST 25FC 60 PUSH1 0x00 25FE 60 PUSH1 0x20 2600 82 DUP3 2601 84 DUP5 2602 03 SUB 2603 12 SLT 2604 15 ISZERO 2605 61 PUSH2 0x260d 2608 57 *JUMPI 2609 60 PUSH1 0x00 260B 80 DUP1 260C FD *REVERT 260D 5B JUMPDEST 260E 81 DUP2 260F 51 MLOAD 2610 61 PUSH2 0x1299 2613 81 DUP2 2614 61 PUSH2 0x1e6e 2617 56 *JUMP 2618 FE *ASSERT 2619 DD DD 261A F2 CALLCODE 261B 52 MSTORE 261C AD AD 261D 1B SHL 261E E2 E2 261F C8 C8 2620 9B SWAP12 2621 69 PUSH10 0xc2b068fc378daa952ba7 262C F1 CALL 262D 63 PUSH4 0xc4a11628 2632 F5 CREATE2 2633 5A GAS 2634 4D 4D 2635 F5 CREATE2 2636 23 23 2637 B3 B3 2638 EF EF 2639 A2 LOG2 263A 64 PUSH5 0x6970667358 2640 22 22 2641 12 SLT 2642 20 SHA3 2643 E3 E3 2644 EC EC 2645 3D RETURNDATASIZE 2646 5B JUMPDEST 2647 19 NOT 2648 1E 1E 2649 1C SHR 264A 32 ORIGIN 264B 0A EXP 264C 03 SUB 264D 54 SLOAD 264E 59 MSIZE 264F F3 *RETURN 2650 3C EXTCODECOPY 2651 29 29 2652 98 SWAP9 2653 FD *REVERT 2654 D5 D5 2655 C4 C4 2656 3E RETURNDATACOPY 2657 64 PUSH5 0xb636063f5d 265D 9A SWAP11 265E D2 D2 265F 15 ISZERO 2660 DA DA 2661 E4 E4 2662 30 ADDRESS 2663 64 PUSH5 0x736f6c6343 2669 00 *STOP 266A 08 ADDMOD 266B 09 MULMOD 266C 00 *STOP 266D 33 CALLER