Online Solidity Decompiler

label_0000: // 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 0x01c3 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01c3, 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 0x95d89b41 0026 11 GT 0027 61 PUSH2 0x00f9 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00f9, if 0x95d89b41 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x95d89b41 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xe5c8b03d 0031 11 GT 0032 61 PUSH2 0x0097 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0097, if 0xe5c8b03d > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xe5c8b03d > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xeb12d61e 003C 11 GT 003D 61 PUSH2 0x0071 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xeb12d61e > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xeb12d61e > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xeb12d61e 0047 14 EQ 0048 61 PUSH2 0x039f 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039f, if 0xeb12d61e == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xeb12d61e == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xf242432a 0052 14 EQ 0053 61 PUSH2 0x03b2 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b2, if 0xf242432a == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xf242432a == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf2fde38b 005D 14 EQ 005E 61 PUSH2 0x03c5 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c5, if 0xf2fde38b == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xf5298aca 0068 14 EQ 0069 61 PUSH2 0x03d8 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d8, if 0xf5298aca == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xf5298aca == stack[-1] 006D 61 PUSH2 0x01c3 0070 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c3 label_0071: // Incoming jump from 0x0040, if 0xeb12d61e > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0xe5c8b03d 0078 14 EQ 0079 61 PUSH2 0x037c 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037c, if 0xe5c8b03d == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xe5c8b03d == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xe8a3d485 0083 14 EQ 0084 61 PUSH2 0x0384 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0384, if 0xe8a3d485 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xe8a3d485 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xe985e9c5 008E 14 EQ 008F 61 PUSH2 0x038c 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x038c, if 0xe985e9c5 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xe985e9c5 == stack[-1] 0093 61 PUSH2 0x01c3 0096 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c3 label_0097: // Incoming jump from 0x0035, if 0xe5c8b03d > stack[-1] // Inputs[1] { @0098 stack[-1] } 0097 5B JUMPDEST 0098 80 DUP1 0099 63 PUSH4 0xb9c4d9fb 009E 11 GT 009F 61 PUSH2 0x00d3 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d3, if 0xb9c4d9fb > stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0xb9c4d9fb > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0xb9c4d9fb 00A9 14 EQ 00AA 61 PUSH2 0x032e 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x032e, if 0xb9c4d9fb == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0xb9c4d9fb == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0xc0ac9983 00B4 14 EQ 00B5 61 PUSH2 0x034e 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x034e, if 0xc0ac9983 == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0xc0ac9983 == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0xc6bf3262 00BF 14 EQ 00C0 61 PUSH2 0x0356 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0356, if 0xc6bf3262 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0xc6bf3262 == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0xcd53d08e 00CA 14 EQ 00CB 61 PUSH2 0x0369 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0369, if 0xcd53d08e == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0xcd53d08e == stack[-1] 00CF 61 PUSH2 0x01c3 00D2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c3 label_00D3: // Incoming jump from 0x00A2, if 0xb9c4d9fb > stack[-1] // Inputs[1] { @00D4 stack[-1] } 00D3 5B JUMPDEST 00D4 80 DUP1 00D5 63 PUSH4 0x95d89b41 00DA 14 EQ 00DB 61 PUSH2 0x0300 00DE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0300, if 0x95d89b41 == stack[-1] label_00DF: // Incoming jump from 0x00DE, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00DF stack[-1] } 00DF 80 DUP1 00E0 63 PUSH4 0x99e0dd7c 00E5 14 EQ 00E6 61 PUSH2 0x0308 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0308, if 0x99e0dd7c == stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x99e0dd7c == stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0xa22cb465 00F0 14 EQ 00F1 61 PUSH2 0x031b 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x031b, if 0xa22cb465 == stack[-1] label_00F5: // Incoming jump from 0x00F4, if not 0xa22cb465 == stack[-1] 00F5 61 PUSH2 0x01c3 00F8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c3 label_00F9: // Incoming jump from 0x002A, if 0x95d89b41 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00FA stack[-1] } 00F9 5B JUMPDEST 00FA 80 DUP1 00FB 63 PUSH4 0x4e1273f4 0100 11 GT 0101 61 PUSH2 0x0166 0104 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0166, if 0x4e1273f4 > stack[-1] label_0105: // Incoming jump from 0x0104, if not 0x4e1273f4 > stack[-1] // Inputs[1] { @0105 stack[-1] } 0105 80 DUP1 0106 63 PUSH4 0x7df73e27 010B 11 GT 010C 61 PUSH2 0x0140 010F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0140, if 0x7df73e27 > stack[-1] label_0110: // Incoming jump from 0x010F, if not 0x7df73e27 > stack[-1] // Inputs[1] { @0110 stack[-1] } 0110 80 DUP1 0111 63 PUSH4 0x7df73e27 0116 14 EQ 0117 61 PUSH2 0x02bd 011A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02bd, if 0x7df73e27 == stack[-1] label_011B: // Incoming jump from 0x011A, if not 0x7df73e27 == stack[-1] // Inputs[1] { @011B stack[-1] } 011B 80 DUP1 011C 63 PUSH4 0x8da5cb5b 0121 14 EQ 0122 61 PUSH2 0x02d0 0125 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d0, if 0x8da5cb5b == stack[-1] label_0126: // Incoming jump from 0x0125, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0126 stack[-1] } 0126 80 DUP1 0127 63 PUSH4 0x8f32d59b 012C 14 EQ 012D 61 PUSH2 0x02e5 0130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e5, if 0x8f32d59b == stack[-1] label_0131: // Incoming jump from 0x0130, if not 0x8f32d59b == stack[-1] // Inputs[1] { @0131 stack[-1] } 0131 80 DUP1 0132 63 PUSH4 0x938e3d7b 0137 14 EQ 0138 61 PUSH2 0x02ed 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ed, if 0x938e3d7b == stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x938e3d7b == stack[-1] 013C 61 PUSH2 0x01c3 013F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c3 label_0140: // Incoming jump from 0x010F, if 0x7df73e27 > stack[-1] // Inputs[1] { @0141 stack[-1] } 0140 5B JUMPDEST 0141 80 DUP1 0142 63 PUSH4 0x4e1273f4 0147 14 EQ 0148 61 PUSH2 0x0281 014B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0281, if 0x4e1273f4 == stack[-1] label_014C: // Incoming jump from 0x014B, if not 0x4e1273f4 == stack[-1] // Inputs[1] { @014C stack[-1] } 014C 80 DUP1 014D 63 PUSH4 0x6308f1cd 0152 14 EQ 0153 61 PUSH2 0x0294 0156 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0294, if 0x6308f1cd == stack[-1] label_0157: // Incoming jump from 0x0156, if not 0x6308f1cd == stack[-1] // Inputs[1] { @0157 stack[-1] } 0157 80 DUP1 0158 63 PUSH4 0x715018a6 015D 14 EQ 015E 61 PUSH2 0x02b5 0161 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b5, if 0x715018a6 == stack[-1] label_0162: // Incoming jump from 0x0161, if not 0x715018a6 == stack[-1] 0162 61 PUSH2 0x01c3 0165 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c3 label_0166: // Incoming jump from 0x0104, if 0x4e1273f4 > stack[-1] // Inputs[1] { @0167 stack[-1] } 0166 5B JUMPDEST 0167 80 DUP1 0168 63 PUSH4 0x0e316ab7 016D 11 GT 016E 61 PUSH2 0x01a2 0171 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a2, if 0x0e316ab7 > stack[-1] label_0172: // Incoming jump from 0x0171, if not 0x0e316ab7 > stack[-1] // Inputs[1] { @0172 stack[-1] } 0172 80 DUP1 0173 63 PUSH4 0x0e316ab7 0178 14 EQ 0179 61 PUSH2 0x0226 017C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0226, if 0x0e316ab7 == stack[-1] label_017D: // Incoming jump from 0x017C, if not 0x0e316ab7 == stack[-1] // Inputs[1] { @017D stack[-1] } 017D 80 DUP1 017E 63 PUSH4 0x0e89341c 0183 14 EQ 0184 61 PUSH2 0x023b 0187 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023b, if 0x0e89341c == stack[-1] label_0188: // Incoming jump from 0x0187, if not 0x0e89341c == stack[-1] // Inputs[1] { @0188 stack[-1] } 0188 80 DUP1 0189 63 PUSH4 0x0ebd4c7f 018E 14 EQ 018F 61 PUSH2 0x024e 0192 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024e, if 0x0ebd4c7f == stack[-1] label_0193: // Incoming jump from 0x0192, if not 0x0ebd4c7f == stack[-1] // Inputs[1] { @0193 stack[-1] } 0193 80 DUP1 0194 63 PUSH4 0x2eb2c2d6 0199 14 EQ 019A 61 PUSH2 0x026e 019D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026e, if 0x2eb2c2d6 == stack[-1] label_019E: // Incoming jump from 0x019D, if not 0x2eb2c2d6 == stack[-1] 019E 61 PUSH2 0x01c3 01A1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c3 label_01A2: // Incoming jump from 0x0171, if 0x0e316ab7 > stack[-1] // Inputs[1] { @01A3 stack[-1] } 01A2 5B JUMPDEST 01A3 80 DUP1 01A4 62 PUSH3 0xfdd58e 01A8 14 EQ 01A9 61 PUSH2 0x01c8 01AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c8, if 0xfdd58e == stack[-1] label_01AD: // Incoming jump from 0x01AC, if not 0xfdd58e == stack[-1] // Inputs[1] { @01AD stack[-1] } 01AD 80 DUP1 01AE 63 PUSH4 0x01ffc9a7 01B3 14 EQ 01B4 61 PUSH2 0x01f1 01B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f1, if 0x01ffc9a7 == stack[-1] label_01B8: // Incoming jump from 0x01B7, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01B8 stack[-1] } 01B8 80 DUP1 01B9 63 PUSH4 0x06fdde03 01BE 14 EQ 01BF 61 PUSH2 0x0211 01C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0211, if 0x06fdde03 == stack[-1] label_01C3: // Incoming jump from 0x0070 // Incoming jump from 0x0096 // Incoming jump from 0x01C2, if not 0x06fdde03 == stack[-1] // Incoming jump from 0x0165 // Incoming jump from 0x00D2 // Incoming jump from 0x00F8 // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x013F // Incoming jump from 0x01A1 // Inputs[1] { @01C7 memory[0x00:0x00] } 01C3 5B JUMPDEST 01C4 60 PUSH1 0x00 01C6 80 DUP1 01C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @01C7 revert(memory[0x00:0x00]); } // Block terminates label_01C8: // Incoming jump from 0x01AC, if 0xfdd58e == stack[-1] // Inputs[1] { @01CF msg.data.length } 01C8 5B JUMPDEST 01C9 61 PUSH2 0x01db 01CC 61 PUSH2 0x01d6 01CF 36 CALLDATASIZE 01D0 60 PUSH1 0x04 01D2 61 PUSH2 0x1fb9 01D5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01C9 stack[0] = 0x01db // @01CC stack[1] = 0x01d6 // @01CF stack[2] = msg.data.length // @01D0 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1fb9 01D6 5B JUMPDEST 01D7 61 PUSH2 0x03eb 01DA 56 *JUMP 01DB 5B JUMPDEST 01DC 60 PUSH1 0x40 01DE 51 MLOAD 01DF 61 PUSH2 0x01e8 01E2 91 SWAP2 01E3 90 SWAP1 01E4 61 PUSH2 0x2bad 01E7 56 *JUMP label_01E8: // Incoming return from call to 0x2A6C at 0x0225 // Inputs[3] // { // @01EB memory[0x40:0x60] // @01ED stack[-1] // @01F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01E8 5B JUMPDEST 01E9 60 PUSH1 0x40 01EB 51 MLOAD 01EC 80 DUP1 01ED 91 SWAP2 01EE 03 SUB 01EF 90 SWAP1 01F0 F3 *RETURN // Stack delta = -1 // Outputs[1] { @01F0 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01F1: // Incoming jump from 0x01B7, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01F8 msg.data.length } 01F1 5B JUMPDEST 01F2 61 PUSH2 0x0204 01F5 61 PUSH2 0x01ff 01F8 36 CALLDATASIZE 01F9 60 PUSH1 0x04 01FB 61 PUSH2 0x20a4 01FE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01F2 stack[0] = 0x0204 // @01F5 stack[1] = 0x01ff // @01F8 stack[2] = msg.data.length // @01F9 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x20a4 01FF 5B JUMPDEST 0200 61 PUSH2 0x0415 0203 56 *JUMP label_0204: // Incoming return from call to 0x0A9D at 0x02EC // Inputs[2] // { // @0207 memory[0x40:0x60] // @020B stack[-1] // } 0204 5B JUMPDEST 0205 60 PUSH1 0x40 0207 51 MLOAD 0208 61 PUSH2 0x01e8 020B 91 SWAP2 020C 90 SWAP1 020D 61 PUSH2 0x2a20 0210 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @020B stack[-1] = 0x01e8 // @020C stack[1] = memory[0x40:0x60] // @020C stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2a20 label_0211: // Incoming jump from 0x01C2, if 0x06fdde03 == stack[-1] 0211 5B JUMPDEST 0212 61 PUSH2 0x0219 0215 61 PUSH2 0x0434 0218 56 *JUMP // Stack delta = +1 // Outputs[1] { @0212 stack[0] = 0x0219 } // Block ends with call to 0x0434, returns to 0x0219 label_0219: // Incoming return from call to 0x0E17 at 0x038B // Incoming return from call to 0x0CDF at 0x0355 // Incoming return from call to 0x0AF0 at 0x0307 // Incoming return from call to 0x0434 at 0x0218 // Inputs[2] // { // @021C memory[0x40:0x60] // @0220 stack[-1] // } 0219 5B JUMPDEST 021A 60 PUSH1 0x40 021C 51 MLOAD 021D 61 PUSH2 0x01e8 0220 91 SWAP2 0221 90 SWAP1 0222 61 PUSH2 0x2a6c 0225 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0220 stack[-1] = 0x01e8 // @0221 stack[1] = memory[0x40:0x60] // @0221 stack[0] = stack[-1] // } // Block ends with call to 0x2a6c, returns to 0x01E8 label_0226: // Incoming jump from 0x017C, if 0x0e316ab7 == stack[-1] // Inputs[1] { @022D msg.data.length } 0226 5B JUMPDEST 0227 61 PUSH2 0x0239 022A 61 PUSH2 0x0234 022D 36 CALLDATASIZE 022E 60 PUSH1 0x04 0230 61 PUSH2 0x1ddb 0233 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0227 stack[0] = 0x0239 // @022A stack[1] = 0x0234 // @022D stack[2] = msg.data.length // @022E stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1ddb 0234 5B JUMPDEST 0235 61 PUSH2 0x04c2 0238 56 *JUMP label_0239: // Incoming return from call to 0x0E05 at 0x0383 // Incoming return from call to 0x0A0C at 0x02BC 0239 5B JUMPDEST 023A 00 *STOP // Stack delta = +0 // Outputs[1] { @023A stop(); } // Block terminates label_023B: // Incoming jump from 0x0187, if 0x0e89341c == stack[-1] // Inputs[1] { @0242 msg.data.length } 023B 5B JUMPDEST 023C 61 PUSH2 0x0219 023F 61 PUSH2 0x0249 0242 36 CALLDATASIZE 0243 60 PUSH1 0x04 0245 61 PUSH2 0x2114 0248 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @023C stack[0] = 0x0219 // @023F stack[1] = 0x0249 // @0242 stack[2] = msg.data.length // @0243 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2114 0249 5B JUMPDEST 024A 61 PUSH2 0x04fb 024D 56 *JUMP label_024E: // Incoming jump from 0x0192, if 0x0ebd4c7f == stack[-1] // Inputs[1] { @0255 msg.data.length } 024E 5B JUMPDEST 024F 61 PUSH2 0x0261 0252 61 PUSH2 0x025c 0255 36 CALLDATASIZE 0256 60 PUSH1 0x04 0258 61 PUSH2 0x2114 025B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @024F stack[0] = 0x0261 // @0252 stack[1] = 0x025c // @0255 stack[2] = msg.data.length // @0256 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2114 025C 5B JUMPDEST 025D 61 PUSH2 0x0506 0260 56 *JUMP label_0261: // Incoming return from call to 0x028F at 0x028E // Inputs[2] // { // @0264 memory[0x40:0x60] // @0268 stack[-1] // } 0261 5B JUMPDEST 0262 60 PUSH1 0x40 0264 51 MLOAD 0265 61 PUSH2 0x01e8 0268 91 SWAP2 0269 90 SWAP1 026A 61 PUSH2 0x2a0f 026D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0268 stack[-1] = 0x01e8 // @0269 stack[1] = memory[0x40:0x60] // @0269 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2a0f label_026E: // Incoming jump from 0x019D, if 0x2eb2c2d6 == stack[-1] // Inputs[1] { @0275 msg.data.length } 026E 5B JUMPDEST 026F 61 PUSH2 0x0239 0272 61 PUSH2 0x027c 0275 36 CALLDATASIZE 0276 60 PUSH1 0x04 0278 61 PUSH2 0x1e33 027B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @026F stack[0] = 0x0239 // @0272 stack[1] = 0x027c // @0275 stack[2] = msg.data.length // @0276 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1e33 027C 5B JUMPDEST 027D 61 PUSH2 0x05f9 0280 56 *JUMP label_0281: // Incoming jump from 0x014B, if 0x4e1273f4 == stack[-1] // Inputs[1] { @0288 msg.data.length } 0281 5B JUMPDEST 0282 61 PUSH2 0x0261 0285 61 PUSH2 0x028f 0288 36 CALLDATASIZE 0289 60 PUSH1 0x04 028B 61 PUSH2 0x2036 028E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0282 stack[0] = 0x0261 // @0285 stack[1] = 0x028f // @0288 stack[2] = msg.data.length // @0289 stack[3] = 0x04 // } // Block ends with call to 0x2036, returns to 0x028F label_028F: // Incoming return from call to 0x2036 at 0x028E 028F 5B JUMPDEST 0290 61 PUSH2 0x08ef 0293 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08ef label_0294: // Incoming jump from 0x0156, if 0x6308f1cd == stack[-1] // Inputs[1] { @029B msg.data.length } 0294 5B JUMPDEST 0295 61 PUSH2 0x02a7 0298 61 PUSH2 0x02a2 029B 36 CALLDATASIZE 029C 60 PUSH1 0x04 029E 61 PUSH2 0x2132 02A1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0295 stack[0] = 0x02a7 // @0298 stack[1] = 0x02a2 // @029B stack[2] = msg.data.length // @029C stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2132 02A2 5B JUMPDEST 02A3 61 PUSH2 0x09c9 02A6 56 *JUMP 02A7 5B JUMPDEST 02A8 60 PUSH1 0x40 02AA 51 MLOAD 02AB 61 PUSH2 0x01e8 02AE 92 SWAP3 02AF 91 SWAP2 02B0 90 SWAP1 02B1 61 PUSH2 0x2904 02B4 56 *JUMP label_02B5: // Incoming jump from 0x0161, if 0x715018a6 == stack[-1] 02B5 5B JUMPDEST 02B6 61 PUSH2 0x0239 02B9 61 PUSH2 0x0a0c 02BC 56 *JUMP // Stack delta = +1 // Outputs[1] { @02B6 stack[0] = 0x0239 } // Block ends with call to 0x0a0c, returns to 0x0239 label_02BD: // Incoming jump from 0x011A, if 0x7df73e27 == stack[-1] // Inputs[1] { @02C4 msg.data.length } 02BD 5B JUMPDEST 02BE 61 PUSH2 0x0204 02C1 61 PUSH2 0x02cb 02C4 36 CALLDATASIZE 02C5 60 PUSH1 0x04 02C7 61 PUSH2 0x1ddb 02CA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02BE stack[0] = 0x0204 // @02C1 stack[1] = 0x02cb // @02C4 stack[2] = msg.data.length // @02C5 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1ddb 02CB 5B JUMPDEST 02CC 61 PUSH2 0x0a7a 02CF 56 *JUMP label_02D0: // Incoming jump from 0x0125, if 0x8da5cb5b == stack[-1] 02D0 5B JUMPDEST 02D1 61 PUSH2 0x02d8 02D4 61 PUSH2 0x0a8d 02D7 56 *JUMP // Stack delta = +1 // Outputs[1] { @02D1 stack[0] = 0x02d8 } // Block ends with call to 0x0a8d, returns to 0x02D8 label_02D8: // Incoming return from call to 0x0A8D at 0x02D7 // Inputs[2] // { // @02DB memory[0x40:0x60] // @02DF stack[-1] // } 02D8 5B JUMPDEST 02D9 60 PUSH1 0x40 02DB 51 MLOAD 02DC 61 PUSH2 0x01e8 02DF 91 SWAP2 02E0 90 SWAP1 02E1 61 PUSH2 0x28f6 02E4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02DF stack[-1] = 0x01e8 // @02E0 stack[1] = memory[0x40:0x60] // @02E0 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x28f6 label_02E5: // Incoming jump from 0x0130, if 0x8f32d59b == stack[-1] 02E5 5B JUMPDEST 02E6 61 PUSH2 0x0204 02E9 61 PUSH2 0x0a9d 02EC 56 *JUMP // Stack delta = +1 // Outputs[1] { @02E6 stack[0] = 0x0204 } // Block ends with call to 0x0a9d, returns to 0x0204 label_02ED: // Incoming jump from 0x013B, if 0x938e3d7b == stack[-1] // Inputs[1] { @02F4 msg.data.length } 02ED 5B JUMPDEST 02EE 61 PUSH2 0x0239 02F1 61 PUSH2 0x02fb 02F4 36 CALLDATASIZE 02F5 60 PUSH1 0x04 02F7 61 PUSH2 0x20e0 02FA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02EE stack[0] = 0x0239 // @02F1 stack[1] = 0x02fb // @02F4 stack[2] = msg.data.length // @02F5 stack[3] = 0x04 // } // Block ends with call to 0x20e0, returns to 0x02FB label_02FB: // Incoming return from call to 0x20E0 at 0x02FA 02FB 5B JUMPDEST 02FC 61 PUSH2 0x0ac3 02FF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ac3 label_0300: // Incoming jump from 0x00DE, if 0x95d89b41 == stack[-1] 0300 5B JUMPDEST 0301 61 PUSH2 0x0219 0304 61 PUSH2 0x0af0 0307 56 *JUMP // Stack delta = +1 // Outputs[1] { @0301 stack[0] = 0x0219 } // Block ends with call to 0x0af0, returns to 0x0219 label_0308: // Incoming jump from 0x00E9, if 0x99e0dd7c == stack[-1] // Inputs[1] { @030F msg.data.length } 0308 5B JUMPDEST 0309 61 PUSH2 0x0239 030C 61 PUSH2 0x0316 030F 36 CALLDATASIZE 0310 60 PUSH1 0x04 0312 61 PUSH2 0x20e0 0315 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0309 stack[0] = 0x0239 // @030C stack[1] = 0x0316 // @030F stack[2] = msg.data.length // @0310 stack[3] = 0x04 // } // Block ends with call to 0x20e0, returns to 0x0316 label_0316: // Incoming return from call to 0x20E0 at 0x0315 0316 5B JUMPDEST 0317 61 PUSH2 0x0b4b 031A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b4b label_031B: // Incoming jump from 0x00F4, if 0xa22cb465 == stack[-1] // Inputs[1] { @0322 msg.data.length } 031B 5B JUMPDEST 031C 61 PUSH2 0x0239 031F 61 PUSH2 0x0329 0322 36 CALLDATASIZE 0323 60 PUSH1 0x04 0325 61 PUSH2 0x1f89 0328 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @031C stack[0] = 0x0239 // @031F stack[1] = 0x0329 // @0322 stack[2] = msg.data.length // @0323 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1f89 0329 5B JUMPDEST 032A 61 PUSH2 0x0b78 032D 56 *JUMP label_032E: // Incoming jump from 0x00AD, if 0xb9c4d9fb == stack[-1] // Inputs[1] { @0335 msg.data.length } 032E 5B JUMPDEST 032F 61 PUSH2 0x0341 0332 61 PUSH2 0x033c 0335 36 CALLDATASIZE 0336 60 PUSH1 0x04 0338 61 PUSH2 0x2114 033B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @032F stack[0] = 0x0341 // @0332 stack[1] = 0x033c // @0335 stack[2] = msg.data.length // @0336 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2114 033C 5B JUMPDEST 033D 61 PUSH2 0x0be7 0340 56 *JUMP 0341 5B JUMPDEST 0342 60 PUSH1 0x40 0344 51 MLOAD 0345 61 PUSH2 0x01e8 0348 91 SWAP2 0349 90 SWAP1 034A 61 PUSH2 0x29cd 034D 56 *JUMP label_034E: // Incoming jump from 0x00B8, if 0xc0ac9983 == stack[-1] 034E 5B JUMPDEST 034F 61 PUSH2 0x0219 0352 61 PUSH2 0x0cdf 0355 56 *JUMP // Stack delta = +1 // Outputs[1] { @034F stack[0] = 0x0219 } // Block ends with call to 0x0cdf, returns to 0x0219 label_0356: // Incoming jump from 0x00C3, if 0xc6bf3262 == stack[-1] // Inputs[1] { @035D msg.data.length } 0356 5B JUMPDEST 0357 61 PUSH2 0x0239 035A 61 PUSH2 0x0364 035D 36 CALLDATASIZE 035E 60 PUSH1 0x04 0360 61 PUSH2 0x2151 0363 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0357 stack[0] = 0x0239 // @035A stack[1] = 0x0364 // @035D stack[2] = msg.data.length // @035E stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2151 0364 5B JUMPDEST 0365 61 PUSH2 0x0d3a 0368 56 *JUMP label_0369: // Incoming jump from 0x00CE, if 0xcd53d08e == stack[-1] // Inputs[1] { @0370 msg.data.length } 0369 5B JUMPDEST 036A 61 PUSH2 0x02d8 036D 61 PUSH2 0x0377 0370 36 CALLDATASIZE 0371 60 PUSH1 0x04 0373 61 PUSH2 0x2114 0376 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @036A stack[0] = 0x02d8 // @036D stack[1] = 0x0377 // @0370 stack[2] = msg.data.length // @0371 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2114 0377 5B JUMPDEST 0378 61 PUSH2 0x0dea 037B 56 *JUMP label_037C: // Incoming jump from 0x007C, if 0xe5c8b03d == stack[-1] 037C 5B JUMPDEST 037D 61 PUSH2 0x0239 0380 61 PUSH2 0x0e05 0383 56 *JUMP // Stack delta = +1 // Outputs[1] { @037D stack[0] = 0x0239 } // Block ends with call to 0x0e05, returns to 0x0239 label_0384: // Incoming jump from 0x0087, if 0xe8a3d485 == stack[-1] 0384 5B JUMPDEST 0385 61 PUSH2 0x0219 0388 61 PUSH2 0x0e17 038B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0385 stack[0] = 0x0219 } // Block ends with call to 0x0e17, returns to 0x0219 label_038C: // Incoming jump from 0x0092, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0393 msg.data.length } 038C 5B JUMPDEST 038D 61 PUSH2 0x0204 0390 61 PUSH2 0x039a 0393 36 CALLDATASIZE 0394 60 PUSH1 0x04 0396 61 PUSH2 0x1df9 0399 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @038D stack[0] = 0x0204 // @0390 stack[1] = 0x039a // @0393 stack[2] = msg.data.length // @0394 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1df9 039A 5B JUMPDEST 039B 61 PUSH2 0x0e72 039E 56 *JUMP label_039F: // Incoming jump from 0x004B, if 0xeb12d61e == stack[-1] // Inputs[1] { @03A6 msg.data.length } 039F 5B JUMPDEST 03A0 61 PUSH2 0x0239 03A3 61 PUSH2 0x03ad 03A6 36 CALLDATASIZE 03A7 60 PUSH1 0x04 03A9 61 PUSH2 0x1ddb 03AC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03A0 stack[0] = 0x0239 // @03A3 stack[1] = 0x03ad // @03A6 stack[2] = msg.data.length // @03A7 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1ddb 03AD 5B JUMPDEST 03AE 61 PUSH2 0x0ea0 03B1 56 *JUMP label_03B2: // Incoming jump from 0x0056, if 0xf242432a == stack[-1] // Inputs[1] { @03B9 msg.data.length } 03B2 5B JUMPDEST 03B3 61 PUSH2 0x0239 03B6 61 PUSH2 0x03c0 03B9 36 CALLDATASIZE 03BA 60 PUSH1 0x04 03BC 61 PUSH2 0x1efa 03BF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03B3 stack[0] = 0x0239 // @03B6 stack[1] = 0x03c0 // @03B9 stack[2] = msg.data.length // @03BA stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1efa 03C0 5B JUMPDEST 03C1 61 PUSH2 0x0ecd 03C4 56 *JUMP label_03C5: // Incoming jump from 0x0061, if 0xf2fde38b == stack[-1] // Inputs[1] { @03CC msg.data.length } 03C5 5B JUMPDEST 03C6 61 PUSH2 0x0239 03C9 61 PUSH2 0x03d3 03CC 36 CALLDATASIZE 03CD 60 PUSH1 0x04 03CF 61 PUSH2 0x1ddb 03D2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03C6 stack[0] = 0x0239 // @03C9 stack[1] = 0x03d3 // @03CC stack[2] = msg.data.length // @03CD stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1ddb 03D3 5B JUMPDEST 03D4 61 PUSH2 0x1087 03D7 56 *JUMP label_03D8: // Incoming jump from 0x006C, if 0xf5298aca == stack[-1] // Inputs[1] { @03DF msg.data.length } 03D8 5B JUMPDEST 03D9 61 PUSH2 0x0239 03DC 61 PUSH2 0x03e6 03DF 36 CALLDATASIZE 03E0 60 PUSH1 0x04 03E2 61 PUSH2 0x1fe9 03E5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03D9 stack[0] = 0x0239 // @03DC stack[1] = 0x03e6 // @03DF stack[2] = msg.data.length // @03E0 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1fe9 03E6 5B JUMPDEST 03E7 61 PUSH2 0x10b4 03EA 56 *JUMP 03EB 5B JUMPDEST 03EC 60 PUSH1 0x00 03EE 81 DUP2 03EF 81 DUP2 03F0 52 MSTORE 03F1 60 PUSH1 0x06 03F3 60 PUSH1 0x20 03F5 90 SWAP1 03F6 81 DUP2 03F7 52 MSTORE 03F8 60 PUSH1 0x40 03FA 80 DUP1 03FB 83 DUP4 03FC 20 SHA3 03FD 60 PUSH1 0x01 03FF 60 PUSH1 0x01 0401 60 PUSH1 0xa0 0403 1B SHL 0404 03 SUB 0405 86 DUP7 0406 16 AND 0407 84 DUP5 0408 52 MSTORE 0409 90 SWAP1 040A 91 SWAP2 040B 52 MSTORE 040C 90 SWAP1 040D 20 SHA3 040E 54 SLOAD label_040F: // Incoming return from call to 0x2D3A at 0x1CED // Incoming return from call to 0x2686 at 0x2B2C // Incoming return from call to 0x264D at 0x2B1C // Incoming return from call to 0x223B at 0x2903 // Incoming return from call to 0x2D31 at 0x1CE2 // Incoming return from call to 0x2C9A at 0x2C87 // Incoming return from call to 0x250D at 0x2ADC // Inputs[3] // { // @0410 stack[-1] // @0410 stack[-4] // @0411 stack[-3] // } 040F 5B JUMPDEST 0410 92 SWAP3 0411 91 SWAP2 0412 50 POP 0413 50 POP 0414 56 *JUMP // Stack delta = -3 // Outputs[1] { @0410 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] 0415 5B JUMPDEST 0416 60 PUSH1 0x01 0418 60 PUSH1 0x01 041A 60 PUSH1 0xe0 041C 1B SHL 041D 03 SUB 041E 19 NOT 041F 16 AND 0420 60 PUSH1 0x00 0422 90 SWAP1 0423 81 DUP2 0424 52 MSTORE 0425 60 PUSH1 0x20 0427 81 DUP2 0428 90 SWAP1 0429 52 MSTORE 042A 60 PUSH1 0x40 042C 90 SWAP1 042D 20 SHA3 042E 54 SLOAD 042F 60 PUSH1 0xff 0431 16 AND 0432 90 SWAP1 0433 56 *JUMP label_0434: // Incoming call from 0x0218, returns to 0x0219 // Inputs[2] // { // @0438 storage[0x0a] // @043C memory[0x40:0x60] // } 0434 5B JUMPDEST 0435 60 PUSH1 0x0a 0437 80 DUP1 0438 54 SLOAD 0439 60 PUSH1 0x40 043B 80 DUP1 043C 51 MLOAD 043D 60 PUSH1 0x20 043F 60 PUSH1 0x02 0441 60 PUSH1 0x01 0443 85 DUP6 0444 16 AND 0445 15 ISZERO 0446 61 PUSH2 0x0100 0449 02 MUL 044A 60 PUSH1 0x00 044C 19 NOT 044D 01 ADD 044E 90 SWAP1 044F 94 SWAP5 0450 16 AND 0451 93 SWAP4 0452 90 SWAP1 0453 93 SWAP4 0454 04 DIV 0455 60 PUSH1 0x1f 0457 81 DUP2 0458 01 ADD 0459 84 DUP5 045A 90 SWAP1 045B 04 DIV 045C 84 DUP5 045D 02 MUL 045E 82 DUP3 045F 01 ADD 0460 84 DUP5 0461 01 ADD 0462 90 SWAP1 0463 92 SWAP3 0464 52 MSTORE 0465 81 DUP2 0466 81 DUP2 0467 52 MSTORE 0468 92 SWAP3 0469 91 SWAP2 046A 83 DUP4 046B 01 ADD 046C 82 DUP3 046D 82 DUP3 046E 80 DUP1 046F 15 ISZERO 0470 61 PUSH2 0x04ba 0473 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @0463 stack[2] = (storage[0x0a] & ~0x00 + 0x0100 * !(storage[0x0a] & 0x01)) / 0x02 // @0464 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x0a] & ~0x00 + 0x0100 * !(storage[0x0a] & 0x01)) / 0x02 + 0x1f) / 0x20) // @0467 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x0a] & ~0x00 + 0x0100 * !(storage[0x0a] & 0x01)) / 0x02 // @0468 stack[0] = memory[0x40:0x60] // @0469 stack[1] = 0x0a // @046B stack[3] = memory[0x40:0x60] + 0x20 // @046C stack[4] = 0x0a // @046D stack[5] = (storage[0x0a] & ~0x00 + 0x0100 * !(storage[0x0a] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x04ba, if !((storage[0x0a] & ~0x00 + 0x0100 * !(storage[0x0a] & 0x01)) / 0x02) label_0474: // Incoming jump from 0x0473, if not !((storage[0x0a] & ~0x00 + 0x0100 * !(storage[0x0a] & 0x01)) / 0x02) // Inputs[1] { @0474 stack[-1] } 0474 80 DUP1 0475 60 PUSH1 0x1f 0477 10 LT 0478 61 PUSH2 0x048f 047B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048f, if 0x1f < stack[-1] label_047C: // Incoming jump from 0x047B, if not 0x1f < stack[-1] // Inputs[4] // { // @0480 stack[-2] // @0481 storage[stack[-2]] // @0484 stack[-3] // @0486 stack[-1] // } 047C 61 PUSH2 0x0100 047F 80 DUP1 0480 83 DUP4 0481 54 SLOAD 0482 04 DIV 0483 02 MUL 0484 83 DUP4 0485 52 MSTORE 0486 91 SWAP2 0487 60 PUSH1 0x20 0489 01 ADD 048A 91 SWAP2 048B 61 PUSH2 0x04ba 048E 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0485 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @048A stack[-1] = stack[-1] // @048A stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x04ba label_048F: // Incoming jump from 0x0E5E, if 0x1f < stack[-1] // Incoming jump from 0x0D26, if 0x1f < stack[-1] // Incoming jump from 0x047B, if 0x1f < stack[-1] // Incoming jump from 0x0B37, if 0x1f < stack[-1] // Inputs[5] // { // @0490 stack[-3] // @0491 stack[-1] // @0493 stack[-2] // @049B memory[0x00:0x20] // @049F storage[keccak256(memory[0x00:0x20])] // } 048F 5B JUMPDEST 0490 82 DUP3 0491 01 ADD 0492 91 SWAP2 0493 90 SWAP1 0494 60 PUSH1 0x00 0496 52 MSTORE 0497 60 PUSH1 0x20 0499 60 PUSH1 0x00 049B 20 SHA3 049C 90 SWAP1 049D 5B JUMPDEST 049E 81 DUP2 049F 54 SLOAD 04A0 81 DUP2 04A1 52 MSTORE 04A2 90 SWAP1 04A3 60 PUSH1 0x01 04A5 01 ADD 04A6 90 SWAP1 04A7 60 PUSH1 0x20 04A9 01 ADD 04AA 80 DUP1 04AB 83 DUP4 04AC 11 GT 04AD 61 PUSH2 0x049d 04B0 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0492 stack[-3] = stack[-3] + stack[-1] // @0496 memory[0x00:0x20] = stack[-2] // @04A1 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @04A6 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @04A9 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x049d, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_04B1: // Incoming jump from 0x04B0, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x04B0, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @04B1 stack[-3] // @04B2 stack[-1] // } 04B1 82 DUP3 04B2 90 SWAP1 04B3 03 SUB 04B4 60 PUSH1 0x1f 04B6 16 AND 04B7 82 DUP3 04B8 01 ADD 04B9 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @04B9 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @04B9 stack[-1] = stack[-3] // } // Block continues label_04BA: // Incoming jump from 0x04B9 // Incoming jump from 0x0B4A // Incoming jump from 0x0E71 // Incoming jump from 0x0E56, if !((storage[0x05] & ~0x00 + 0x0100 * !(storage[0x05] & 0x01)) / 0x02) // Incoming jump from 0x048E // Incoming jump from 0x0B2F, if !((storage[0x0b] & ~0x00 + 0x0100 * !(storage[0x0b] & 0x01)) / 0x02) // Incoming jump from 0x0473, if !((storage[0x0a] & ~0x00 + 0x0100 * !(storage[0x0a] & 0x01)) / 0x02) // Incoming jump from 0x0D39 // Incoming jump from 0x0D1E, if !((storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02) // Inputs[1] { @04C0 stack[-7] } 04BA 5B JUMPDEST 04BB 50 POP 04BC 50 POP 04BD 50 POP 04BE 50 POP 04BF 50 POP 04C0 81 DUP2 04C1 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] 04C2 5B JUMPDEST 04C3 61 PUSH2 0x04ca 04C6 61 PUSH2 0x0a9d 04C9 56 *JUMP 04CA 5B JUMPDEST 04CB 61 PUSH2 0x04ef 04CE 57 *JUMPI 04CF 60 PUSH1 0x40 04D1 51 MLOAD 04D2 62 PUSH3 0x461bcd 04D6 60 PUSH1 0xe5 04D8 1B SHL 04D9 81 DUP2 04DA 52 MSTORE 04DB 60 PUSH1 0x04 04DD 01 ADD 04DE 61 PUSH2 0x04e6 04E1 90 SWAP1 04E2 61 PUSH2 0x2b0d 04E5 56 *JUMP 04E6 5B JUMPDEST 04E7 60 PUSH1 0x40 04E9 51 MLOAD 04EA 80 DUP1 04EB 91 SWAP2 04EC 03 SUB 04ED 90 SWAP1 04EE FD *REVERT 04EF 5B JUMPDEST 04F0 61 PUSH2 0x04f8 04F3 81 DUP2 04F4 61 PUSH2 0x11ac 04F7 56 *JUMP label_04F8: // Incoming jump from 0x2D23, if stack[-2] == stack[-1] // Inputs[1] { @04FA stack[-2] } 04F8 5B JUMPDEST 04F9 50 POP 04FA 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 04FB 5B JUMPDEST 04FC 60 PUSH1 0x60 04FE 61 PUSH2 0x040f 0501 82 DUP3 0502 61 PUSH2 0x11f4 0505 56 *JUMP 0506 5B JUMPDEST 0507 60 PUSH1 0x00 0509 81 DUP2 050A 81 DUP2 050B 52 MSTORE 050C 60 PUSH1 0x09 050E 60 PUSH1 0x20 0510 90 SWAP1 0511 81 DUP2 0512 52 MSTORE 0513 60 PUSH1 0x40 0515 80 DUP1 0516 83 DUP4 0517 20 SHA3 0518 80 DUP1 0519 54 SLOAD 051A 82 DUP3 051B 51 MLOAD 051C 81 DUP2 051D 85 DUP6 051E 02 MUL 051F 81 DUP2 0520 01 ADD 0521 85 DUP6 0522 01 ADD 0523 90 SWAP1 0524 93 SWAP4 0525 52 MSTORE 0526 80 DUP1 0527 83 DUP4 0528 52 MSTORE 0529 60 PUSH1 0x60 052B 94 SWAP5 052C 85 DUP6 052D 94 SWAP5 052E 84 DUP5 052F 01 ADD 0530 5B JUMPDEST 0531 82 DUP3 0532 82 DUP3 0533 10 LT 0534 15 ISZERO 0535 61 PUSH2 0x0578 0538 57 *JUMPI 0539 60 PUSH1 0x00 053B 84 DUP5 053C 81 DUP2 053D 52 MSTORE 053E 60 PUSH1 0x20 0540 90 SWAP1 0541 81 DUP2 0542 90 SWAP1 0543 20 SHA3 0544 60 PUSH1 0x40 0546 80 DUP1 0547 51 MLOAD 0548 80 DUP1 0549 82 DUP3 054A 01 ADD 054B 90 SWAP1 054C 91 SWAP2 054D 52 MSTORE 054E 60 PUSH1 0x02 0550 85 DUP6 0551 02 MUL 0552 90 SWAP1 0553 91 SWAP2 0554 01 ADD 0555 80 DUP1 0556 54 SLOAD 0557 60 PUSH1 0x01 0559 60 PUSH1 0x01 055B 60 PUSH1 0xa0 055D 1B SHL 055E 03 SUB 055F 16 AND 0560 82 DUP3 0561 52 MSTORE 0562 60 PUSH1 0x01 0564 90 SWAP1 0565 81 DUP2 0566 01 ADD 0567 54 SLOAD 0568 82 DUP3 0569 84 DUP5 056A 01 ADD 056B 52 MSTORE 056C 90 SWAP1 056D 83 DUP4 056E 52 MSTORE 056F 90 SWAP1 0570 92 SWAP3 0571 01 ADD 0572 91 SWAP2 0573 01 ADD 0574 61 PUSH2 0x0530 0577 56 *JUMP 0578 5B JUMPDEST 0579 50 POP 057A 50 POP 057B 50 POP 057C 50 POP 057D 90 SWAP1 057E 50 POP 057F 60 PUSH1 0x60 0581 81 DUP2 0582 51 MLOAD 0583 60 PUSH1 0x40 0585 51 MLOAD 0586 90 SWAP1 0587 80 DUP1 0588 82 DUP3 0589 52 MSTORE 058A 80 DUP1 058B 60 PUSH1 0x20 058D 02 MUL 058E 60 PUSH1 0x20 0590 01 ADD 0591 82 DUP3 0592 01 ADD 0593 60 PUSH1 0x40 0595 52 MSTORE 0596 80 DUP1 0597 15 ISZERO 0598 61 PUSH2 0x05ab 059B 57 *JUMPI 059C 81 DUP2 059D 60 PUSH1 0x20 059F 01 ADD 05A0 60 PUSH1 0x20 05A2 82 DUP3 05A3 02 MUL 05A4 80 DUP1 05A5 38 CODESIZE 05A6 83 DUP4 05A7 39 CODECOPY 05A8 01 ADD 05A9 90 SWAP1 05AA 50 POP 05AB 5B JUMPDEST 05AC 50 POP 05AD 90 SWAP1 05AE 50 POP 05AF 60 PUSH1 0x00 05B1 5B JUMPDEST 05B2 82 DUP3 05B3 51 MLOAD 05B4 81 DUP2 05B5 10 LT 05B6 15 ISZERO 05B7 61 PUSH2 0x05f1 05BA 57 *JUMPI 05BB 82 DUP3 05BC 81 DUP2 05BD 81 DUP2 05BE 51 MLOAD 05BF 81 DUP2 05C0 10 LT 05C1 61 PUSH2 0x05c6 05C4 57 *JUMPI 05C5 FE *ASSERT 05C6 5B JUMPDEST 05C7 60 PUSH1 0x20 05C9 02 MUL 05CA 60 PUSH1 0x20 05CC 01 ADD 05CD 01 ADD 05CE 51 MLOAD 05CF 60 PUSH1 0x20 05D1 01 ADD 05D2 51 MLOAD 05D3 82 DUP3 05D4 82 DUP3 05D5 81 DUP2 05D6 51 MLOAD 05D7 81 DUP2 05D8 10 LT 05D9 61 PUSH2 0x05de 05DC 57 *JUMPI 05DD FE *ASSERT 05DE 5B JUMPDEST 05DF 60 PUSH1 0x20 05E1 90 SWAP1 05E2 81 DUP2 05E3 02 MUL 05E4 91 SWAP2 05E5 90 SWAP1 05E6 91 SWAP2 05E7 01 ADD 05E8 01 ADD 05E9 52 MSTORE 05EA 60 PUSH1 0x01 05EC 01 ADD 05ED 61 PUSH2 0x05b1 05F0 56 *JUMP 05F1 5B JUMPDEST 05F2 50 POP 05F3 93 SWAP4 05F4 92 SWAP3 05F5 50 POP 05F6 50 POP 05F7 50 POP 05F8 56 *JUMP 05F9 5B JUMPDEST 05FA 60 PUSH1 0x01 05FC 60 PUSH1 0x01 05FE 60 PUSH1 0xa0 0600 1B SHL 0601 03 SUB 0602 87 DUP8 0603 16 AND 0604 61 PUSH2 0x061f 0607 57 *JUMPI 0608 60 PUSH1 0x40 060A 51 MLOAD 060B 62 PUSH3 0x461bcd 060F 60 PUSH1 0xe5 0611 1B SHL 0612 81 DUP2 0613 52 MSTORE 0614 60 PUSH1 0x04 0616 01 ADD 0617 61 PUSH2 0x04e6 061A 90 SWAP1 061B 61 PUSH2 0x2abd 061E 56 *JUMP 061F 5B JUMPDEST 0620 84 DUP5 0621 83 DUP4 0622 14 EQ 0623 61 PUSH2 0x063e 0626 57 *JUMPI 0627 60 PUSH1 0x40 0629 51 MLOAD 062A 62 PUSH3 0x461bcd 062E 60 PUSH1 0xe5 0630 1B SHL 0631 81 DUP2 0632 52 MSTORE 0633 60 PUSH1 0x04 0635 01 ADD 0636 61 PUSH2 0x04e6 0639 90 SWAP1 063A 61 PUSH2 0x2b4d 063D 56 *JUMP 063E 5B JUMPDEST 063F 60 PUSH1 0x01 0641 60 PUSH1 0x01 0643 60 PUSH1 0xa0 0645 1B SHL 0646 03 SUB 0647 88 DUP9 0648 16 AND 0649 33 CALLER 064A 14 EQ 064B 80 DUP1 064C 61 PUSH2 0x067d 064F 57 *JUMPI 0650 50 POP 0651 60 PUSH1 0x01 0653 60 PUSH1 0x01 0655 60 PUSH1 0xa0 0657 1B SHL 0658 03 SUB 0659 88 DUP9 065A 16 AND 065B 60 PUSH1 0x00 065D 90 SWAP1 065E 81 DUP2 065F 52 MSTORE 0660 60 PUSH1 0x07 0662 60 PUSH1 0x20 0664 90 SWAP1 0665 81 DUP2 0666 52 MSTORE 0667 60 PUSH1 0x40 0669 80 DUP1 066A 83 DUP4 066B 20 SHA3 066C 33 CALLER 066D 84 DUP5 066E 52 MSTORE 066F 90 SWAP1 0670 91 SWAP2 0671 52 MSTORE 0672 90 SWAP1 0673 20 SHA3 0674 54 SLOAD 0675 60 PUSH1 0xff 0677 16 AND 0678 15 ISZERO 0679 15 ISZERO 067A 60 PUSH1 0x01 067C 14 EQ 067D 5B JUMPDEST 067E 61 PUSH2 0x0699 0681 57 *JUMPI 0682 60 PUSH1 0x40 0684 51 MLOAD 0685 62 PUSH3 0x461bcd 0689 60 PUSH1 0xe5 068B 1B SHL 068C 81 DUP2 068D 52 MSTORE 068E 60 PUSH1 0x04 0690 01 ADD 0691 61 PUSH2 0x04e6 0694 90 SWAP1 0695 61 PUSH2 0x2aed 0698 56 *JUMP 0699 5B JUMPDEST 069A 60 PUSH1 0x00 069C 5B JUMPDEST 069D 85 DUP6 069E 81 DUP2 069F 10 LT 06A0 15 ISZERO 06A1 61 PUSH2 0x07ce 06A4 57 *JUMPI 06A5 60 PUSH1 0x00 06A7 87 DUP8 06A8 87 DUP8 06A9 83 DUP4 06AA 81 DUP2 06AB 81 DUP2 06AC 10 LT 06AD 61 PUSH2 0x06b2 06B0 57 *JUMPI 06B1 FE *ASSERT 06B2 5B JUMPDEST 06B3 90 SWAP1 06B4 50 POP 06B5 60 PUSH1 0x20 06B7 02 MUL 06B8 01 ADD 06B9 35 CALLDATALOAD 06BA 90 SWAP1 06BB 50 POP 06BC 60 PUSH1 0x00 06BE 86 DUP7 06BF 86 DUP7 06C0 84 DUP5 06C1 81 DUP2 06C2 81 DUP2 06C3 10 LT 06C4 61 PUSH2 0x06c9 06C7 57 *JUMPI 06C8 FE *ASSERT 06C9 5B JUMPDEST 06CA 90 SWAP1 06CB 50 POP 06CC 60 PUSH1 0x20 06CE 02 MUL 06CF 01 ADD 06D0 35 CALLDATALOAD 06D1 90 SWAP1 06D2 50 POP 06D3 61 PUSH2 0x071b 06D6 81 DUP2 06D7 60 PUSH1 0x06 06D9 60 PUSH1 0x00 06DB 85 DUP6 06DC 81 DUP2 06DD 52 MSTORE 06DE 60 PUSH1 0x20 06E0 01 ADD 06E1 90 SWAP1 06E2 81 DUP2 06E3 52 MSTORE 06E4 60 PUSH1 0x20 06E6 01 ADD 06E7 60 PUSH1 0x00 06E9 20 SHA3 06EA 60 PUSH1 0x00 06EC 8E DUP15 06ED 60 PUSH1 0x01 06EF 60 PUSH1 0x01 06F1 60 PUSH1 0xa0 06F3 1B SHL 06F4 03 SUB 06F5 16 AND 06F6 60 PUSH1 0x01 06F8 60 PUSH1 0x01 06FA 60 PUSH1 0xa0 06FC 1B SHL 06FD 03 SUB 06FE 16 AND 06FF 81 DUP2 0700 52 MSTORE 0701 60 PUSH1 0x20 0703 01 ADD 0704 90 SWAP1 0705 81 DUP2 0706 52 MSTORE 0707 60 PUSH1 0x20 0709 01 ADD 070A 60 PUSH1 0x00 070C 20 SHA3 070D 54 SLOAD 070E 61 PUSH2 0x132f 0711 90 SWAP1 0712 91 SWAP2 0713 90 SWAP1 0714 63 PUSH4 0xffffffff 0719 16 AND 071A 56 *JUMP 071B 5B JUMPDEST 071C 60 PUSH1 0x06 071E 60 PUSH1 0x00 0720 84 DUP5 0721 81 DUP2 0722 52 MSTORE 0723 60 PUSH1 0x20 0725 01 ADD 0726 90 SWAP1 0727 81 DUP2 0728 52 MSTORE 0729 60 PUSH1 0x20 072B 01 ADD 072C 60 PUSH1 0x00 072E 20 SHA3 072F 60 PUSH1 0x00 0731 8D DUP14 0732 60 PUSH1 0x01 0734 60 PUSH1 0x01 0736 60 PUSH1 0xa0 0738 1B SHL 0739 03 SUB 073A 16 AND 073B 60 PUSH1 0x01 073D 60 PUSH1 0x01 073F 60 PUSH1 0xa0 0741 1B SHL 0742 03 SUB 0743 16 AND 0744 81 DUP2 0745 52 MSTORE 0746 60 PUSH1 0x20 0748 01 ADD 0749 90 SWAP1 074A 81 DUP2 074B 52 MSTORE 074C 60 PUSH1 0x20 074E 01 ADD 074F 60 PUSH1 0x00 0751 20 SHA3 0752 81 DUP2 0753 90 SWAP1 0754 55 SSTORE 0755 50 POP 0756 61 PUSH2 0x079e 0759 60 PUSH1 0x06 075B 60 PUSH1 0x00 075D 84 DUP5 075E 81 DUP2 075F 52 MSTORE 0760 60 PUSH1 0x20 0762 01 ADD 0763 90 SWAP1 0764 81 DUP2 0765 52 MSTORE 0766 60 PUSH1 0x20 0768 01 ADD 0769 60 PUSH1 0x00 076B 20 SHA3 076C 60 PUSH1 0x00 076E 8C DUP13 076F 60 PUSH1 0x01 0771 60 PUSH1 0x01 0773 60 PUSH1 0xa0 0775 1B SHL 0776 03 SUB 0777 16 AND 0778 60 PUSH1 0x01 077A 60 PUSH1 0x01 077C 60 PUSH1 0xa0 077E 1B SHL 077F 03 SUB 0780 16 AND 0781 81 DUP2 0782 52 MSTORE 0783 60 PUSH1 0x20 0785 01 ADD 0786 90 SWAP1 0787 81 DUP2 0788 52 MSTORE 0789 60 PUSH1 0x20 078B 01 ADD 078C 60 PUSH1 0x00 078E 20 SHA3 078F 54 SLOAD 0790 82 DUP3 0791 61 PUSH2 0x1341 0794 90 SWAP1 0795 91 SWAP2 0796 90 SWAP1 0797 63 PUSH4 0xffffffff 079C 16 AND 079D 56 *JUMP 079E 5B JUMPDEST 079F 60 PUSH1 0x00 07A1 92 SWAP3 07A2 83 DUP4 07A3 52 MSTORE 07A4 60 PUSH1 0x06 07A6 60 PUSH1 0x20 07A8 90 SWAP1 07A9 81 DUP2 07AA 52 MSTORE 07AB 60 PUSH1 0x40 07AD 80 DUP1 07AE 85 DUP6 07AF 20 SHA3 07B0 60 PUSH1 0x01 07B2 60 PUSH1 0x01 07B4 60 PUSH1 0xa0 07B6 1B SHL 07B7 03 SUB 07B8 8E DUP15 07B9 16 AND 07BA 86 DUP7 07BB 52 MSTORE 07BC 90 SWAP1 07BD 91 SWAP2 07BE 52 MSTORE 07BF 90 SWAP1 07C0 92 SWAP3 07C1 20 SHA3 07C2 91 SWAP2 07C3 90 SWAP1 07C4 91 SWAP2 07C5 55 SSTORE 07C6 50 POP 07C7 60 PUSH1 0x01 07C9 01 ADD 07CA 61 PUSH2 0x069c 07CD 56 *JUMP 07CE 5B JUMPDEST 07CF 50 POP 07D0 86 DUP7 07D1 60 PUSH1 0x01 07D3 60 PUSH1 0x01 07D5 60 PUSH1 0xa0 07D7 1B SHL 07D8 03 SUB 07D9 16 AND 07DA 88 DUP9 07DB 60 PUSH1 0x01 07DD 60 PUSH1 0x01 07DF 60 PUSH1 0xa0 07E1 1B SHL 07E2 03 SUB 07E3 16 AND 07E4 33 CALLER 07E5 60 PUSH1 0x01 07E7 60 PUSH1 0x01 07E9 60 PUSH1 0xa0 07EB 1B SHL 07EC 03 SUB 07ED 16 AND 07EE 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 080F 89 DUP10 0810 89 DUP10 0811 89 DUP10 0812 89 DUP10 0813 60 PUSH1 0x40 0815 51 MLOAD 0816 61 PUSH2 0x0822 0819 94 SWAP5 081A 93 SWAP4 081B 92 SWAP3 081C 91 SWAP2 081D 90 SWAP1 081E 61 PUSH2 0x29de 0821 56 *JUMP 0822 5B JUMPDEST 0823 60 PUSH1 0x40 0825 51 MLOAD 0826 80 DUP1 0827 91 SWAP2 0828 03 SUB 0829 90 SWAP1 082A A4 LOG4 082B 61 PUSH2 0x083c 082E 87 DUP8 082F 60 PUSH1 0x01 0831 60 PUSH1 0x01 0833 60 PUSH1 0xa0 0835 1B SHL 0836 03 SUB 0837 16 AND 0838 61 PUSH2 0x134e 083B 56 *JUMP 083C 5B JUMPDEST 083D 15 ISZERO 083E 61 PUSH2 0x08e5 0841 57 *JUMPI 0842 61 PUSH2 0x08e5 0845 33 CALLER 0846 89 DUP10 0847 89 DUP10 0848 89 DUP10 0849 89 DUP10 084A 80 DUP1 084B 80 DUP1 084C 60 PUSH1 0x20 084E 02 MUL 084F 60 PUSH1 0x20 0851 01 ADD 0852 60 PUSH1 0x40 0854 51 MLOAD 0855 90 SWAP1 0856 81 DUP2 0857 01 ADD 0858 60 PUSH1 0x40 085A 52 MSTORE 085B 80 DUP1 085C 93 SWAP4 085D 92 SWAP3 085E 91 SWAP2 085F 90 SWAP1 0860 81 DUP2 0861 81 DUP2 0862 52 MSTORE 0863 60 PUSH1 0x20 0865 01 ADD 0866 83 DUP4 0867 83 DUP4 0868 60 PUSH1 0x20 086A 02 MUL 086B 80 DUP1 086C 82 DUP3 086D 84 DUP5 086E 37 CALLDATACOPY 086F 60 PUSH1 0x00 0871 92 SWAP3 0872 01 ADD 0873 91 SWAP2 0874 90 SWAP1 0875 91 SWAP2 0876 52 MSTORE 0877 50 POP 0878 50 POP 0879 60 PUSH1 0x40 087B 80 DUP1 087C 51 MLOAD 087D 60 PUSH1 0x20 087F 80 DUP1 0880 8D DUP14 0881 02 MUL 0882 82 DUP3 0883 81 DUP2 0884 01 ADD 0885 82 DUP3 0886 01 ADD 0887 90 SWAP1 0888 93 SWAP4 0889 52 MSTORE 088A 8C DUP13 088B 82 DUP3 088C 52 MSTORE 088D 90 SWAP1 088E 93 SWAP4 088F 50 POP 0890 8C DUP13 0891 92 SWAP3 0892 50 POP 0893 8B DUP12 0894 91 SWAP2 0895 82 DUP3 0896 91 SWAP2 0897 85 DUP6 0898 01 ADD 0899 90 SWAP1 089A 84 DUP5 089B 90 SWAP1 089C 80 DUP1 089D 82 DUP3 089E 84 DUP5 089F 37 CALLDATACOPY 08A0 60 PUSH1 0x00 08A2 92 SWAP3 08A3 01 ADD 08A4 91 SWAP2 08A5 90 SWAP1 08A6 91 SWAP2 08A7 52 MSTORE 08A8 50 POP 08A9 50 POP 08AA 60 PUSH1 0x40 08AC 80 DUP1 08AD 51 MLOAD 08AE 60 PUSH1 0x20 08B0 60 PUSH1 0x1f 08B2 8C DUP13 08B3 01 ADD 08B4 81 DUP2 08B5 90 SWAP1 08B6 04 DIV 08B7 81 DUP2 08B8 02 MUL 08B9 82 DUP3 08BA 01 ADD 08BB 81 DUP2 08BC 01 ADD 08BD 90 SWAP1 08BE 92 SWAP3 08BF 52 MSTORE 08C0 8A DUP11 08C1 81 DUP2 08C2 52 MSTORE 08C3 92 SWAP3 08C4 50 POP 08C5 8A DUP11 08C6 91 SWAP2 08C7 50 POP 08C8 89 DUP10 08C9 90 SWAP1 08CA 81 DUP2 08CB 90 SWAP1 08CC 84 DUP5 08CD 01 ADD 08CE 83 DUP4 08CF 82 DUP3 08D0 80 DUP1 08D1 82 DUP3 08D2 84 DUP5 08D3 37 CALLDATACOPY 08D4 60 PUSH1 0x00 08D6 92 SWAP3 08D7 01 ADD 08D8 91 SWAP2 08D9 90 SWAP1 08DA 91 SWAP2 08DB 52 MSTORE 08DC 50 POP 08DD 61 PUSH2 0x138a 08E0 92 SWAP3 08E1 50 POP 08E2 50 POP 08E3 50 POP 08E4 56 *JUMP 08E5 5B JUMPDEST 08E6 50 POP 08E7 50 POP 08E8 50 POP 08E9 50 POP 08EA 50 POP 08EB 50 POP 08EC 50 POP 08ED 50 POP 08EE 56 *JUMP label_08EF: // Incoming jump from 0x0293 // Inputs[2] // { // @08F2 stack[-3] // @08F3 stack[-1] // } 08EF 5B JUMPDEST 08F0 60 PUSH1 0x60 08F2 83 DUP4 08F3 82 DUP3 08F4 14 EQ 08F5 61 PUSH2 0x08fd 08F8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08F0 stack[0] = 0x60 } // Block ends with conditional jump to 0x08fd, if stack[-1] == stack[-3] label_08F9: // Incoming jump from 0x08F8, if not stack[-1] == stack[-3] // Inputs[1] { @08FC memory[0x00:0x00] } 08F9 60 PUSH1 0x00 08FB 80 DUP1 08FC FD *REVERT // Stack delta = +0 // Outputs[1] { @08FC revert(memory[0x00:0x00]); } // Block terminates label_08FD: // Incoming jump from 0x08F8, if stack[-1] == stack[-3] // Inputs[2] // { // @0901 memory[0x40:0x60] // @0902 stack[-4] // } 08FD 5B JUMPDEST 08FE 60 PUSH1 0x40 0900 80 DUP1 0901 51 MLOAD 0902 85 DUP6 0903 81 DUP2 0904 52 MSTORE 0905 60 PUSH1 0x20 0907 80 DUP1 0908 87 DUP8 0909 02 MUL 090A 82 DUP3 090B 01 ADD 090C 01 ADD 090D 90 SWAP1 090E 91 SWAP2 090F 52 MSTORE 0910 60 PUSH1 0x60 0912 90 SWAP1 0913 85 DUP6 0914 80 DUP1 0915 15 ISZERO 0916 61 PUSH2 0x0929 0919 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0904 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-4] // @090F memory[0x40:0x60] = memory[0x40:0x60] + stack[-4] * 0x20 + 0x20 // @0912 stack[0] = 0x60 // @0912 stack[1] = memory[0x40:0x60] // @0913 stack[2] = stack[-4] // } // Block ends with conditional jump to 0x0929, if !stack[-4] label_091A: // Incoming jump from 0x0919, if not !stack[-4] // Inputs[5] // { // @091A stack[-2] // @0920 stack[-1] // @0923 code.length // @092B stack[-3] // @0930 stack[-7] // } 091A 81 DUP2 091B 60 PUSH1 0x20 091D 01 ADD 091E 60 PUSH1 0x20 0920 82 DUP3 0921 02 MUL 0922 80 DUP1 0923 38 CODESIZE 0924 83 DUP4 0925 39 CODECOPY 0926 01 ADD 0927 90 SWAP1 0928 50 POP 0929 5B JUMPDEST 092A 50 POP 092B 90 SWAP1 092C 50 POP 092D 60 PUSH1 0x00 092F 5B JUMPDEST 0930 85 DUP6 0931 81 DUP2 0932 10 LT 0933 15 ISZERO 0934 61 PUSH2 0x09bf 0937 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @0925 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = code[code.length:code.length + stack[-1] * 0x20] // @092B stack[-3] = stack[-2] // @092D stack[-2] = 0x00 // } // Block ends with conditional jump to 0x09bf, if !(0x00 < stack[-7]) label_0938: // Incoming jump from 0x0937, if not !(0x00 < stack[-7]) // Incoming jump from 0x0937, if not !(0x00 < stack[-7]) // Inputs[3] // { // @093C stack[-5] // @093D stack[-4] // @093E stack[-1] // } 0938 60 PUSH1 0x06 093A 60 PUSH1 0x00 093C 86 DUP7 093D 86 DUP7 093E 84 DUP5 093F 81 DUP2 0940 81 DUP2 0941 10 LT 0942 61 PUSH2 0x0947 0945 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @0938 stack[0] = 0x06 // @093A stack[1] = 0x00 // @093C stack[2] = stack[-5] // @093D stack[3] = stack[-4] // @093E stack[4] = stack[-1] // } // Block ends with conditional jump to 0x0947, if stack[-1] < stack[-4] label_0946: // Incoming jump from 0x0945, if not stack[-1] < stack[-4] 0946 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0946 assert(); } // Block terminates label_0947: // Incoming jump from 0x0945, if stack[-1] < stack[-4] // Inputs[10] // { // @0948 stack[-2] // @0948 stack[-1] // @094D stack[-3] // @094E msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @094F stack[-4] // @0954 stack[-5] // @095C memory[0x00:0x00 + 0x20 + 0x20 + stack[-4]] // @095F stack[-12] // @0960 stack[-11] // @0961 stack[-6] // } 0947 5B JUMPDEST 0948 90 SWAP1 0949 50 POP 094A 60 PUSH1 0x20 094C 02 MUL 094D 01 ADD 094E 35 CALLDATALOAD 094F 81 DUP2 0950 52 MSTORE 0951 60 PUSH1 0x20 0953 01 ADD 0954 90 SWAP1 0955 81 DUP2 0956 52 MSTORE 0957 60 PUSH1 0x20 0959 01 ADD 095A 60 PUSH1 0x00 095C 20 SHA3 095D 60 PUSH1 0x00 095F 88 DUP9 0960 88 DUP9 0961 84 DUP5 0962 81 DUP2 0963 81 DUP2 0964 10 LT 0965 61 PUSH2 0x096a 0968 57 *JUMPI // Stack delta = +0 // Outputs[7] // { // @0950 memory[stack[-4]:stack[-4] + 0x20] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0956 memory[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] = stack[-5] // @095C stack[-5] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-4]]) // @095D stack[-4] = 0x00 // @095F stack[-3] = stack[-12] // @0960 stack[-2] = stack[-11] // @0961 stack[-1] = stack[-6] // } // Block ends with conditional jump to 0x096a, if stack[-6] < stack[-11] label_0969: // Incoming jump from 0x0968, if not stack[-6] < stack[-11] 0969 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0969 assert(); } // Block terminates label_096A: // Incoming jump from 0x0968, if stack[-6] < stack[-11] // Inputs[3] // { // @096B stack[-2] // @096B stack[-1] // @0970 stack[-3] // } 096A 5B JUMPDEST 096B 90 SWAP1 096C 50 POP 096D 60 PUSH1 0x20 096F 02 MUL 0970 01 ADD 0971 60 PUSH1 0x20 0973 61 PUSH2 0x097f 0976 91 SWAP2 0977 90 SWAP1 0978 81 DUP2 0979 01 ADD 097A 90 SWAP1 097B 61 PUSH2 0x1ddb 097E 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0976 stack[-3] = 0x097f // @097A stack[-1] = 0x20 * stack[-1] + stack[-3] // @097A stack[-2] = 0x20 * stack[-1] + stack[-3] + 0x20 // } // Block ends with unconditional jump to 0x1ddb 097F 5B JUMPDEST 0980 60 PUSH1 0x01 0982 60 PUSH1 0x01 0984 60 PUSH1 0xa0 0986 1B SHL 0987 03 SUB 0988 16 AND 0989 60 PUSH1 0x01 098B 60 PUSH1 0x01 098D 60 PUSH1 0xa0 098F 1B SHL 0990 03 SUB 0991 16 AND 0992 81 DUP2 0993 52 MSTORE 0994 60 PUSH1 0x20 0996 01 ADD 0997 90 SWAP1 0998 81 DUP2 0999 52 MSTORE 099A 60 PUSH1 0x20 099C 01 ADD 099D 60 PUSH1 0x00 099F 20 SHA3 09A0 54 SLOAD 09A1 82 DUP3 09A2 82 DUP3 09A3 81 DUP2 09A4 51 MLOAD 09A5 81 DUP2 09A6 10 LT 09A7 61 PUSH2 0x09ac 09AA 57 *JUMPI 09AB FE *ASSERT 09AC 5B JUMPDEST 09AD 60 PUSH1 0x20 09AF 90 SWAP1 09B0 81 DUP2 09B1 02 MUL 09B2 91 SWAP2 09B3 90 SWAP1 09B4 91 SWAP2 09B5 01 ADD 09B6 01 ADD 09B7 52 MSTORE 09B8 60 PUSH1 0x01 09BA 01 ADD 09BB 61 PUSH2 0x092f 09BE 56 *JUMP label_09BF: // Incoming jump from 0x0937, if !(0x00 < stack[-7]) // Incoming jump from 0x0937, if !(0x00 < stack[-7]) // Inputs[3] // { // @09C1 stack[-8] // @09C1 stack[-2] // @09C2 stack[-7] // } 09BF 5B JUMPDEST 09C0 50 POP 09C1 95 SWAP6 09C2 94 SWAP5 09C3 50 POP 09C4 50 POP 09C5 50 POP 09C6 50 POP 09C7 50 POP 09C8 56 *JUMP // Stack delta = -7 // Outputs[1] { @09C1 stack[-8] = stack[-2] } // Block ends with unconditional jump to stack[-8] 09C9 5B JUMPDEST 09CA 60 PUSH1 0x09 09CC 60 PUSH1 0x20 09CE 52 MSTORE 09CF 81 DUP2 09D0 60 PUSH1 0x00 09D2 52 MSTORE 09D3 60 PUSH1 0x40 09D5 60 PUSH1 0x00 09D7 20 SHA3 09D8 81 DUP2 09D9 81 DUP2 09DA 54 SLOAD 09DB 81 DUP2 09DC 10 LT 09DD 61 PUSH2 0x09e2 09E0 57 *JUMPI 09E1 FE *ASSERT 09E2 5B JUMPDEST 09E3 60 PUSH1 0x00 09E5 91 SWAP2 09E6 82 DUP3 09E7 52 MSTORE 09E8 60 PUSH1 0x20 09EA 90 SWAP1 09EB 91 SWAP2 09EC 20 SHA3 09ED 60 PUSH1 0x02 09EF 90 SWAP1 09F0 91 SWAP2 09F1 02 MUL 09F2 01 ADD 09F3 80 DUP1 09F4 54 SLOAD 09F5 60 PUSH1 0x01 09F7 90 SWAP1 09F8 91 SWAP2 09F9 01 ADD 09FA 54 SLOAD 09FB 60 PUSH1 0x01 09FD 60 PUSH1 0x01 09FF 60 PUSH1 0xa0 0A01 1B SHL 0A02 03 SUB 0A03 90 SWAP1 0A04 91 SWAP2 0A05 16 AND 0A06 92 SWAP3 0A07 50 POP 0A08 90 SWAP1 0A09 50 POP 0A0A 82 DUP3 0A0B 56 *JUMP label_0A0C: // Incoming call from 0x02BC, returns to 0x0239 0A0C 5B JUMPDEST 0A0D 61 PUSH2 0x0a14 0A10 61 PUSH2 0x0a9d 0A13 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A0D stack[0] = 0x0a14 } // Block ends with call to 0x0a9d, returns to 0x0A14 label_0A14: // Incoming return from call to 0x0A9D at 0x0A13 // Inputs[1] { @0A18 stack[-1] } 0A14 5B JUMPDEST 0A15 61 PUSH2 0x0a30 0A18 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a30, if stack[-1] label_0A19: // Incoming jump from 0x0A18, if not stack[-1] // Inputs[1] { @0A1B memory[0x40:0x60] } 0A19 60 PUSH1 0x40 0A1B 51 MLOAD 0A1C 62 PUSH3 0x461bcd 0A20 60 PUSH1 0xe5 0A22 1B SHL 0A23 81 DUP2 0A24 52 MSTORE 0A25 60 PUSH1 0x04 0A27 01 ADD 0A28 61 PUSH2 0x04e6 0A2B 90 SWAP1 0A2C 61 PUSH2 0x2b0d 0A2F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A24 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A2B stack[0] = 0x04e6 // @0A2B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2b0d label_0A30: // Incoming jump from 0x0A18, if stack[-1] // Inputs[5] // { // @0A33 storage[0x01] // @0A36 memory[0x40:0x60] // @0A68 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0A6C storage[0x01] // @0A79 stack[-1] // } 0A30 5B JUMPDEST 0A31 60 PUSH1 0x01 0A33 54 SLOAD 0A34 60 PUSH1 0x40 0A36 51 MLOAD 0A37 60 PUSH1 0x00 0A39 91 SWAP2 0A3A 60 PUSH1 0x01 0A3C 60 PUSH1 0x01 0A3E 60 PUSH1 0xa0 0A40 1B SHL 0A41 03 SUB 0A42 16 AND 0A43 90 SWAP1 0A44 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 0A65 90 SWAP1 0A66 83 DUP4 0A67 90 SWAP1 0A68 A3 LOG3 0A69 60 PUSH1 0x01 0A6B 80 DUP1 0A6C 54 SLOAD 0A6D 60 PUSH1 0x01 0A6F 60 PUSH1 0x01 0A71 60 PUSH1 0xa0 0A73 1B SHL 0A74 03 SUB 0A75 19 NOT 0A76 16 AND 0A77 90 SWAP1 0A78 55 SSTORE 0A79 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @0A68 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x01] & (0x01 << 0xa0) - 0x01, 0x00]); // @0A78 storage[0x01] = ~((0x01 << 0xa0) - 0x01) & storage[0x01] // } // Block ends with unconditional jump to stack[-1] 0A7A 5B JUMPDEST 0A7B 60 PUSH1 0x00 0A7D 61 PUSH2 0x040f 0A80 60 PUSH1 0x02 0A82 83 DUP4 0A83 63 PUSH4 0xffffffff 0A88 61 PUSH2 0x1439 0A8B 16 AND 0A8C 56 *JUMP label_0A8D: // Incoming call from 0x02D7, returns to 0x02D8 // Inputs[1] { @0A90 storage[0x01] } 0A8D 5B JUMPDEST 0A8E 60 PUSH1 0x01 0A90 54 SLOAD 0A91 60 PUSH1 0x01 0A93 60 PUSH1 0x01 0A95 60 PUSH1 0xa0 0A97 1B SHL 0A98 03 SUB 0A99 16 AND // Stack delta = +1 // Outputs[1] { @0A99 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x01] } // Block continues label_0A9A: // Incoming return from call to 0x1BDB at 0x1BED // Incoming call from 0x2D39, returns to 0x2D1D // Incoming call from 0x2389, returns to 0x2244 // Incoming jump from 0x0A99 // Inputs[2] // { // @0A9B stack[-1] // @0A9B stack[-2] // } 0A9A 5B JUMPDEST 0A9B 90 SWAP1 0A9C 56 *JUMP // Stack delta = -1 // Outputs[1] { @0A9B stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0A9D: // Incoming call from 0x02EC, returns to 0x0204 // Incoming call from 0x0B52, returns to 0x0B53 // Incoming call from 0x0A13, returns to 0x0A14 // Incoming call from 0x0ACA, returns to 0x0ACB // Inputs[1] { @0AA0 storage[0x01] } 0A9D 5B JUMPDEST 0A9E 60 PUSH1 0x01 0AA0 54 SLOAD 0AA1 60 PUSH1 0x00 0AA3 90 SWAP1 0AA4 60 PUSH1 0x01 0AA6 60 PUSH1 0x01 0AA8 60 PUSH1 0xa0 0AAA 1B SHL 0AAB 03 SUB 0AAC 16 AND 0AAD 61 PUSH2 0x0ab4 0AB0 61 PUSH2 0x1481 0AB3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AA3 stack[0] = 0x00 // @0AAC stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x01] // @0AAD stack[2] = 0x0ab4 // } // Block ends with call to 0x1481, returns to 0x0AB4 label_0AB4: // Incoming return from call to 0x1481 at 0x0AB3 // Inputs[4] // { // @0ABD stack[-1] // @0ABE stack[-2] // @0ABF stack[-3] // @0AC1 stack[-4] // } 0AB4 5B JUMPDEST 0AB5 60 PUSH1 0x01 0AB7 60 PUSH1 0x01 0AB9 60 PUSH1 0xa0 0ABB 1B SHL 0ABC 03 SUB 0ABD 16 AND 0ABE 14 EQ 0ABF 90 SWAP1 0AC0 50 POP 0AC1 90 SWAP1 0AC2 56 *JUMP // Stack delta = -3 // Outputs[1] { @0AC1 stack[-4] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-4] label_0AC3: // Incoming jump from 0x02FF 0AC3 5B JUMPDEST 0AC4 61 PUSH2 0x0acb 0AC7 61 PUSH2 0x0a9d 0ACA 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AC4 stack[0] = 0x0acb } // Block ends with call to 0x0a9d, returns to 0x0ACB label_0ACB: // Incoming return from call to 0x0A9D at 0x0ACA // Inputs[1] { @0ACF stack[-1] } 0ACB 5B JUMPDEST 0ACC 61 PUSH2 0x0ae7 0ACF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ae7, if stack[-1] label_0AD0: // Incoming jump from 0x0ACF, if not stack[-1] // Inputs[1] { @0AD2 memory[0x40:0x60] } 0AD0 60 PUSH1 0x40 0AD2 51 MLOAD 0AD3 62 PUSH3 0x461bcd 0AD7 60 PUSH1 0xe5 0AD9 1B SHL 0ADA 81 DUP2 0ADB 52 MSTORE 0ADC 60 PUSH1 0x04 0ADE 01 ADD 0ADF 61 PUSH2 0x04e6 0AE2 90 SWAP1 0AE3 61 PUSH2 0x2b0d 0AE6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0ADB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AE2 stack[0] = 0x04e6 // @0AE2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2b0d label_0AE7: // Incoming jump from 0x0ACF, if stack[-1] // Inputs[1] { @0AEB stack[-1] } 0AE7 5B JUMPDEST 0AE8 61 PUSH2 0x04f8 0AEB 81 DUP2 0AEC 61 PUSH2 0x1485 0AEF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0AE8 stack[0] = 0x04f8 // @0AEB stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x1485 label_0AF0: // Incoming call from 0x0307, returns to 0x0219 // Inputs[2] // { // @0AF4 storage[0x0b] // @0AF8 memory[0x40:0x60] // } 0AF0 5B JUMPDEST 0AF1 60 PUSH1 0x0b 0AF3 80 DUP1 0AF4 54 SLOAD 0AF5 60 PUSH1 0x40 0AF7 80 DUP1 0AF8 51 MLOAD 0AF9 60 PUSH1 0x20 0AFB 60 PUSH1 0x02 0AFD 60 PUSH1 0x01 0AFF 85 DUP6 0B00 16 AND 0B01 15 ISZERO 0B02 61 PUSH2 0x0100 0B05 02 MUL 0B06 60 PUSH1 0x00 0B08 19 NOT 0B09 01 ADD 0B0A 90 SWAP1 0B0B 94 SWAP5 0B0C 16 AND 0B0D 93 SWAP4 0B0E 90 SWAP1 0B0F 93 SWAP4 0B10 04 DIV 0B11 60 PUSH1 0x1f 0B13 81 DUP2 0B14 01 ADD 0B15 84 DUP5 0B16 90 SWAP1 0B17 04 DIV 0B18 84 DUP5 0B19 02 MUL 0B1A 82 DUP3 0B1B 01 ADD 0B1C 84 DUP5 0B1D 01 ADD 0B1E 90 SWAP1 0B1F 92 SWAP3 0B20 52 MSTORE 0B21 81 DUP2 0B22 81 DUP2 0B23 52 MSTORE 0B24 92 SWAP3 0B25 91 SWAP2 0B26 83 DUP4 0B27 01 ADD 0B28 82 DUP3 0B29 82 DUP3 0B2A 80 DUP1 0B2B 15 ISZERO 0B2C 61 PUSH2 0x04ba 0B2F 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @0B1F stack[2] = (storage[0x0b] & ~0x00 + 0x0100 * !(storage[0x0b] & 0x01)) / 0x02 // @0B20 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x0b] & ~0x00 + 0x0100 * !(storage[0x0b] & 0x01)) / 0x02 + 0x1f) / 0x20) // @0B23 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x0b] & ~0x00 + 0x0100 * !(storage[0x0b] & 0x01)) / 0x02 // @0B24 stack[0] = memory[0x40:0x60] // @0B25 stack[1] = 0x0b // @0B27 stack[3] = memory[0x40:0x60] + 0x20 // @0B28 stack[4] = 0x0b // @0B29 stack[5] = (storage[0x0b] & ~0x00 + 0x0100 * !(storage[0x0b] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x04ba, if !((storage[0x0b] & ~0x00 + 0x0100 * !(storage[0x0b] & 0x01)) / 0x02) label_0B30: // Incoming jump from 0x0B2F, if not !((storage[0x0b] & ~0x00 + 0x0100 * !(storage[0x0b] & 0x01)) / 0x02) // Inputs[1] { @0B30 stack[-1] } 0B30 80 DUP1 0B31 60 PUSH1 0x1f 0B33 10 LT 0B34 61 PUSH2 0x048f 0B37 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048f, if 0x1f < stack[-1] label_0B38: // Incoming jump from 0x0B37, if not 0x1f < stack[-1] // Inputs[4] // { // @0B3C stack[-2] // @0B3D storage[stack[-2]] // @0B40 stack[-3] // @0B42 stack[-1] // } 0B38 61 PUSH2 0x0100 0B3B 80 DUP1 0B3C 83 DUP4 0B3D 54 SLOAD 0B3E 04 DIV 0B3F 02 MUL 0B40 83 DUP4 0B41 52 MSTORE 0B42 91 SWAP2 0B43 60 PUSH1 0x20 0B45 01 ADD 0B46 91 SWAP2 0B47 61 PUSH2 0x04ba 0B4A 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0B41 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0B46 stack[-1] = stack[-1] // @0B46 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x04ba label_0B4B: // Incoming jump from 0x031A 0B4B 5B JUMPDEST 0B4C 61 PUSH2 0x0b53 0B4F 61 PUSH2 0x0a9d 0B52 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B4C stack[0] = 0x0b53 } // Block ends with call to 0x0a9d, returns to 0x0B53 label_0B53: // Incoming return from call to 0x0A9D at 0x0B52 // Inputs[1] { @0B57 stack[-1] } 0B53 5B JUMPDEST 0B54 61 PUSH2 0x0b6f 0B57 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b6f, if stack[-1] label_0B58: // Incoming jump from 0x0B57, if not stack[-1] // Inputs[1] { @0B5A memory[0x40:0x60] } 0B58 60 PUSH1 0x40 0B5A 51 MLOAD 0B5B 62 PUSH3 0x461bcd 0B5F 60 PUSH1 0xe5 0B61 1B SHL 0B62 81 DUP2 0B63 52 MSTORE 0B64 60 PUSH1 0x04 0B66 01 ADD 0B67 61 PUSH2 0x04e6 0B6A 90 SWAP1 0B6B 61 PUSH2 0x2b0d 0B6E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B63 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B6A stack[0] = 0x04e6 // @0B6A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2b0d label_0B6F: // Incoming jump from 0x0B57, if stack[-1] // Inputs[1] { @0B73 stack[-1] } 0B6F 5B JUMPDEST 0B70 61 PUSH2 0x04f8 0B73 81 DUP2 0B74 61 PUSH2 0x149c 0B77 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B70 stack[0] = 0x04f8 // @0B73 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x149c 0B78 5B JUMPDEST 0B79 33 CALLER 0B7A 60 PUSH1 0x00 0B7C 81 DUP2 0B7D 81 DUP2 0B7E 52 MSTORE 0B7F 60 PUSH1 0x07 0B81 60 PUSH1 0x20 0B83 90 SWAP1 0B84 81 DUP2 0B85 52 MSTORE 0B86 60 PUSH1 0x40 0B88 80 DUP1 0B89 83 DUP4 0B8A 20 SHA3 0B8B 60 PUSH1 0x01 0B8D 60 PUSH1 0x01 0B8F 60 PUSH1 0xa0 0B91 1B SHL 0B92 03 SUB 0B93 87 DUP8 0B94 16 AND 0B95 80 DUP1 0B96 85 DUP6 0B97 52 MSTORE 0B98 92 SWAP3 0B99 52 MSTORE 0B9A 91 SWAP2 0B9B 82 DUP3 0B9C 90 SWAP1 0B9D 20 SHA3 0B9E 80 DUP1 0B9F 54 SLOAD 0BA0 60 PUSH1 0xff 0BA2 19 NOT 0BA3 16 AND 0BA4 85 DUP6 0BA5 15 ISZERO 0BA6 15 ISZERO 0BA7 17 OR 0BA8 90 SWAP1 0BA9 55 SSTORE 0BAA 90 SWAP1 0BAB 51 MLOAD 0BAC 90 SWAP1 0BAD 91 SWAP2 0BAE 90 SWAP1 0BAF 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0BD0 90 SWAP1 0BD1 61 PUSH2 0x0bdb 0BD4 90 SWAP1 0BD5 85 DUP6 0BD6 90 SWAP1 0BD7 61 PUSH2 0x2a20 0BDA 56 *JUMP 0BDB 5B JUMPDEST 0BDC 60 PUSH1 0x40 0BDE 51 MLOAD 0BDF 80 DUP1 0BE0 91 SWAP2 0BE1 03 SUB 0BE2 90 SWAP1 0BE3 A3 LOG3 0BE4 50 POP 0BE5 50 POP 0BE6 56 *JUMP 0BE7 5B JUMPDEST 0BE8 60 PUSH1 0x00 0BEA 81 DUP2 0BEB 81 DUP2 0BEC 52 MSTORE 0BED 60 PUSH1 0x09 0BEF 60 PUSH1 0x20 0BF1 90 SWAP1 0BF2 81 DUP2 0BF3 52 MSTORE 0BF4 60 PUSH1 0x40 0BF6 80 DUP1 0BF7 83 DUP4 0BF8 20 SHA3 0BF9 80 DUP1 0BFA 54 SLOAD 0BFB 82 DUP3 0BFC 51 MLOAD 0BFD 81 DUP2 0BFE 85 DUP6 0BFF 02 MUL 0C00 81 DUP2 0C01 01 ADD 0C02 85 DUP6 0C03 01 ADD 0C04 90 SWAP1 0C05 93 SWAP4 0C06 52 MSTORE 0C07 80 DUP1 0C08 83 DUP4 0C09 52 MSTORE 0C0A 60 PUSH1 0x60 0C0C 94 SWAP5 0C0D 85 DUP6 0C0E 94 SWAP5 0C0F 84 DUP5 0C10 01 ADD 0C11 5B JUMPDEST 0C12 82 DUP3 0C13 82 DUP3 0C14 10 LT 0C15 15 ISZERO 0C16 61 PUSH2 0x0c59 0C19 57 *JUMPI 0C1A 60 PUSH1 0x00 0C1C 84 DUP5 0C1D 81 DUP2 0C1E 52 MSTORE 0C1F 60 PUSH1 0x20 0C21 90 SWAP1 0C22 81 DUP2 0C23 90 SWAP1 0C24 20 SHA3 0C25 60 PUSH1 0x40 0C27 80 DUP1 0C28 51 MLOAD 0C29 80 DUP1 0C2A 82 DUP3 0C2B 01 ADD 0C2C 90 SWAP1 0C2D 91 SWAP2 0C2E 52 MSTORE 0C2F 60 PUSH1 0x02 0C31 85 DUP6 0C32 02 MUL 0C33 90 SWAP1 0C34 91 SWAP2 0C35 01 ADD 0C36 80 DUP1 0C37 54 SLOAD 0C38 60 PUSH1 0x01 0C3A 60 PUSH1 0x01 0C3C 60 PUSH1 0xa0 0C3E 1B SHL 0C3F 03 SUB 0C40 16 AND 0C41 82 DUP3 0C42 52 MSTORE 0C43 60 PUSH1 0x01 0C45 90 SWAP1 0C46 81 DUP2 0C47 01 ADD 0C48 54 SLOAD 0C49 82 DUP3 0C4A 84 DUP5 0C4B 01 ADD 0C4C 52 MSTORE 0C4D 90 SWAP1 0C4E 83 DUP4 0C4F 52 MSTORE 0C50 90 SWAP1 0C51 92 SWAP3 0C52 01 ADD 0C53 91 SWAP2 0C54 01 ADD 0C55 61 PUSH2 0x0c11 0C58 56 *JUMP 0C59 5B JUMPDEST 0C5A 50 POP 0C5B 50 POP 0C5C 50 POP 0C5D 50 POP 0C5E 90 SWAP1 0C5F 50 POP 0C60 60 PUSH1 0x60 0C62 81 DUP2 0C63 51 MLOAD 0C64 60 PUSH1 0x40 0C66 51 MLOAD 0C67 90 SWAP1 0C68 80 DUP1 0C69 82 DUP3 0C6A 52 MSTORE 0C6B 80 DUP1 0C6C 60 PUSH1 0x20 0C6E 02 MUL 0C6F 60 PUSH1 0x20 0C71 01 ADD 0C72 82 DUP3 0C73 01 ADD 0C74 60 PUSH1 0x40 0C76 52 MSTORE 0C77 80 DUP1 0C78 15 ISZERO 0C79 61 PUSH2 0x0c8c 0C7C 57 *JUMPI 0C7D 81 DUP2 0C7E 60 PUSH1 0x20 0C80 01 ADD 0C81 60 PUSH1 0x20 0C83 82 DUP3 0C84 02 MUL 0C85 80 DUP1 0C86 38 CODESIZE 0C87 83 DUP4 0C88 39 CODECOPY 0C89 01 ADD 0C8A 90 SWAP1 0C8B 50 POP 0C8C 5B JUMPDEST 0C8D 50 POP 0C8E 90 SWAP1 0C8F 50 POP 0C90 60 PUSH1 0x00 0C92 5B JUMPDEST 0C93 82 DUP3 0C94 51 MLOAD 0C95 81 DUP2 0C96 10 LT 0C97 15 ISZERO 0C98 61 PUSH2 0x05f1 0C9B 57 *JUMPI 0C9C 82 DUP3 0C9D 81 DUP2 0C9E 81 DUP2 0C9F 51 MLOAD 0CA0 81 DUP2 0CA1 10 LT 0CA2 61 PUSH2 0x0ca7 0CA5 57 *JUMPI 0CA6 FE *ASSERT 0CA7 5B JUMPDEST 0CA8 60 PUSH1 0x20 0CAA 02 MUL 0CAB 60 PUSH1 0x20 0CAD 01 ADD 0CAE 01 ADD 0CAF 51 MLOAD 0CB0 60 PUSH1 0x00 0CB2 01 ADD 0CB3 51 MLOAD 0CB4 82 DUP3 0CB5 82 DUP3 0CB6 81 DUP2 0CB7 51 MLOAD 0CB8 81 DUP2 0CB9 10 LT 0CBA 61 PUSH2 0x0cbf 0CBD 57 *JUMPI 0CBE FE *ASSERT 0CBF 5B JUMPDEST 0CC0 60 PUSH1 0x01 0CC2 60 PUSH1 0x01 0CC4 60 PUSH1 0xa0 0CC6 1B SHL 0CC7 03 SUB 0CC8 90 SWAP1 0CC9 92 SWAP3 0CCA 16 AND 0CCB 60 PUSH1 0x20 0CCD 92 SWAP3 0CCE 83 DUP4 0CCF 02 MUL 0CD0 91 SWAP2 0CD1 90 SWAP1 0CD2 91 SWAP2 0CD3 01 ADD 0CD4 90 SWAP1 0CD5 91 SWAP2 0CD6 01 ADD 0CD7 52 MSTORE 0CD8 60 PUSH1 0x01 0CDA 01 ADD 0CDB 61 PUSH2 0x0c92 0CDE 56 *JUMP label_0CDF: // Incoming call from 0x0355, returns to 0x0219 // Inputs[2] // { // @0CE3 storage[0x03] // @0CE7 memory[0x40:0x60] // } 0CDF 5B JUMPDEST 0CE0 60 PUSH1 0x03 0CE2 80 DUP1 0CE3 54 SLOAD 0CE4 60 PUSH1 0x40 0CE6 80 DUP1 0CE7 51 MLOAD 0CE8 60 PUSH1 0x20 0CEA 60 PUSH1 0x02 0CEC 60 PUSH1 0x01 0CEE 85 DUP6 0CEF 16 AND 0CF0 15 ISZERO 0CF1 61 PUSH2 0x0100 0CF4 02 MUL 0CF5 60 PUSH1 0x00 0CF7 19 NOT 0CF8 01 ADD 0CF9 90 SWAP1 0CFA 94 SWAP5 0CFB 16 AND 0CFC 93 SWAP4 0CFD 90 SWAP1 0CFE 93 SWAP4 0CFF 04 DIV 0D00 60 PUSH1 0x1f 0D02 81 DUP2 0D03 01 ADD 0D04 84 DUP5 0D05 90 SWAP1 0D06 04 DIV 0D07 84 DUP5 0D08 02 MUL 0D09 82 DUP3 0D0A 01 ADD 0D0B 84 DUP5 0D0C 01 ADD 0D0D 90 SWAP1 0D0E 92 SWAP3 0D0F 52 MSTORE 0D10 81 DUP2 0D11 81 DUP2 0D12 52 MSTORE 0D13 92 SWAP3 0D14 91 SWAP2 0D15 83 DUP4 0D16 01 ADD 0D17 82 DUP3 0D18 82 DUP3 0D19 80 DUP1 0D1A 15 ISZERO 0D1B 61 PUSH2 0x04ba 0D1E 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @0D0E stack[2] = (storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02 // @0D0F memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02 + 0x1f) / 0x20) // @0D12 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02 // @0D13 stack[0] = memory[0x40:0x60] // @0D14 stack[1] = 0x03 // @0D16 stack[3] = memory[0x40:0x60] + 0x20 // @0D17 stack[4] = 0x03 // @0D18 stack[5] = (storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x04ba, if !((storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02) label_0D1F: // Incoming jump from 0x0D1E, if not !((storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02) // Inputs[1] { @0D1F stack[-1] } 0D1F 80 DUP1 0D20 60 PUSH1 0x1f 0D22 10 LT 0D23 61 PUSH2 0x048f 0D26 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048f, if 0x1f < stack[-1] label_0D27: // Incoming jump from 0x0D26, if not 0x1f < stack[-1] // Inputs[4] // { // @0D2B stack[-2] // @0D2C storage[stack[-2]] // @0D2F stack[-3] // @0D31 stack[-1] // } 0D27 61 PUSH2 0x0100 0D2A 80 DUP1 0D2B 83 DUP4 0D2C 54 SLOAD 0D2D 04 DIV 0D2E 02 MUL 0D2F 83 DUP4 0D30 52 MSTORE 0D31 91 SWAP2 0D32 60 PUSH1 0x20 0D34 01 ADD 0D35 91 SWAP2 0D36 61 PUSH2 0x04ba 0D39 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0D30 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0D35 stack[-1] = stack[-1] // @0D35 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x04ba 0D3A 5B JUMPDEST 0D3B 61 PUSH2 0x0db9 0D3E 60 PUSH1 0x01 0D40 30 ADDRESS 0D41 89 DUP10 0D42 60 PUSH1 0x40 0D44 51 MLOAD 0D45 60 PUSH1 0x20 0D47 01 ADD 0D48 61 PUSH2 0x0d52 0D4B 92 SWAP3 0D4C 91 SWAP2 0D4D 90 SWAP1 0D4E 61 PUSH2 0x28d0 0D51 56 *JUMP 0D52 5B JUMPDEST 0D53 60 PUSH1 0x40 0D55 51 MLOAD 0D56 60 PUSH1 0x20 0D58 81 DUP2 0D59 83 DUP4 0D5A 03 SUB 0D5B 03 SUB 0D5C 81 DUP2 0D5D 52 MSTORE 0D5E 90 SWAP1 0D5F 60 PUSH1 0x40 0D61 52 MSTORE 0D62 80 DUP1 0D63 51 MLOAD 0D64 90 SWAP1 0D65 60 PUSH1 0x20 0D67 01 ADD 0D68 20 SHA3 0D69 88 DUP9 0D6A 88 DUP9 0D6B 88 DUP9 0D6C 60 PUSH1 0x40 0D6E 51 MLOAD 0D6F 60 PUSH1 0x00 0D71 81 DUP2 0D72 52 MSTORE 0D73 60 PUSH1 0x20 0D75 01 ADD 0D76 60 PUSH1 0x40 0D78 52 MSTORE 0D79 60 PUSH1 0x40 0D7B 51 MLOAD 0D7C 61 PUSH2 0x0d88 0D7F 94 SWAP5 0D80 93 SWAP4 0D81 92 SWAP3 0D82 91 SWAP2 0D83 90 SWAP1 0D84 61 PUSH2 0x2a2e 0D87 56 *JUMP 0D88 5B JUMPDEST 0D89 60 PUSH1 0x20 0D8B 60 PUSH1 0x40 0D8D 51 MLOAD 0D8E 60 PUSH1 0x20 0D90 81 DUP2 0D91 03 SUB 0D92 90 SWAP1 0D93 80 DUP1 0D94 84 DUP5 0D95 03 SUB 0D96 90 SWAP1 0D97 85 DUP6 0D98 5A GAS 0D99 FA STATICCALL 0D9A 15 ISZERO 0D9B 80 DUP1 0D9C 15 ISZERO 0D9D 61 PUSH2 0x0daa 0DA0 57 *JUMPI 0DA1 3D RETURNDATASIZE 0DA2 60 PUSH1 0x00 0DA4 80 DUP1 0DA5 3E RETURNDATACOPY 0DA6 3D RETURNDATASIZE 0DA7 60 PUSH1 0x00 0DA9 FD *REVERT 0DAA 5B JUMPDEST 0DAB 50 POP 0DAC 50 POP 0DAD 50 POP 0DAE 60 PUSH1 0x20 0DB0 60 PUSH1 0x40 0DB2 51 MLOAD 0DB3 03 SUB 0DB4 51 MLOAD 0DB5 61 PUSH2 0x0a7a 0DB8 56 *JUMP 0DB9 5B JUMPDEST 0DBA 61 PUSH2 0x0dd5 0DBD 57 *JUMPI 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 0x04 0DCC 01 ADD 0DCD 61 PUSH2 0x04e6 0DD0 90 SWAP1 0DD1 61 PUSH2 0x2b8d 0DD4 56 *JUMP 0DD5 5B JUMPDEST 0DD6 61 PUSH2 0x0de1 0DD9 87 DUP8 0DDA 84 DUP5 0DDB 84 DUP5 0DDC 84 DUP5 0DDD 61 PUSH2 0x14af 0DE0 56 *JUMP 0DE1 5B JUMPDEST 0DE2 50 POP 0DE3 50 POP 0DE4 50 POP 0DE5 50 POP 0DE6 50 POP 0DE7 50 POP 0DE8 50 POP 0DE9 56 *JUMP 0DEA 5B JUMPDEST 0DEB 60 PUSH1 0x08 0DED 60 PUSH1 0x20 0DEF 52 MSTORE 0DF0 60 PUSH1 0x00 0DF2 90 SWAP1 0DF3 81 DUP2 0DF4 52 MSTORE 0DF5 60 PUSH1 0x40 0DF7 90 SWAP1 0DF8 20 SHA3 0DF9 54 SLOAD 0DFA 60 PUSH1 0x01 0DFC 60 PUSH1 0x01 0DFE 60 PUSH1 0xa0 0E00 1B SHL 0E01 03 SUB 0E02 16 AND 0E03 81 DUP2 0E04 56 *JUMP label_0E05: // Incoming call from 0x0383, returns to 0x0239 0E05 5B JUMPDEST 0E06 61 PUSH2 0x0e15 0E09 61 PUSH2 0x0e10 0E0C 61 PUSH2 0x1481 0E0F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0E06 stack[0] = 0x0e15 // @0E09 stack[1] = 0x0e10 // } // Block ends with call to 0x1481, returns to 0x0E10 label_0E10: // Incoming return from call to 0x1481 at 0x0E0F 0E10 5B JUMPDEST 0E11 61 PUSH2 0x11ac 0E14 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x11ac label_0E15: // Incoming return from call to 0x0E10 at 0x0E0F // Inputs[1] { @0E16 stack[-1] } 0E15 5B JUMPDEST 0E16 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0E17: // Incoming call from 0x038B, returns to 0x0219 // Inputs[2] // { // @0E1B storage[0x05] // @0E1F memory[0x40:0x60] // } 0E17 5B JUMPDEST 0E18 60 PUSH1 0x05 0E1A 80 DUP1 0E1B 54 SLOAD 0E1C 60 PUSH1 0x40 0E1E 80 DUP1 0E1F 51 MLOAD 0E20 60 PUSH1 0x20 0E22 60 PUSH1 0x02 0E24 60 PUSH1 0x01 0E26 85 DUP6 0E27 16 AND 0E28 15 ISZERO 0E29 61 PUSH2 0x0100 0E2C 02 MUL 0E2D 60 PUSH1 0x00 0E2F 19 NOT 0E30 01 ADD 0E31 90 SWAP1 0E32 94 SWAP5 0E33 16 AND 0E34 93 SWAP4 0E35 90 SWAP1 0E36 93 SWAP4 0E37 04 DIV 0E38 60 PUSH1 0x1f 0E3A 81 DUP2 0E3B 01 ADD 0E3C 84 DUP5 0E3D 90 SWAP1 0E3E 04 DIV 0E3F 84 DUP5 0E40 02 MUL 0E41 82 DUP3 0E42 01 ADD 0E43 84 DUP5 0E44 01 ADD 0E45 90 SWAP1 0E46 92 SWAP3 0E47 52 MSTORE 0E48 81 DUP2 0E49 81 DUP2 0E4A 52 MSTORE 0E4B 92 SWAP3 0E4C 91 SWAP2 0E4D 83 DUP4 0E4E 01 ADD 0E4F 82 DUP3 0E50 82 DUP3 0E51 80 DUP1 0E52 15 ISZERO 0E53 61 PUSH2 0x04ba 0E56 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @0E46 stack[2] = (storage[0x05] & ~0x00 + 0x0100 * !(storage[0x05] & 0x01)) / 0x02 // @0E47 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x05] & ~0x00 + 0x0100 * !(storage[0x05] & 0x01)) / 0x02 + 0x1f) / 0x20) // @0E4A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x05] & ~0x00 + 0x0100 * !(storage[0x05] & 0x01)) / 0x02 // @0E4B stack[0] = memory[0x40:0x60] // @0E4C stack[1] = 0x05 // @0E4E stack[3] = memory[0x40:0x60] + 0x20 // @0E4F stack[4] = 0x05 // @0E50 stack[5] = (storage[0x05] & ~0x00 + 0x0100 * !(storage[0x05] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x04ba, if !((storage[0x05] & ~0x00 + 0x0100 * !(storage[0x05] & 0x01)) / 0x02) label_0E57: // Incoming jump from 0x0E56, if not !((storage[0x05] & ~0x00 + 0x0100 * !(storage[0x05] & 0x01)) / 0x02) // Inputs[1] { @0E57 stack[-1] } 0E57 80 DUP1 0E58 60 PUSH1 0x1f 0E5A 10 LT 0E5B 61 PUSH2 0x048f 0E5E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048f, if 0x1f < stack[-1] label_0E5F: // Incoming jump from 0x0E5E, if not 0x1f < stack[-1] // Inputs[4] // { // @0E63 stack[-2] // @0E64 storage[stack[-2]] // @0E67 stack[-3] // @0E69 stack[-1] // } 0E5F 61 PUSH2 0x0100 0E62 80 DUP1 0E63 83 DUP4 0E64 54 SLOAD 0E65 04 DIV 0E66 02 MUL 0E67 83 DUP4 0E68 52 MSTORE 0E69 91 SWAP2 0E6A 60 PUSH1 0x20 0E6C 01 ADD 0E6D 91 SWAP2 0E6E 61 PUSH2 0x04ba 0E71 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0E68 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0E6D stack[-1] = stack[-1] // @0E6D stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x04ba 0E72 5B JUMPDEST 0E73 60 PUSH1 0x01 0E75 60 PUSH1 0x01 0E77 60 PUSH1 0xa0 0E79 1B SHL 0E7A 03 SUB 0E7B 91 SWAP2 0E7C 82 DUP3 0E7D 16 AND 0E7E 60 PUSH1 0x00 0E80 90 SWAP1 0E81 81 DUP2 0E82 52 MSTORE 0E83 60 PUSH1 0x07 0E85 60 PUSH1 0x20 0E87 90 SWAP1 0E88 81 DUP2 0E89 52 MSTORE 0E8A 60 PUSH1 0x40 0E8C 80 DUP1 0E8D 83 DUP4 0E8E 20 SHA3 0E8F 93 SWAP4 0E90 90 SWAP1 0E91 94 SWAP5 0E92 16 AND 0E93 82 DUP3 0E94 52 MSTORE 0E95 91 SWAP2 0E96 90 SWAP1 0E97 91 SWAP2 0E98 52 MSTORE 0E99 20 SHA3 0E9A 54 SLOAD 0E9B 60 PUSH1 0xff 0E9D 16 AND 0E9E 90 SWAP1 0E9F 56 *JUMP 0EA0 5B JUMPDEST 0EA1 61 PUSH2 0x0ea8 0EA4 61 PUSH2 0x0a9d 0EA7 56 *JUMP 0EA8 5B JUMPDEST 0EA9 61 PUSH2 0x0ec4 0EAC 57 *JUMPI 0EAD 60 PUSH1 0x40 0EAF 51 MLOAD 0EB0 62 PUSH3 0x461bcd 0EB4 60 PUSH1 0xe5 0EB6 1B SHL 0EB7 81 DUP2 0EB8 52 MSTORE 0EB9 60 PUSH1 0x04 0EBB 01 ADD 0EBC 61 PUSH2 0x04e6 0EBF 90 SWAP1 0EC0 61 PUSH2 0x2b0d 0EC3 56 *JUMP 0EC4 5B JUMPDEST 0EC5 61 PUSH2 0x04f8 0EC8 81 DUP2 0EC9 61 PUSH2 0x17fd 0ECC 56 *JUMP 0ECD 5B JUMPDEST 0ECE 60 PUSH1 0x01 0ED0 60 PUSH1 0x01 0ED2 60 PUSH1 0xa0 0ED4 1B SHL 0ED5 03 SUB 0ED6 85 DUP6 0ED7 16 AND 0ED8 61 PUSH2 0x0ef3 0EDB 57 *JUMPI 0EDC 60 PUSH1 0x40 0EDE 51 MLOAD 0EDF 62 PUSH3 0x461bcd 0EE3 60 PUSH1 0xe5 0EE5 1B SHL 0EE6 81 DUP2 0EE7 52 MSTORE 0EE8 60 PUSH1 0x04 0EEA 01 ADD 0EEB 61 PUSH2 0x04e6 0EEE 90 SWAP1 0EEF 61 PUSH2 0x2b7d 0EF2 56 *JUMP 0EF3 5B JUMPDEST 0EF4 60 PUSH1 0x01 0EF6 60 PUSH1 0x01 0EF8 60 PUSH1 0xa0 0EFA 1B SHL 0EFB 03 SUB 0EFC 86 DUP7 0EFD 16 AND 0EFE 33 CALLER 0EFF 14 EQ 0F00 80 DUP1 0F01 61 PUSH2 0x0f32 0F04 57 *JUMPI 0F05 50 POP 0F06 60 PUSH1 0x01 0F08 60 PUSH1 0x01 0F0A 60 PUSH1 0xa0 0F0C 1B SHL 0F0D 03 SUB 0F0E 86 DUP7 0F0F 16 AND 0F10 60 PUSH1 0x00 0F12 90 SWAP1 0F13 81 DUP2 0F14 52 MSTORE 0F15 60 PUSH1 0x07 0F17 60 PUSH1 0x20 0F19 90 SWAP1 0F1A 81 DUP2 0F1B 52 MSTORE 0F1C 60 PUSH1 0x40 0F1E 80 DUP1 0F1F 83 DUP4 0F20 20 SHA3 0F21 33 CALLER 0F22 84 DUP5 0F23 52 MSTORE 0F24 90 SWAP1 0F25 91 SWAP2 0F26 52 MSTORE 0F27 90 SWAP1 0F28 20 SHA3 0F29 54 SLOAD 0F2A 60 PUSH1 0xff 0F2C 16 AND 0F2D 15 ISZERO 0F2E 15 ISZERO 0F2F 60 PUSH1 0x01 0F31 14 EQ 0F32 5B JUMPDEST 0F33 61 PUSH2 0x0f4e 0F36 57 *JUMPI 0F37 60 PUSH1 0x40 0F39 51 MLOAD 0F3A 62 PUSH3 0x461bcd 0F3E 60 PUSH1 0xe5 0F40 1B SHL 0F41 81 DUP2 0F42 52 MSTORE 0F43 60 PUSH1 0x04 0F45 01 ADD 0F46 61 PUSH2 0x04e6 0F49 90 SWAP1 0F4A 61 PUSH2 0x2aed 0F4D 56 *JUMP 0F4E 5B JUMPDEST 0F4F 60 PUSH1 0x00 0F51 84 DUP5 0F52 81 DUP2 0F53 52 MSTORE 0F54 60 PUSH1 0x06 0F56 60 PUSH1 0x20 0F58 90 SWAP1 0F59 81 DUP2 0F5A 52 MSTORE 0F5B 60 PUSH1 0x40 0F5D 80 DUP1 0F5E 83 DUP4 0F5F 20 SHA3 0F60 60 PUSH1 0x01 0F62 60 PUSH1 0x01 0F64 60 PUSH1 0xa0 0F66 1B SHL 0F67 03 SUB 0F68 8A DUP11 0F69 16 AND 0F6A 84 DUP5 0F6B 52 MSTORE 0F6C 90 SWAP1 0F6D 91 SWAP2 0F6E 52 MSTORE 0F6F 90 SWAP1 0F70 20 SHA3 0F71 54 SLOAD 0F72 61 PUSH2 0x0f81 0F75 90 SWAP1 0F76 84 DUP5 0F77 63 PUSH4 0xffffffff 0F7C 61 PUSH2 0x132f 0F7F 16 AND 0F80 56 *JUMP 0F81 5B JUMPDEST 0F82 60 PUSH1 0x00 0F84 85 DUP6 0F85 81 DUP2 0F86 52 MSTORE 0F87 60 PUSH1 0x06 0F89 60 PUSH1 0x20 0F8B 90 SWAP1 0F8C 81 DUP2 0F8D 52 MSTORE 0F8E 60 PUSH1 0x40 0F90 80 DUP1 0F91 83 DUP4 0F92 20 SHA3 0F93 60 PUSH1 0x01 0F95 60 PUSH1 0x01 0F97 60 PUSH1 0xa0 0F99 1B SHL 0F9A 03 SUB 0F9B 8B DUP12 0F9C 81 DUP2 0F9D 16 AND 0F9E 85 DUP6 0F9F 52 MSTORE 0FA0 92 SWAP3 0FA1 52 MSTORE 0FA2 80 DUP1 0FA3 83 DUP4 0FA4 20 SHA3 0FA5 93 SWAP4 0FA6 90 SWAP1 0FA7 93 SWAP4 0FA8 55 SSTORE 0FA9 87 DUP8 0FAA 16 AND 0FAB 81 DUP2 0FAC 52 MSTORE 0FAD 20 SHA3 0FAE 54 SLOAD 0FAF 61 PUSH2 0x0fb9 0FB2 90 SWAP1 0FB3 84 DUP5 0FB4 90 SWAP1 0FB5 61 PUSH2 0x1341 0FB8 56 *JUMP 0FB9 5B JUMPDEST 0FBA 60 PUSH1 0x00 0FBC 85 DUP6 0FBD 81 DUP2 0FBE 52 MSTORE 0FBF 60 PUSH1 0x06 0FC1 60 PUSH1 0x20 0FC3 90 SWAP1 0FC4 81 DUP2 0FC5 52 MSTORE 0FC6 60 PUSH1 0x40 0FC8 80 DUP1 0FC9 83 DUP4 0FCA 20 SHA3 0FCB 60 PUSH1 0x01 0FCD 60 PUSH1 0x01 0FCF 60 PUSH1 0xa0 0FD1 1B SHL 0FD2 03 SUB 0FD3 80 DUP1 0FD4 8B DUP12 0FD5 16 AND 0FD6 80 DUP1 0FD7 86 DUP7 0FD8 52 MSTORE 0FD9 91 SWAP2 0FDA 90 SWAP1 0FDB 93 SWAP4 0FDC 52 MSTORE 0FDD 92 SWAP3 0FDE 81 DUP2 0FDF 90 SWAP1 0FE0 20 SHA3 0FE1 93 SWAP4 0FE2 90 SWAP1 0FE3 93 SWAP4 0FE4 55 SSTORE 0FE5 91 SWAP2 0FE6 51 MLOAD 0FE7 90 SWAP1 0FE8 91 SWAP2 0FE9 88 DUP9 0FEA 16 AND 0FEB 90 SWAP1 0FEC 33 CALLER 0FED 90 SWAP1 0FEE 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 100F 90 SWAP1 1010 61 PUSH2 0x101c 1013 90 SWAP1 1014 89 DUP10 1015 90 SWAP1 1016 89 DUP10 1017 90 SWAP1 1018 61 PUSH2 0x2bef 101B 56 *JUMP 101C 5B JUMPDEST 101D 60 PUSH1 0x40 101F 51 MLOAD 1020 80 DUP1 1021 91 SWAP2 1022 03 SUB 1023 90 SWAP1 1024 A4 LOG4 1025 61 PUSH2 0x1036 1028 85 DUP6 1029 60 PUSH1 0x01 102B 60 PUSH1 0x01 102D 60 PUSH1 0xa0 102F 1B SHL 1030 03 SUB 1031 16 AND 1032 61 PUSH2 0x134e 1035 56 *JUMP 1036 5B JUMPDEST 1037 15 ISZERO 1038 61 PUSH2 0x107f 103B 57 *JUMPI 103C 61 PUSH2 0x107f 103F 33 CALLER 1040 87 DUP8 1041 87 DUP8 1042 87 DUP8 1043 87 DUP8 1044 87 DUP8 1045 87 DUP8 1046 80 DUP1 1047 80 DUP1 1048 60 PUSH1 0x1f 104A 01 ADD 104B 60 PUSH1 0x20 104D 80 DUP1 104E 91 SWAP2 104F 04 DIV 1050 02 MUL 1051 60 PUSH1 0x20 1053 01 ADD 1054 60 PUSH1 0x40 1056 51 MLOAD 1057 90 SWAP1 1058 81 DUP2 1059 01 ADD 105A 60 PUSH1 0x40 105C 52 MSTORE 105D 80 DUP1 105E 93 SWAP4 105F 92 SWAP3 1060 91 SWAP2 1061 90 SWAP1 1062 81 DUP2 1063 81 DUP2 1064 52 MSTORE 1065 60 PUSH1 0x20 1067 01 ADD 1068 83 DUP4 1069 83 DUP4 106A 80 DUP1 106B 82 DUP3 106C 84 DUP5 106D 37 CALLDATACOPY 106E 60 PUSH1 0x00 1070 92 SWAP3 1071 01 ADD 1072 91 SWAP2 1073 90 SWAP1 1074 91 SWAP2 1075 52 MSTORE 1076 50 POP 1077 61 PUSH2 0x1845 107A 92 SWAP3 107B 50 POP 107C 50 POP 107D 50 POP 107E 56 *JUMP 107F 5B JUMPDEST 1080 50 POP 1081 50 POP 1082 50 POP 1083 50 POP 1084 50 POP 1085 50 POP 1086 56 *JUMP 1087 5B JUMPDEST 1088 61 PUSH2 0x108f 108B 61 PUSH2 0x0a9d 108E 56 *JUMP 108F 5B JUMPDEST 1090 61 PUSH2 0x10ab 1093 57 *JUMPI 1094 60 PUSH1 0x40 1096 51 MLOAD 1097 62 PUSH3 0x461bcd 109B 60 PUSH1 0xe5 109D 1B SHL 109E 81 DUP2 109F 52 MSTORE 10A0 60 PUSH1 0x04 10A2 01 ADD 10A3 61 PUSH2 0x04e6 10A6 90 SWAP1 10A7 61 PUSH2 0x2b0d 10AA 56 *JUMP 10AB 5B JUMPDEST 10AC 61 PUSH2 0x04f8 10AF 81 DUP2 10B0 61 PUSH2 0x18f4 10B3 56 *JUMP 10B4 5B JUMPDEST 10B5 60 PUSH1 0x01 10B7 60 PUSH1 0x01 10B9 60 PUSH1 0xa0 10BB 1B SHL 10BC 03 SUB 10BD 83 DUP4 10BE 16 AND 10BF 33 CALLER 10C0 14 EQ 10C1 80 DUP1 10C2 61 PUSH2 0x10f3 10C5 57 *JUMPI 10C6 50 POP 10C7 60 PUSH1 0x01 10C9 60 PUSH1 0x01 10CB 60 PUSH1 0xa0 10CD 1B SHL 10CE 03 SUB 10CF 83 DUP4 10D0 16 AND 10D1 60 PUSH1 0x00 10D3 90 SWAP1 10D4 81 DUP2 10D5 52 MSTORE 10D6 60 PUSH1 0x07 10D8 60 PUSH1 0x20 10DA 90 SWAP1 10DB 81 DUP2 10DC 52 MSTORE 10DD 60 PUSH1 0x40 10DF 80 DUP1 10E0 83 DUP4 10E1 20 SHA3 10E2 33 CALLER 10E3 84 DUP5 10E4 52 MSTORE 10E5 90 SWAP1 10E6 91 SWAP2 10E7 52 MSTORE 10E8 90 SWAP1 10E9 20 SHA3 10EA 54 SLOAD 10EB 60 PUSH1 0xff 10ED 16 AND 10EE 15 ISZERO 10EF 15 ISZERO 10F0 60 PUSH1 0x01 10F2 14 EQ 10F3 5B JUMPDEST 10F4 61 PUSH2 0x110f 10F7 57 *JUMPI 10F8 60 PUSH1 0x40 10FA 51 MLOAD 10FB 62 PUSH3 0x461bcd 10FF 60 PUSH1 0xe5 1101 1B SHL 1102 81 DUP2 1103 52 MSTORE 1104 60 PUSH1 0x04 1106 01 ADD 1107 61 PUSH2 0x04e6 110A 90 SWAP1 110B 61 PUSH2 0x2add 110E 56 *JUMP 110F 5B JUMPDEST 1110 60 PUSH1 0x00 1112 82 DUP3 1113 81 DUP2 1114 52 MSTORE 1115 60 PUSH1 0x06 1117 60 PUSH1 0x20 1119 90 SWAP1 111A 81 DUP2 111B 52 MSTORE 111C 60 PUSH1 0x40 111E 80 DUP1 111F 83 DUP4 1120 20 SHA3 1121 60 PUSH1 0x01 1123 60 PUSH1 0x01 1125 60 PUSH1 0xa0 1127 1B SHL 1128 03 SUB 1129 87 DUP8 112A 16 AND 112B 84 DUP5 112C 52 MSTORE 112D 90 SWAP1 112E 91 SWAP2 112F 52 MSTORE 1130 90 SWAP1 1131 20 SHA3 1132 54 SLOAD 1133 61 PUSH2 0x1142 1136 90 SWAP1 1137 82 DUP3 1138 63 PUSH4 0xffffffff 113D 61 PUSH2 0x132f 1140 16 AND 1141 56 *JUMP 1142 5B JUMPDEST 1143 60 PUSH1 0x00 1145 83 DUP4 1146 81 DUP2 1147 52 MSTORE 1148 60 PUSH1 0x06 114A 60 PUSH1 0x20 114C 90 SWAP1 114D 81 DUP2 114E 52 MSTORE 114F 60 PUSH1 0x40 1151 80 DUP1 1152 83 DUP4 1153 20 SHA3 1154 60 PUSH1 0x01 1156 60 PUSH1 0x01 1158 60 PUSH1 0xa0 115A 1B SHL 115B 03 SUB 115C 88 DUP9 115D 16 AND 115E 80 DUP1 115F 85 DUP6 1160 52 MSTORE 1161 92 SWAP3 1162 52 MSTORE 1163 80 DUP1 1164 83 DUP4 1165 20 SHA3 1166 93 SWAP4 1167 90 SWAP1 1168 93 SWAP4 1169 55 SSTORE 116A 91 SWAP2 116B 51 MLOAD 116C 90 SWAP1 116D 91 SWAP2 116E 90 SWAP1 116F 33 CALLER 1170 90 SWAP1 1171 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 1192 90 SWAP1 1193 61 PUSH2 0x119f 1196 90 SWAP1 1197 87 DUP8 1198 90 SWAP1 1199 87 DUP8 119A 90 SWAP1 119B 61 PUSH2 0x2bef 119E 56 *JUMP 119F 5B JUMPDEST 11A0 60 PUSH1 0x40 11A2 51 MLOAD 11A3 80 DUP1 11A4 91 SWAP2 11A5 03 SUB 11A6 90 SWAP1 11A7 A4 LOG4 11A8 50 POP 11A9 50 POP 11AA 50 POP 11AB 56 *JUMP label_11AC: // Incoming jump from 0x0E14 // Inputs[1] { @11B2 stack[-1] } 11AC 5B JUMPDEST 11AD 61 PUSH2 0x11bd 11B0 60 PUSH1 0x02 11B2 82 DUP3 11B3 63 PUSH4 0xffffffff 11B8 61 PUSH2 0x1976 11BB 16 AND 11BC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @11AD stack[0] = 0x11bd // @11B0 stack[1] = 0x02 // @11B2 stack[2] = stack[-1] // } // Block ends with call to 0x1976 & 0xffffffff, returns to 0x11BD label_11BD: // Incoming return from call to 0x1976 at 0x11BC // Inputs[4] // { // @11C0 memory[0x40:0x60] // @11C9 stack[-1] // @11F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @11F3 stack[-2] // } 11BD 5B JUMPDEST 11BE 60 PUSH1 0x40 11C0 51 MLOAD 11C1 60 PUSH1 0x01 11C3 60 PUSH1 0x01 11C5 60 PUSH1 0xa0 11C7 1B SHL 11C8 03 SUB 11C9 82 DUP3 11CA 16 AND 11CB 90 SWAP1 11CC 7F PUSH32 0x3525e22824a8a7df2c9a6029941c824cf95b6447f1e13d5128fd3826d35afe8b 11ED 90 SWAP1 11EE 60 PUSH1 0x00 11F0 90 SWAP1 11F1 A2 LOG2 11F2 50 POP 11F3 56 *JUMP // Stack delta = -2 // Outputs[1] { @11F1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x3525e22824a8a7df2c9a6029941c824cf95b6447f1e13d5128fd3826d35afe8b, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-2] 11F4 5B JUMPDEST 11F5 60 PUSH1 0x00 11F7 81 DUP2 11F8 81 DUP2 11F9 52 MSTORE 11FA 60 PUSH1 0x04 11FC 60 PUSH1 0x20 11FE 90 SWAP1 11FF 81 DUP2 1200 52 MSTORE 1201 60 PUSH1 0x40 1203 91 SWAP2 1204 82 DUP3 1205 90 SWAP1 1206 20 SHA3 1207 80 DUP1 1208 54 SLOAD 1209 83 DUP4 120A 51 MLOAD 120B 60 PUSH1 0x02 120D 60 PUSH1 0x01 120F 83 DUP4 1210 16 AND 1211 15 ISZERO 1212 61 PUSH2 0x0100 1215 02 MUL 1216 60 PUSH1 0x00 1218 19 NOT 1219 01 ADD 121A 90 SWAP1 121B 92 SWAP3 121C 16 AND 121D 91 SWAP2 121E 90 SWAP1 121F 91 SWAP2 1220 04 DIV 1221 60 PUSH1 0x1f 1223 81 DUP2 1224 01 ADD 1225 84 DUP5 1226 90 SWAP1 1227 04 DIV 1228 84 DUP5 1229 02 MUL 122A 82 DUP3 122B 01 ADD 122C 84 DUP5 122D 01 ADD 122E 90 SWAP1 122F 94 SWAP5 1230 52 MSTORE 1231 83 DUP4 1232 81 DUP2 1233 52 MSTORE 1234 60 PUSH1 0x60 1236 93 SWAP4 1237 61 PUSH2 0x040f 123A 93 SWAP4 123B 91 SWAP2 123C 92 SWAP3 123D 91 SWAP2 123E 83 DUP4 123F 01 ADD 1240 82 DUP3 1241 82 DUP3 1242 80 DUP1 1243 15 ISZERO 1244 61 PUSH2 0x128e 1247 57 *JUMPI 1248 80 DUP1 1249 60 PUSH1 0x1f 124B 10 LT 124C 61 PUSH2 0x1263 124F 57 *JUMPI 1250 61 PUSH2 0x0100 1253 80 DUP1 1254 83 DUP4 1255 54 SLOAD 1256 04 DIV 1257 02 MUL 1258 83 DUP4 1259 52 MSTORE 125A 91 SWAP2 125B 60 PUSH1 0x20 125D 01 ADD 125E 91 SWAP2 125F 61 PUSH2 0x128e 1262 56 *JUMP 1263 5B JUMPDEST 1264 82 DUP3 1265 01 ADD 1266 91 SWAP2 1267 90 SWAP1 1268 60 PUSH1 0x00 126A 52 MSTORE 126B 60 PUSH1 0x20 126D 60 PUSH1 0x00 126F 20 SHA3 1270 90 SWAP1 1271 5B JUMPDEST 1272 81 DUP2 1273 54 SLOAD 1274 81 DUP2 1275 52 MSTORE 1276 90 SWAP1 1277 60 PUSH1 0x01 1279 01 ADD 127A 90 SWAP1 127B 60 PUSH1 0x20 127D 01 ADD 127E 80 DUP1 127F 83 DUP4 1280 11 GT 1281 61 PUSH2 0x1271 1284 57 *JUMPI 1285 82 DUP3 1286 90 SWAP1 1287 03 SUB 1288 60 PUSH1 0x1f 128A 16 AND 128B 82 DUP3 128C 01 ADD 128D 91 SWAP2 128E 5B JUMPDEST 128F 50 POP 1290 50 POP 1291 60 PUSH1 0x03 1293 80 DUP1 1294 54 SLOAD 1295 60 PUSH1 0x40 1297 80 DUP1 1298 51 MLOAD 1299 60 PUSH1 0x20 129B 60 PUSH1 0x1f 129D 60 PUSH1 0x02 129F 60 PUSH1 0x00 12A1 19 NOT 12A2 61 PUSH2 0x0100 12A5 60 PUSH1 0x01 12A7 88 DUP9 12A8 16 AND 12A9 15 ISZERO 12AA 02 MUL 12AB 01 ADD 12AC 90 SWAP1 12AD 95 SWAP6 12AE 16 AND 12AF 94 SWAP5 12B0 90 SWAP1 12B1 94 SWAP5 12B2 04 DIV 12B3 93 SWAP4 12B4 84 DUP5 12B5 01 ADD 12B6 81 DUP2 12B7 90 SWAP1 12B8 04 DIV 12B9 81 DUP2 12BA 02 MUL 12BB 82 DUP3 12BC 01 ADD 12BD 81 DUP2 12BE 01 ADD 12BF 90 SWAP1 12C0 92 SWAP3 12C1 52 MSTORE 12C2 82 DUP3 12C3 81 DUP2 12C4 52 MSTORE 12C5 95 SWAP6 12C6 50 POP 12C7 91 SWAP2 12C8 93 SWAP4 12C9 50 POP 12CA 91 SWAP2 12CB 50 POP 12CC 83 DUP4 12CD 01 ADD 12CE 82 DUP3 12CF 82 DUP3 12D0 80 DUP1 12D1 15 ISZERO 12D2 61 PUSH2 0x131c 12D5 57 *JUMPI 12D6 80 DUP1 12D7 60 PUSH1 0x1f 12D9 10 LT 12DA 61 PUSH2 0x12f1 12DD 57 *JUMPI 12DE 61 PUSH2 0x0100 12E1 80 DUP1 12E2 83 DUP4 12E3 54 SLOAD 12E4 04 DIV 12E5 02 MUL 12E6 83 DUP4 12E7 52 MSTORE 12E8 91 SWAP2 12E9 60 PUSH1 0x20 12EB 01 ADD 12EC 91 SWAP2 12ED 61 PUSH2 0x131c 12F0 56 *JUMP 12F1 5B JUMPDEST 12F2 82 DUP3 12F3 01 ADD 12F4 91 SWAP2 12F5 90 SWAP1 12F6 60 PUSH1 0x00 12F8 52 MSTORE 12F9 60 PUSH1 0x20 12FB 60 PUSH1 0x00 12FD 20 SHA3 12FE 90 SWAP1 12FF 5B JUMPDEST 1300 81 DUP2 1301 54 SLOAD 1302 81 DUP2 1303 52 MSTORE 1304 90 SWAP1 1305 60 PUSH1 0x01 1307 01 ADD 1308 90 SWAP1 1309 60 PUSH1 0x20 130B 01 ADD 130C 80 DUP1 130D 83 DUP4 130E 11 GT 130F 61 PUSH2 0x12ff 1312 57 *JUMPI 1313 82 DUP3 1314 90 SWAP1 1315 03 SUB 1316 60 PUSH1 0x1f 1318 16 AND 1319 82 DUP3 131A 01 ADD 131B 91 SWAP2 131C 5B JUMPDEST 131D 50 POP 131E 50 POP 131F 50 POP 1320 50 POP 1321 50 POP 1322 61 PUSH2 0x19be 1325 90 SWAP1 1326 91 SWAP2 1327 90 SWAP1 1328 63 PUSH4 0xffffffff 132D 16 AND 132E 56 *JUMP 132F 5B JUMPDEST 1330 60 PUSH1 0x00 1332 82 DUP3 1333 82 DUP3 1334 11 GT 1335 15 ISZERO 1336 61 PUSH2 0x133b 1339 57 *JUMPI 133A FE *ASSERT 133B 5B JUMPDEST 133C 50 POP 133D 90 SWAP1 133E 03 SUB 133F 90 SWAP1 1340 56 *JUMP 1341 5B JUMPDEST 1342 81 DUP2 1343 81 DUP2 1344 01 ADD 1345 82 DUP3 1346 81 DUP2 1347 10 LT 1348 15 ISZERO 1349 61 PUSH2 0x040f 134C 57 *JUMPI 134D FE *ASSERT 134E 5B JUMPDEST 134F 60 PUSH1 0x00 1351 81 DUP2 1352 3F EXTCODEHASH 1353 7F PUSH32 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 1374 81 DUP2 1375 81 DUP2 1376 14 EQ 1377 80 DUP1 1378 15 ISZERO 1379 90 SWAP1 137A 61 PUSH2 0x1382 137D 57 *JUMPI 137E 50 POP 137F 81 DUP2 1380 15 ISZERO 1381 15 ISZERO label_1382: // Incoming return from call to 0x1D3A at 0x2113 // Inputs[3] // { // @1383 stack[-6] // @1383 stack[-1] // @1384 stack[-5] // } 1382 5B JUMPDEST 1383 94 SWAP5 1384 93 SWAP4 1385 50 POP 1386 50 POP 1387 50 POP 1388 50 POP 1389 56 *JUMP // Stack delta = -5 // Outputs[1] { @1383 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] 138A 5B JUMPDEST 138B 60 PUSH1 0x40 138D 51 MLOAD 138E 63 PUSH4 0xbc197c81 1393 60 PUSH1 0xe0 1395 1B SHL 1396 80 DUP1 1397 82 DUP3 1398 52 MSTORE 1399 90 SWAP1 139A 60 PUSH1 0x01 139C 60 PUSH1 0x01 139E 60 PUSH1 0xa0 13A0 1B SHL 13A1 03 SUB 13A2 86 DUP7 13A3 16 AND 13A4 90 SWAP1 13A5 63 PUSH4 0xbc197c81 13AA 90 SWAP1 13AB 61 PUSH2 0x13c0 13AE 90 SWAP1 13AF 8A DUP11 13B0 90 SWAP1 13B1 8A DUP11 13B2 90 SWAP1 13B3 89 DUP10 13B4 90 SWAP1 13B5 89 DUP10 13B6 90 SWAP1 13B7 89 DUP10 13B8 90 SWAP1 13B9 60 PUSH1 0x04 13BB 01 ADD 13BC 61 PUSH2 0x2926 13BF 56 *JUMP 13C0 5B JUMPDEST 13C1 60 PUSH1 0x20 13C3 60 PUSH1 0x40 13C5 51 MLOAD 13C6 80 DUP1 13C7 83 DUP4 13C8 03 SUB 13C9 81 DUP2 13CA 60 PUSH1 0x00 13CC 87 DUP8 13CD 80 DUP1 13CE 3B EXTCODESIZE 13CF 15 ISZERO 13D0 80 DUP1 13D1 15 ISZERO 13D2 61 PUSH2 0x13da 13D5 57 *JUMPI 13D6 60 PUSH1 0x00 13D8 80 DUP1 13D9 FD *REVERT 13DA 5B JUMPDEST 13DB 50 POP 13DC 5A GAS 13DD F1 CALL 13DE 15 ISZERO 13DF 80 DUP1 13E0 15 ISZERO 13E1 61 PUSH2 0x13ee 13E4 57 *JUMPI 13E5 3D RETURNDATASIZE 13E6 60 PUSH1 0x00 13E8 80 DUP1 13E9 3E RETURNDATACOPY 13EA 3D RETURNDATASIZE 13EB 60 PUSH1 0x00 13ED FD *REVERT 13EE 5B JUMPDEST 13EF 50 POP 13F0 50 POP 13F1 50 POP 13F2 50 POP 13F3 60 PUSH1 0x40 13F5 51 MLOAD 13F6 3D RETURNDATASIZE 13F7 60 PUSH1 0x1f 13F9 19 NOT 13FA 60 PUSH1 0x1f 13FC 82 DUP3 13FD 01 ADD 13FE 16 AND 13FF 82 DUP3 1400 01 ADD 1401 80 DUP1 1402 60 PUSH1 0x40 1404 52 MSTORE 1405 50 POP 1406 61 PUSH2 0x1412 1409 91 SWAP2 140A 90 SWAP1 140B 81 DUP2 140C 01 ADD 140D 90 SWAP1 140E 61 PUSH2 0x20c2 1411 56 *JUMP 1412 5B JUMPDEST 1413 60 PUSH1 0x01 1415 60 PUSH1 0x01 1417 60 PUSH1 0xe0 1419 1B SHL 141A 03 SUB 141B 19 NOT 141C 16 AND 141D 14 EQ 141E 61 PUSH2 0x107f 1421 57 *JUMPI 1422 60 PUSH1 0x40 1424 51 MLOAD 1425 62 PUSH3 0x461bcd 1429 60 PUSH1 0xe5 142B 1B SHL 142C 81 DUP2 142D 52 MSTORE 142E 60 PUSH1 0x04 1430 01 ADD 1431 61 PUSH2 0x04e6 1434 90 SWAP1 1435 61 PUSH2 0x2afd 1438 56 *JUMP label_1439: // Incoming call from 0x197F, returns to 0x1980 // Inputs[1] { @1444 stack[-1] } 1439 5B JUMPDEST 143A 60 PUSH1 0x00 143C 60 PUSH1 0x01 143E 60 PUSH1 0x01 1440 60 PUSH1 0xa0 1442 1B SHL 1443 03 SUB 1444 82 DUP3 1445 16 AND 1446 61 PUSH2 0x1461 1449 57 *JUMPI // Stack delta = +1 // Outputs[1] { @143A stack[0] = 0x00 } // Block ends with conditional jump to 0x1461, if stack[-1] & (0x01 << 0xa0) - 0x01 label_144A: // Incoming jump from 0x1449, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @144C memory[0x40:0x60] } 144A 60 PUSH1 0x40 144C 51 MLOAD 144D 62 PUSH3 0x461bcd 1451 60 PUSH1 0xe5 1453 1B SHL 1454 81 DUP2 1455 52 MSTORE 1456 60 PUSH1 0x04 1458 01 ADD 1459 61 PUSH2 0x04e6 145C 90 SWAP1 145D 61 PUSH2 0x2b1d 1460 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1455 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @145C stack[0] = 0x04e6 // @145C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2b1d label_1461: // Incoming jump from 0x1449, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[5] // { // @146B stack[-2] // @1473 stack[-3] // @147A memory[0x00:0x40] // @147B storage[keccak256(memory[0x00:0x40])] // @147F stack[-4] // } 1461 5B JUMPDEST 1462 50 POP 1463 60 PUSH1 0x01 1465 60 PUSH1 0x01 1467 60 PUSH1 0xa0 1469 1B SHL 146A 03 SUB 146B 16 AND 146C 60 PUSH1 0x00 146E 90 SWAP1 146F 81 DUP2 1470 52 MSTORE 1471 60 PUSH1 0x20 1473 91 SWAP2 1474 90 SWAP1 1475 91 SWAP2 1476 52 MSTORE 1477 60 PUSH1 0x40 1479 90 SWAP1 147A 20 SHA3 147B 54 SLOAD 147C 60 PUSH1 0xff 147E 16 AND 147F 90 SWAP1 1480 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1470 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1476 memory[0x20:0x40] = stack[-3] // @147F stack[-4] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_1481: // Incoming call from 0x0AB3, returns to 0x0AB4 // Incoming call from 0x0E0F, returns to 0x0E10 // Inputs[2] // { // @1482 msg.sender // @1483 stack[-1] // } 1481 5B JUMPDEST 1482 33 CALLER 1483 90 SWAP1 1484 56 *JUMP // Stack delta = +0 // Outputs[1] { @1483 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_1485: // Incoming jump from 0x0AEF // Inputs[2] // { // @1486 stack[-1] // @1487 memory[stack[-1]:stack[-1] + 0x20] // } 1485 5B JUMPDEST 1486 80 DUP1 1487 51 MLOAD 1488 61 PUSH2 0x1498 148B 90 SWAP1 148C 60 PUSH1 0x05 148E 90 SWAP1 148F 60 PUSH1 0x20 1491 84 DUP5 1492 01 ADD 1493 90 SWAP1 1494 61 PUSH2 0x1b61 1497 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @148B stack[0] = 0x1498 // @148E stack[1] = 0x05 // @1493 stack[2] = stack[-1] + 0x20 // @1493 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1b61 1498 5B JUMPDEST 1499 50 POP 149A 50 POP 149B 56 *JUMP label_149C: // Incoming jump from 0x0B77 // Inputs[2] // { // @149D stack[-1] // @149E memory[stack[-1]:stack[-1] + 0x20] // } 149C 5B JUMPDEST 149D 80 DUP1 149E 51 MLOAD 149F 61 PUSH2 0x1498 14A2 90 SWAP1 14A3 60 PUSH1 0x03 14A5 90 SWAP1 14A6 60 PUSH1 0x20 14A8 84 DUP5 14A9 01 ADD 14AA 90 SWAP1 14AB 61 PUSH2 0x1b61 14AE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @14A2 stack[0] = 0x1498 // @14A5 stack[1] = 0x03 // @14AA stack[2] = stack[-1] + 0x20 // @14AA stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1b61 14AF 5B JUMPDEST 14B0 60 PUSH1 0x00 14B2 84 DUP5 14B3 81 DUP2 14B4 52 MSTORE 14B5 60 PUSH1 0x08 14B7 60 PUSH1 0x20 14B9 52 MSTORE 14BA 60 PUSH1 0x40 14BC 90 SWAP1 14BD 20 SHA3 14BE 54 SLOAD 14BF 60 PUSH1 0x01 14C1 60 PUSH1 0x01 14C3 60 PUSH1 0xa0 14C5 1B SHL 14C6 03 SUB 14C7 16 AND 14C8 15 ISZERO 14C9 61 PUSH2 0x14e4 14CC 57 *JUMPI 14CD 60 PUSH1 0x40 14CF 51 MLOAD 14D0 62 PUSH3 0x461bcd 14D4 60 PUSH1 0xe5 14D6 1B SHL 14D7 81 DUP2 14D8 52 MSTORE 14D9 60 PUSH1 0x04 14DB 01 ADD 14DC 61 PUSH2 0x04e6 14DF 90 SWAP1 14E0 61 PUSH2 0x2b2d 14E3 56 *JUMP 14E4 5B JUMPDEST 14E5 81 DUP2 14E6 61 PUSH2 0x1501 14E9 57 *JUMPI 14EA 60 PUSH1 0x40 14EC 51 MLOAD 14ED 62 PUSH3 0x461bcd 14F1 60 PUSH1 0xe5 14F3 1B SHL 14F4 81 DUP2 14F5 52 MSTORE 14F6 60 PUSH1 0x04 14F8 01 ADD 14F9 61 PUSH2 0x04e6 14FC 90 SWAP1 14FD 61 PUSH2 0x2b3d 1500 56 *JUMP 1501 5B JUMPDEST 1502 60 PUSH1 0x00 1504 81 DUP2 1505 51 MLOAD 1506 11 GT 1507 61 PUSH2 0x1522 150A 57 *JUMPI 150B 60 PUSH1 0x40 150D 51 MLOAD 150E 62 PUSH3 0x461bcd 1512 60 PUSH1 0xe5 1514 1B SHL 1515 81 DUP2 1516 52 MSTORE 1517 60 PUSH1 0x04 1519 01 ADD 151A 61 PUSH2 0x04e6 151D 90 SWAP1 151E 61 PUSH2 0x2b9d 1521 56 *JUMP 1522 5B JUMPDEST 1523 60 PUSH1 0x00 1525 84 DUP5 1526 81 DUP2 1527 52 MSTORE 1528 60 PUSH1 0x08 152A 60 PUSH1 0x20 152C 90 SWAP1 152D 81 DUP2 152E 52 MSTORE 152F 60 PUSH1 0x40 1531 91 SWAP2 1532 82 DUP3 1533 90 SWAP1 1534 20 SHA3 1535 80 DUP1 1536 54 SLOAD 1537 60 PUSH1 0x01 1539 60 PUSH1 0x01 153B 60 PUSH1 0xa0 153D 1B SHL 153E 03 SUB 153F 19 NOT 1540 16 AND 1541 33 CALLER 1542 17 OR 1543 90 SWAP1 1544 55 SSTORE 1545 84 DUP5 1546 51 MLOAD 1547 82 DUP3 1548 51 MLOAD 1549 81 DUP2 154A 81 DUP2 154B 52 MSTORE 154C 81 DUP2 154D 83 DUP4 154E 02 MUL 154F 81 DUP2 1550 01 ADD 1551 90 SWAP1 1552 92 SWAP3 1553 01 ADD 1554 90 SWAP1 1555 92 SWAP3 1556 52 MSTORE 1557 60 PUSH1 0x60 1559 91 SWAP2 155A 80 DUP1 155B 15 ISZERO 155C 61 PUSH2 0x156f 155F 57 *JUMPI 1560 81 DUP2 1561 60 PUSH1 0x20 1563 01 ADD 1564 60 PUSH1 0x20 1566 82 DUP3 1567 02 MUL 1568 80 DUP1 1569 38 CODESIZE 156A 83 DUP4 156B 39 CODECOPY 156C 01 ADD 156D 90 SWAP1 156E 50 POP 156F 5B JUMPDEST 1570 50 POP 1571 90 SWAP1 1572 50 POP 1573 60 PUSH1 0x60 1575 84 DUP5 1576 51 MLOAD 1577 60 PUSH1 0x40 1579 51 MLOAD 157A 90 SWAP1 157B 80 DUP1 157C 82 DUP3 157D 52 MSTORE 157E 80 DUP1 157F 60 PUSH1 0x20 1581 02 MUL 1582 60 PUSH1 0x20 1584 01 ADD 1585 82 DUP3 1586 01 ADD 1587 60 PUSH1 0x40 1589 52 MSTORE 158A 80 DUP1 158B 15 ISZERO 158C 61 PUSH2 0x159f 158F 57 *JUMPI 1590 81 DUP2 1591 60 PUSH1 0x20 1593 01 ADD 1594 60 PUSH1 0x20 1596 82 DUP3 1597 02 MUL 1598 80 DUP1 1599 38 CODESIZE 159A 83 DUP4 159B 39 CODECOPY 159C 01 ADD 159D 90 SWAP1 159E 50 POP 159F 5B JUMPDEST 15A0 50 POP 15A1 90 SWAP1 15A2 50 POP 15A3 60 PUSH1 0x00 15A5 5B JUMPDEST 15A6 85 DUP6 15A7 51 MLOAD 15A8 81 DUP2 15A9 10 LT 15AA 15 ISZERO 15AB 61 PUSH2 0x1712 15AE 57 *JUMPI 15AF 60 PUSH1 0x00 15B1 60 PUSH1 0x01 15B3 60 PUSH1 0x01 15B5 60 PUSH1 0xa0 15B7 1B SHL 15B8 03 SUB 15B9 16 AND 15BA 86 DUP7 15BB 82 DUP3 15BC 81 DUP2 15BD 51 MLOAD 15BE 81 DUP2 15BF 10 LT 15C0 61 PUSH2 0x15c5 15C3 57 *JUMPI 15C4 FE *ASSERT 15C5 5B JUMPDEST 15C6 60 PUSH1 0x20 15C8 02 MUL 15C9 60 PUSH1 0x20 15CB 01 ADD 15CC 01 ADD 15CD 51 MLOAD 15CE 60 PUSH1 0x00 15D0 01 ADD 15D1 51 MLOAD 15D2 60 PUSH1 0x01 15D4 60 PUSH1 0x01 15D6 60 PUSH1 0xa0 15D8 1B SHL 15D9 03 SUB 15DA 16 AND 15DB 14 EQ 15DC 15 ISZERO 15DD 61 PUSH2 0x15f8 15E0 57 *JUMPI 15E1 60 PUSH1 0x40 15E3 51 MLOAD 15E4 62 PUSH3 0x461bcd 15E8 60 PUSH1 0xe5 15EA 1B SHL 15EB 81 DUP2 15EC 52 MSTORE 15ED 60 PUSH1 0x04 15EF 01 ADD 15F0 61 PUSH2 0x04e6 15F3 90 SWAP1 15F4 61 PUSH2 0x2b5d 15F7 56 *JUMP 15F8 5B JUMPDEST 15F9 85 DUP6 15FA 81 DUP2 15FB 81 DUP2 15FC 51 MLOAD 15FD 81 DUP2 15FE 10 LT 15FF 61 PUSH2 0x1604 1602 57 *JUMPI 1603 FE *ASSERT 1604 5B JUMPDEST 1605 60 PUSH1 0x20 1607 02 MUL 1608 60 PUSH1 0x20 160A 01 ADD 160B 01 ADD 160C 51 MLOAD 160D 60 PUSH1 0x20 160F 01 ADD 1610 51 MLOAD 1611 60 PUSH1 0x00 1613 14 EQ 1614 15 ISZERO 1615 61 PUSH2 0x1630 1618 57 *JUMPI 1619 60 PUSH1 0x40 161B 51 MLOAD 161C 62 PUSH3 0x461bcd 1620 60 PUSH1 0xe5 1622 1B SHL 1623 81 DUP2 1624 52 MSTORE 1625 60 PUSH1 0x04 1627 01 ADD 1628 61 PUSH2 0x04e6 162B 90 SWAP1 162C 61 PUSH2 0x2a7d 162F 56 *JUMP 1630 5B JUMPDEST 1631 60 PUSH1 0x00 1633 87 DUP8 1634 81 DUP2 1635 52 MSTORE 1636 60 PUSH1 0x09 1638 60 PUSH1 0x20 163A 52 MSTORE 163B 60 PUSH1 0x40 163D 90 SWAP1 163E 20 SHA3 163F 86 DUP7 1640 51 MLOAD 1641 87 DUP8 1642 90 SWAP1 1643 83 DUP4 1644 90 SWAP1 1645 81 DUP2 1646 10 LT 1647 61 PUSH2 0x164c 164A 57 *JUMPI 164B FE *ASSERT 164C 5B JUMPDEST 164D 60 PUSH1 0x20 164F 90 SWAP1 1650 81 DUP2 1651 02 MUL 1652 91 SWAP2 1653 90 SWAP1 1654 91 SWAP2 1655 01 ADD 1656 81 DUP2 1657 01 ADD 1658 51 MLOAD 1659 82 DUP3 165A 54 SLOAD 165B 60 PUSH1 0x01 165D 80 DUP1 165E 82 DUP3 165F 01 ADD 1660 85 DUP6 1661 55 SSTORE 1662 60 PUSH1 0x00 1664 94 SWAP5 1665 85 DUP6 1666 52 MSTORE 1667 93 SWAP4 1668 83 DUP4 1669 90 SWAP1 166A 20 SHA3 166B 82 DUP3 166C 51 MLOAD 166D 60 PUSH1 0x02 166F 90 SWAP1 1670 92 SWAP3 1671 02 MUL 1672 01 ADD 1673 80 DUP1 1674 54 SLOAD 1675 60 PUSH1 0x01 1677 60 PUSH1 0x01 1679 60 PUSH1 0xa0 167B 1B SHL 167C 03 SUB 167D 19 NOT 167E 16 AND 167F 60 PUSH1 0x01 1681 60 PUSH1 0x01 1683 60 PUSH1 0xa0 1685 1B SHL 1686 03 SUB 1687 90 SWAP1 1688 92 SWAP3 1689 16 AND 168A 91 SWAP2 168B 90 SWAP1 168C 91 SWAP2 168D 17 OR 168E 81 DUP2 168F 55 SSTORE 1690 91 SWAP2 1691 01 ADD 1692 51 MLOAD 1693 91 SWAP2 1694 01 ADD 1695 55 SSTORE 1696 85 DUP6 1697 51 MLOAD 1698 86 DUP7 1699 90 SWAP1 169A 82 DUP3 169B 90 SWAP1 169C 81 DUP2 169D 10 LT 169E 61 PUSH2 0x16a3 16A1 57 *JUMPI 16A2 FE *ASSERT 16A3 5B JUMPDEST 16A4 60 PUSH1 0x20 16A6 02 MUL 16A7 60 PUSH1 0x20 16A9 01 ADD 16AA 01 ADD 16AB 51 MLOAD 16AC 60 PUSH1 0x00 16AE 01 ADD 16AF 51 MLOAD 16B0 83 DUP4 16B1 82 DUP3 16B2 81 DUP2 16B3 51 MLOAD 16B4 81 DUP2 16B5 10 LT 16B6 61 PUSH2 0x16bb 16B9 57 *JUMPI 16BA FE *ASSERT 16BB 5B JUMPDEST 16BC 60 PUSH1 0x20 16BE 02 MUL 16BF 60 PUSH1 0x20 16C1 01 ADD 16C2 01 ADD 16C3 90 SWAP1 16C4 60 PUSH1 0x01 16C6 60 PUSH1 0x01 16C8 60 PUSH1 0xa0 16CA 1B SHL 16CB 03 SUB 16CC 16 AND 16CD 90 SWAP1 16CE 81 DUP2 16CF 60 PUSH1 0x01 16D1 60 PUSH1 0x01 16D3 60 PUSH1 0xa0 16D5 1B SHL 16D6 03 SUB 16D7 16 AND 16D8 81 DUP2 16D9 52 MSTORE 16DA 50 POP 16DB 50 POP 16DC 85 DUP6 16DD 81 DUP2 16DE 81 DUP2 16DF 51 MLOAD 16E0 81 DUP2 16E1 10 LT 16E2 61 PUSH2 0x16e7 16E5 57 *JUMPI 16E6 FE *ASSERT 16E7 5B JUMPDEST 16E8 60 PUSH1 0x20 16EA 02 MUL 16EB 60 PUSH1 0x20 16ED 01 ADD 16EE 01 ADD 16EF 51 MLOAD 16F0 60 PUSH1 0x20 16F2 01 ADD 16F3 51 MLOAD 16F4 82 DUP3 16F5 82 DUP3 16F6 81 DUP2 16F7 51 MLOAD 16F8 81 DUP2 16F9 10 LT 16FA 61 PUSH2 0x16ff 16FD 57 *JUMPI 16FE FE *ASSERT 16FF 5B JUMPDEST 1700 60 PUSH1 0x20 1702 90 SWAP1 1703 81 DUP2 1704 02 MUL 1705 91 SWAP2 1706 90 SWAP1 1707 91 SWAP2 1708 01 ADD 1709 01 ADD 170A 52 MSTORE 170B 60 PUSH1 0x01 170D 01 ADD 170E 61 PUSH2 0x15a5 1711 56 *JUMP 1712 5B JUMPDEST 1713 50 POP 1714 84 DUP5 1715 51 MLOAD 1716 15 ISZERO 1717 61 PUSH2 0x1756 171A 57 *JUMPI 171B 7F PUSH32 0x99aba1d63749cfd5ad1afda7c4663840924d54eb5f005bbbeadedc6ec13674b2 173C 86 DUP7 173D 83 DUP4 173E 83 DUP4 173F 60 PUSH1 0x40 1741 51 MLOAD 1742 61 PUSH2 0x174d 1745 93 SWAP4 1746 92 SWAP3 1747 91 SWAP2 1748 90 SWAP1 1749 61 PUSH2 0x2bbb 174C 56 *JUMP 174D 5B JUMPDEST 174E 60 PUSH1 0x40 1750 51 MLOAD 1751 80 DUP1 1752 91 SWAP2 1753 03 SUB 1754 90 SWAP1 1755 A1 LOG1 1756 5B JUMPDEST 1757 60 PUSH1 0x00 1759 86 DUP7 175A 81 DUP2 175B 52 MSTORE 175C 60 PUSH1 0x06 175E 60 PUSH1 0x20 1760 90 SWAP1 1761 81 DUP2 1762 52 MSTORE 1763 60 PUSH1 0x40 1765 80 DUP1 1766 83 DUP4 1767 20 SHA3 1768 33 CALLER 1769 84 DUP5 176A 52 MSTORE 176B 90 SWAP1 176C 91 SWAP2 176D 52 MSTORE 176E 90 SWAP1 176F 20 SHA3 1770 84 DUP5 1771 90 SWAP1 1772 55 SSTORE 1773 61 PUSH2 0x177c 1776 86 DUP7 1777 84 DUP5 1778 61 PUSH2 0x1ab3 177B 56 *JUMP 177C 5B JUMPDEST 177D 60 PUSH1 0x40 177F 51 MLOAD 1780 33 CALLER 1781 90 SWAP1 1782 60 PUSH1 0x00 1784 90 SWAP1 1785 82 DUP3 1786 90 SWAP1 1787 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 17A8 90 SWAP1 17A9 61 PUSH2 0x17b5 17AC 90 SWAP1 17AD 8B DUP12 17AE 90 SWAP1 17AF 8A DUP11 17B0 90 SWAP1 17B1 61 PUSH2 0x2bef 17B4 56 *JUMP 17B5 5B JUMPDEST 17B6 60 PUSH1 0x40 17B8 51 MLOAD 17B9 80 DUP1 17BA 91 SWAP2 17BB 03 SUB 17BC 90 SWAP1 17BD A4 LOG4 17BE 85 DUP6 17BF 7F PUSH32 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b 17E0 84 DUP5 17E1 60 PUSH1 0x40 17E3 51 MLOAD 17E4 61 PUSH2 0x17ed 17E7 91 SWAP2 17E8 90 SWAP1 17E9 61 PUSH2 0x2a6c 17EC 56 *JUMP 17ED 5B JUMPDEST 17EE 60 PUSH1 0x40 17F0 51 MLOAD 17F1 80 DUP1 17F2 91 SWAP2 17F3 03 SUB 17F4 90 SWAP1 17F5 A2 LOG2 17F6 50 POP 17F7 50 POP 17F8 50 POP 17F9 50 POP 17FA 50 POP 17FB 50 POP 17FC 56 *JUMP 17FD 5B JUMPDEST 17FE 61 PUSH2 0x180e 1801 60 PUSH1 0x02 1803 82 DUP3 1804 63 PUSH4 0xffffffff 1809 61 PUSH2 0x1af1 180C 16 AND 180D 56 *JUMP 180E 5B JUMPDEST 180F 60 PUSH1 0x40 1811 51 MLOAD 1812 60 PUSH1 0x01 1814 60 PUSH1 0x01 1816 60 PUSH1 0xa0 1818 1B SHL 1819 03 SUB 181A 82 DUP3 181B 16 AND 181C 90 SWAP1 181D 7F PUSH32 0x47d1c22a25bb3a5d4e481b9b1e6944c2eade3181a0a20b495ed61d35b5323f24 183E 90 SWAP1 183F 60 PUSH1 0x00 1841 90 SWAP1 1842 A2 LOG2 1843 50 POP 1844 56 *JUMP 1845 5B JUMPDEST 1846 60 PUSH1 0x40 1848 51 MLOAD 1849 63 PUSH4 0xf23a6e61 184E 60 PUSH1 0xe0 1850 1B SHL 1851 80 DUP1 1852 82 DUP3 1853 52 MSTORE 1854 90 SWAP1 1855 60 PUSH1 0x01 1857 60 PUSH1 0x01 1859 60 PUSH1 0xa0 185B 1B SHL 185C 03 SUB 185D 86 DUP7 185E 16 AND 185F 90 SWAP1 1860 63 PUSH4 0xf23a6e61 1865 90 SWAP1 1866 61 PUSH2 0x187b 1869 90 SWAP1 186A 8A DUP11 186B 90 SWAP1 186C 8A DUP11 186D 90 SWAP1 186E 89 DUP10 186F 90 SWAP1 1870 89 DUP10 1871 90 SWAP1 1872 89 DUP10 1873 90 SWAP1 1874 60 PUSH1 0x04 1876 01 ADD 1877 61 PUSH2 0x2986 187A 56 *JUMP 187B 5B JUMPDEST 187C 60 PUSH1 0x20 187E 60 PUSH1 0x40 1880 51 MLOAD 1881 80 DUP1 1882 83 DUP4 1883 03 SUB 1884 81 DUP2 1885 60 PUSH1 0x00 1887 87 DUP8 1888 80 DUP1 1889 3B EXTCODESIZE 188A 15 ISZERO 188B 80 DUP1 188C 15 ISZERO 188D 61 PUSH2 0x1895 1890 57 *JUMPI 1891 60 PUSH1 0x00 1893 80 DUP1 1894 FD *REVERT 1895 5B JUMPDEST 1896 50 POP 1897 5A GAS 1898 F1 CALL 1899 15 ISZERO 189A 80 DUP1 189B 15 ISZERO 189C 61 PUSH2 0x18a9 189F 57 *JUMPI 18A0 3D RETURNDATASIZE 18A1 60 PUSH1 0x00 18A3 80 DUP1 18A4 3E RETURNDATACOPY 18A5 3D RETURNDATASIZE 18A6 60 PUSH1 0x00 18A8 FD *REVERT 18A9 5B JUMPDEST 18AA 50 POP 18AB 50 POP 18AC 50 POP 18AD 50 POP 18AE 60 PUSH1 0x40 18B0 51 MLOAD 18B1 3D RETURNDATASIZE 18B2 60 PUSH1 0x1f 18B4 19 NOT 18B5 60 PUSH1 0x1f 18B7 82 DUP3 18B8 01 ADD 18B9 16 AND 18BA 82 DUP3 18BB 01 ADD 18BC 80 DUP1 18BD 60 PUSH1 0x40 18BF 52 MSTORE 18C0 50 POP 18C1 61 PUSH2 0x18cd 18C4 91 SWAP2 18C5 90 SWAP1 18C6 81 DUP2 18C7 01 ADD 18C8 90 SWAP1 18C9 61 PUSH2 0x20c2 18CC 56 *JUMP 18CD 5B JUMPDEST 18CE 60 PUSH1 0x01 18D0 60 PUSH1 0x01 18D2 60 PUSH1 0xe0 18D4 1B SHL 18D5 03 SUB 18D6 19 NOT 18D7 16 AND 18D8 14 EQ 18D9 61 PUSH2 0x107f 18DC 57 *JUMPI 18DD 60 PUSH1 0x40 18DF 51 MLOAD 18E0 62 PUSH3 0x461bcd 18E4 60 PUSH1 0xe5 18E6 1B SHL 18E7 81 DUP2 18E8 52 MSTORE 18E9 60 PUSH1 0x04 18EB 01 ADD 18EC 61 PUSH2 0x04e6 18EF 90 SWAP1 18F0 61 PUSH2 0x2b6d 18F3 56 *JUMP 18F4 5B JUMPDEST 18F5 60 PUSH1 0x01 18F7 60 PUSH1 0x01 18F9 60 PUSH1 0xa0 18FB 1B SHL 18FC 03 SUB 18FD 81 DUP2 18FE 16 AND 18FF 61 PUSH2 0x191a 1902 57 *JUMPI 1903 60 PUSH1 0x40 1905 51 MLOAD 1906 62 PUSH3 0x461bcd 190A 60 PUSH1 0xe5 190C 1B SHL 190D 81 DUP2 190E 52 MSTORE 190F 60 PUSH1 0x04 1911 01 ADD 1912 61 PUSH2 0x04e6 1915 90 SWAP1 1916 61 PUSH2 0x2a9d 1919 56 *JUMP 191A 5B JUMPDEST 191B 60 PUSH1 0x01 191D 54 SLOAD 191E 60 PUSH1 0x40 1920 51 MLOAD 1921 60 PUSH1 0x01 1923 60 PUSH1 0x01 1925 60 PUSH1 0xa0 1927 1B SHL 1928 03 SUB 1929 80 DUP1 192A 84 DUP5 192B 16 AND 192C 92 SWAP3 192D 16 AND 192E 90 SWAP1 192F 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1950 90 SWAP1 1951 60 PUSH1 0x00 1953 90 SWAP1 1954 A3 LOG3 1955 60 PUSH1 0x01 1957 80 DUP1 1958 54 SLOAD 1959 60 PUSH1 0x01 195B 60 PUSH1 0x01 195D 60 PUSH1 0xa0 195F 1B SHL 1960 03 SUB 1961 19 NOT 1962 16 AND 1963 60 PUSH1 0x01 1965 60 PUSH1 0x01 1967 60 PUSH1 0xa0 1969 1B SHL 196A 03 SUB 196B 92 SWAP3 196C 90 SWAP1 196D 92 SWAP3 196E 16 AND 196F 91 SWAP2 1970 90 SWAP1 1971 91 SWAP2 1972 17 OR 1973 90 SWAP1 1974 55 SSTORE 1975 56 *JUMP label_1976: // Incoming call from 0x11BC, returns to 0x11BD // Inputs[2] // { // @197A stack[-2] // @197B stack[-1] // } 1976 5B JUMPDEST 1977 61 PUSH2 0x1980 197A 82 DUP3 197B 82 DUP3 197C 61 PUSH2 0x1439 197F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1977 stack[0] = 0x1980 // @197A stack[1] = stack[-2] // @197B stack[2] = stack[-1] // } // Block ends with call to 0x1439, returns to 0x1980 label_1980: // Incoming return from call to 0x1439 at 0x197F // Inputs[1] { @1984 stack[-1] } 1980 5B JUMPDEST 1981 61 PUSH2 0x199c 1984 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x199c, if stack[-1] label_1985: // Incoming jump from 0x1984, if not stack[-1] // Inputs[1] { @1987 memory[0x40:0x60] } 1985 60 PUSH1 0x40 1987 51 MLOAD 1988 62 PUSH3 0x461bcd 198C 60 PUSH1 0xe5 198E 1B SHL 198F 81 DUP2 1990 52 MSTORE 1991 60 PUSH1 0x04 1993 01 ADD 1994 61 PUSH2 0x04e6 1997 90 SWAP1 1998 61 PUSH2 0x2acd 199B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1990 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1997 stack[0] = 0x04e6 // @1997 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2acd label_199C: // Incoming jump from 0x1984, if stack[-1] // Inputs[5] // { // @19A5 stack[-1] // @19AD stack[-2] // @19B4 memory[0x00:0x40] // @19B6 storage[keccak256(memory[0x00:0x40])] // @19BD stack[-3] // } 199C 5B JUMPDEST 199D 60 PUSH1 0x01 199F 60 PUSH1 0x01 19A1 60 PUSH1 0xa0 19A3 1B SHL 19A4 03 SUB 19A5 16 AND 19A6 60 PUSH1 0x00 19A8 90 SWAP1 19A9 81 DUP2 19AA 52 MSTORE 19AB 60 PUSH1 0x20 19AD 91 SWAP2 19AE 90 SWAP1 19AF 91 SWAP2 19B0 52 MSTORE 19B1 60 PUSH1 0x40 19B3 90 SWAP1 19B4 20 SHA3 19B5 80 DUP1 19B6 54 SLOAD 19B7 60 PUSH1 0xff 19B9 19 NOT 19BA 16 AND 19BB 90 SWAP1 19BC 55 SSTORE 19BD 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @19AA memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @19B0 memory[0x20:0x40] = stack[-2] // @19BC storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] 19BE 5B JUMPDEST 19BF 60 PUSH1 0x60 19C1 80 DUP1 19C2 83 DUP4 19C3 90 SWAP1 19C4 50 POP 19C5 60 PUSH1 0x60 19C7 83 DUP4 19C8 90 SWAP1 19C9 50 POP 19CA 60 PUSH1 0x60 19CC 81 DUP2 19CD 51 MLOAD 19CE 83 DUP4 19CF 51 MLOAD 19D0 01 ADD 19D1 60 PUSH1 0x40 19D3 51 MLOAD 19D4 90 SWAP1 19D5 80 DUP1 19D6 82 DUP3 19D7 52 MSTORE 19D8 80 DUP1 19D9 60 PUSH1 0x1f 19DB 01 ADD 19DC 60 PUSH1 0x1f 19DE 19 NOT 19DF 16 AND 19E0 60 PUSH1 0x20 19E2 01 ADD 19E3 82 DUP3 19E4 01 ADD 19E5 60 PUSH1 0x40 19E7 52 MSTORE 19E8 80 DUP1 19E9 15 ISZERO 19EA 61 PUSH2 0x19fa 19ED 57 *JUMPI 19EE 60 PUSH1 0x20 19F0 82 DUP3 19F1 01 ADD 19F2 81 DUP2 19F3 80 DUP1 19F4 38 CODESIZE 19F5 83 DUP4 19F6 39 CODECOPY 19F7 01 ADD 19F8 90 SWAP1 19F9 50 POP 19FA 5B JUMPDEST 19FB 50 POP 19FC 90 SWAP1 19FD 50 POP 19FE 60 PUSH1 0x00 1A00 80 DUP1 1A01 5B JUMPDEST 1A02 84 DUP5 1A03 51 MLOAD 1A04 81 DUP2 1A05 10 LT 1A06 15 ISZERO 1A07 61 PUSH2 0x1a52 1A0A 57 *JUMPI 1A0B 84 DUP5 1A0C 81 DUP2 1A0D 81 DUP2 1A0E 51 MLOAD 1A0F 81 DUP2 1A10 10 LT 1A11 61 PUSH2 0x1a16 1A14 57 *JUMPI 1A15 FE *ASSERT 1A16 5B JUMPDEST 1A17 60 PUSH1 0x20 1A19 01 ADD 1A1A 01 ADD 1A1B 51 MLOAD 1A1C 60 PUSH1 0xf8 1A1E 1C SHR 1A1F 60 PUSH1 0xf8 1A21 1B SHL 1A22 83 DUP4 1A23 83 DUP4 1A24 80 DUP1 1A25 60 PUSH1 0x01 1A27 01 ADD 1A28 94 SWAP5 1A29 50 POP 1A2A 81 DUP2 1A2B 51 MLOAD 1A2C 81 DUP2 1A2D 10 LT 1A2E 61 PUSH2 0x1a33 1A31 57 *JUMPI 1A32 FE *ASSERT 1A33 5B JUMPDEST 1A34 60 PUSH1 0x20 1A36 01 ADD 1A37 01 ADD 1A38 90 SWAP1 1A39 60 PUSH1 0x01 1A3B 60 PUSH1 0x01 1A3D 60 PUSH1 0xf8 1A3F 1B SHL 1A40 03 SUB 1A41 19 NOT 1A42 16 AND 1A43 90 SWAP1 1A44 81 DUP2 1A45 60 PUSH1 0x00 1A47 1A BYTE 1A48 90 SWAP1 1A49 53 MSTORE8 1A4A 50 POP 1A4B 60 PUSH1 0x01 1A4D 01 ADD 1A4E 61 PUSH2 0x1a01 1A51 56 *JUMP 1A52 5B JUMPDEST 1A53 50 POP 1A54 60 PUSH1 0x00 1A56 5B JUMPDEST 1A57 83 DUP4 1A58 51 MLOAD 1A59 81 DUP2 1A5A 10 LT 1A5B 15 ISZERO 1A5C 61 PUSH2 0x1aa7 1A5F 57 *JUMPI 1A60 83 DUP4 1A61 81 DUP2 1A62 81 DUP2 1A63 51 MLOAD 1A64 81 DUP2 1A65 10 LT 1A66 61 PUSH2 0x1a6b 1A69 57 *JUMPI 1A6A FE *ASSERT 1A6B 5B JUMPDEST 1A6C 60 PUSH1 0x20 1A6E 01 ADD 1A6F 01 ADD 1A70 51 MLOAD 1A71 60 PUSH1 0xf8 1A73 1C SHR 1A74 60 PUSH1 0xf8 1A76 1B SHL 1A77 83 DUP4 1A78 83 DUP4 1A79 80 DUP1 1A7A 60 PUSH1 0x01 1A7C 01 ADD 1A7D 94 SWAP5 1A7E 50 POP 1A7F 81 DUP2 1A80 51 MLOAD 1A81 81 DUP2 1A82 10 LT 1A83 61 PUSH2 0x1a88 1A86 57 *JUMPI 1A87 FE *ASSERT 1A88 5B JUMPDEST 1A89 60 PUSH1 0x20 1A8B 01 ADD 1A8C 01 ADD 1A8D 90 SWAP1 1A8E 60 PUSH1 0x01 1A90 60 PUSH1 0x01 1A92 60 PUSH1 0xf8 1A94 1B SHL 1A95 03 SUB 1A96 19 NOT 1A97 16 AND 1A98 90 SWAP1 1A99 81 DUP2 1A9A 60 PUSH1 0x00 1A9C 1A BYTE 1A9D 90 SWAP1 1A9E 53 MSTORE8 1A9F 50 POP 1AA0 60 PUSH1 0x01 1AA2 01 ADD 1AA3 61 PUSH2 0x1a56 1AA6 56 *JUMP 1AA7 5B JUMPDEST 1AA8 50 POP 1AA9 90 SWAP1 1AAA 96 SWAP7 1AAB 95 SWAP6 1AAC 50 POP 1AAD 50 POP 1AAE 50 POP 1AAF 50 POP 1AB0 50 POP 1AB1 50 POP 1AB2 56 *JUMP 1AB3 5B JUMPDEST 1AB4 60 PUSH1 0x00 1AB6 82 DUP3 1AB7 81 DUP2 1AB8 52 MSTORE 1AB9 60 PUSH1 0x08 1ABB 60 PUSH1 0x20 1ABD 52 MSTORE 1ABE 60 PUSH1 0x40 1AC0 90 SWAP1 1AC1 20 SHA3 1AC2 54 SLOAD 1AC3 60 PUSH1 0x01 1AC5 60 PUSH1 0x01 1AC7 60 PUSH1 0xa0 1AC9 1B SHL 1ACA 03 SUB 1ACB 16 AND 1ACC 61 PUSH2 0x1ae7 1ACF 57 *JUMPI 1AD0 60 PUSH1 0x40 1AD2 51 MLOAD 1AD3 62 PUSH3 0x461bcd 1AD7 60 PUSH1 0xe5 1AD9 1B SHL 1ADA 81 DUP2 1ADB 52 MSTORE 1ADC 60 PUSH1 0x04 1ADE 01 ADD 1ADF 61 PUSH2 0x04e6 1AE2 90 SWAP1 1AE3 61 PUSH2 0x2aad 1AE6 56 *JUMP 1AE7 5B JUMPDEST 1AE8 61 PUSH2 0x1498 1AEB 82 DUP3 1AEC 82 DUP3 1AED 61 PUSH2 0x1b3d 1AF0 56 *JUMP 1AF1 5B JUMPDEST 1AF2 61 PUSH2 0x1afb 1AF5 82 DUP3 1AF6 82 DUP3 1AF7 61 PUSH2 0x1439 1AFA 56 *JUMP 1AFB 5B JUMPDEST 1AFC 15 ISZERO 1AFD 61 PUSH2 0x1b18 1B00 57 *JUMPI 1B01 60 PUSH1 0x40 1B03 51 MLOAD 1B04 62 PUSH3 0x461bcd 1B08 60 PUSH1 0xe5 1B0A 1B SHL 1B0B 81 DUP2 1B0C 52 MSTORE 1B0D 60 PUSH1 0x04 1B0F 01 ADD 1B10 61 PUSH2 0x04e6 1B13 90 SWAP1 1B14 61 PUSH2 0x2a8d 1B17 56 *JUMP 1B18 5B JUMPDEST 1B19 60 PUSH1 0x01 1B1B 60 PUSH1 0x01 1B1D 60 PUSH1 0xa0 1B1F 1B SHL 1B20 03 SUB 1B21 16 AND 1B22 60 PUSH1 0x00 1B24 90 SWAP1 1B25 81 DUP2 1B26 52 MSTORE 1B27 60 PUSH1 0x20 1B29 91 SWAP2 1B2A 90 SWAP1 1B2B 91 SWAP2 1B2C 52 MSTORE 1B2D 60 PUSH1 0x40 1B2F 90 SWAP1 1B30 20 SHA3 1B31 80 DUP1 1B32 54 SLOAD 1B33 60 PUSH1 0xff 1B35 19 NOT 1B36 16 AND 1B37 60 PUSH1 0x01 1B39 17 OR 1B3A 90 SWAP1 1B3B 55 SSTORE 1B3C 56 *JUMP 1B3D 5B JUMPDEST 1B3E 60 PUSH1 0x00 1B40 82 DUP3 1B41 81 DUP2 1B42 52 MSTORE 1B43 60 PUSH1 0x04 1B45 60 PUSH1 0x20 1B47 90 SWAP1 1B48 81 DUP2 1B49 52 MSTORE 1B4A 60 PUSH1 0x40 1B4C 90 SWAP1 1B4D 91 SWAP2 1B4E 20 SHA3 1B4F 82 DUP3 1B50 51 MLOAD 1B51 61 PUSH2 0x1b5c 1B54 92 SWAP3 1B55 84 DUP5 1B56 01 ADD 1B57 90 SWAP1 1B58 61 PUSH2 0x1b61 1B5B 56 *JUMP 1B5C 5B JUMPDEST 1B5D 50 POP 1B5E 50 POP 1B5F 50 POP 1B60 56 *JUMP label_1B61: // Incoming jump from 0x14AE // Incoming jump from 0x1497 // Inputs[5] // { // @1B62 stack[-3] // @1B64 storage[stack[-3]] // @1B7E memory[0x00:0x20] // @1B89 stack[-2] // @1B8A stack[-1] // } 1B61 5B JUMPDEST 1B62 82 DUP3 1B63 80 DUP1 1B64 54 SLOAD 1B65 60 PUSH1 0x01 1B67 81 DUP2 1B68 60 PUSH1 0x01 1B6A 16 AND 1B6B 15 ISZERO 1B6C 61 PUSH2 0x0100 1B6F 02 MUL 1B70 03 SUB 1B71 16 AND 1B72 60 PUSH1 0x02 1B74 90 SWAP1 1B75 04 DIV 1B76 90 SWAP1 1B77 60 PUSH1 0x00 1B79 52 MSTORE 1B7A 60 PUSH1 0x20 1B7C 60 PUSH1 0x00 1B7E 20 SHA3 1B7F 90 SWAP1 1B80 60 PUSH1 0x1f 1B82 01 ADD 1B83 60 PUSH1 0x20 1B85 90 SWAP1 1B86 04 DIV 1B87 81 DUP2 1B88 01 ADD 1B89 92 SWAP3 1B8A 82 DUP3 1B8B 60 PUSH1 0x1f 1B8D 10 LT 1B8E 61 PUSH2 0x1ba2 1B91 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1B79 memory[0x00:0x20] = stack[-3] // @1B7F stack[0] = keccak256(memory[0x00:0x20]) // @1B89 stack[1] = stack[-2] // @1B89 stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x1ba2, if 0x1f < stack[-1] label_1B92: // Incoming jump from 0x1B91, if not 0x1f < stack[-1] // Inputs[4] // { // @1B92 stack[-1] // @1B93 memory[stack[-1]:stack[-1] + 0x20] // @1B98 stack[-3] // @1B9C stack[-5] // } 1B92 80 DUP1 1B93 51 MLOAD 1B94 60 PUSH1 0xff 1B96 19 NOT 1B97 16 AND 1B98 83 DUP4 1B99 80 DUP1 1B9A 01 ADD 1B9B 17 OR 1B9C 85 DUP6 1B9D 55 SSTORE 1B9E 61 PUSH2 0x1bcf 1BA1 56 *JUMP // Stack delta = +0 // Outputs[1] { @1B9D storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x1bcf label_1BA2: // Incoming jump from 0x1B91, if 0x1f < stack[-1] // Inputs[2] // { // @1BA3 stack[-3] // @1BA9 stack[-5] // } 1BA2 5B JUMPDEST 1BA3 82 DUP3 1BA4 80 DUP1 1BA5 01 ADD 1BA6 60 PUSH1 0x01 1BA8 01 ADD 1BA9 85 DUP6 1BAA 55 SSTORE 1BAB 82 DUP3 1BAC 15 ISZERO 1BAD 61 PUSH2 0x1bcf 1BB0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1BAA storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1bcf, if !stack[-3] label_1BB1: // Incoming jump from 0x1BB0, if not !stack[-3] // Inputs[2] // { // @1BB1 stack[-3] // @1BB1 stack[-1] // } 1BB1 91 SWAP2 1BB2 82 DUP3 1BB3 01 ADD 1BB4 5B JUMPDEST 1BB5 82 DUP3 1BB6 81 DUP2 1BB7 11 GT 1BB8 15 ISZERO 1BB9 61 PUSH2 0x1bcf 1BBC 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1BB1 stack[-3] = stack[-1] // @1BB3 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1bcf, if !(stack[-1] + stack[-3] > stack[-1]) label_1BBD: // Incoming jump from 0x1BBC, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x1BBC, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @1BBD stack[-3] // @1BBE memory[stack[-3]:stack[-3] + 0x20] // @1BBF stack[-2] // @1BC1 stack[-1] // } 1BBD 82 DUP3 1BBE 51 MLOAD 1BBF 82 DUP3 1BC0 55 SSTORE 1BC1 91 SWAP2 1BC2 60 PUSH1 0x20 1BC4 01 ADD 1BC5 91 SWAP2 1BC6 90 SWAP1 1BC7 60 PUSH1 0x01 1BC9 01 ADD 1BCA 90 SWAP1 1BCB 61 PUSH2 0x1bb4 1BCE 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1BC0 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1BC5 stack[-3] = 0x20 + stack[-3] // @1BCA stack[-2] = 0x01 + stack[-2] // @1BCA stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1bb4 label_1BCF: // Incoming jump from 0x1BB0, if !stack[-3] // Incoming jump from 0x1BBC, if !(stack[-1] > stack[-3]) // Incoming jump from 0x1BA1 // Incoming jump from 0x1BBC, if !(stack[-1] + stack[-3] > stack[-1]) // Inputs[2] // { // @1BD4 stack[-4] // @1BD5 stack[-3] // } 1BCF 5B JUMPDEST 1BD0 50 POP 1BD1 61 PUSH2 0x1bdb 1BD4 92 SWAP3 1BD5 91 SWAP2 1BD6 50 POP 1BD7 61 PUSH2 0x1bdf 1BDA 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1BD4 stack[-4] = 0x1bdb // @1BD5 stack[-3] = stack[-4] // } // Block ends with call to 0x1bdf, returns to 0x1BDB label_1BDB: // Incoming call from 0x1BED, returns to 0x0A9A, if !(stack[-2] > stack[-1]) // Incoming jump from 0x1BED, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x1BDF at 0x1BDA // Inputs[2] // { // @1BDD stack[-3] // @1BDD stack[-2] // } 1BDB 5B JUMPDEST 1BDC 50 POP 1BDD 90 SWAP1 1BDE 56 *JUMP // Stack delta = -2 // Outputs[1] { @1BDD stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1BDF: // Incoming call from 0x1BDA, returns to 0x1BDB // Inputs[2] // { // @1BE3 stack[-2] // @1BE4 stack[-1] // } 1BDF 5B JUMPDEST 1BE0 61 PUSH2 0x0a9a 1BE3 91 SWAP2 1BE4 90 SWAP1 1BE5 5B JUMPDEST 1BE6 80 DUP1 1BE7 82 DUP3 1BE8 11 GT 1BE9 15 ISZERO 1BEA 61 PUSH2 0x1bdb 1BED 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1BE3 stack[-2] = 0x0a9a // @1BE4 stack[-1] = stack[-2] // @1BE4 stack[0] = stack[-1] // } // Block ends with conditional call to 0x1bdb, returns to 0x0A9A, if !(stack[-2] > stack[-1]) label_1BEE: // Incoming jump from 0x1BED, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1BED, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1BF0 stack[-1] } 1BEE 60 PUSH1 0x00 1BF0 81 DUP2 1BF1 55 SSTORE 1BF2 60 PUSH1 0x01 1BF4 01 ADD 1BF5 61 PUSH2 0x1be5 1BF8 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1BF1 storage[stack[-1]] = 0x00 // @1BF4 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1be5 label_1BF9: // Incoming jump from 0x1E5A // Incoming jump from 0x2009 // Incoming jump from 0x1F1E // Incoming jump from 0x1FD7 // Incoming jump from 0x1DF8 // Incoming jump from 0x1E17 // Incoming jump from 0x1FA7 // Inputs[2] // { // @1BFA stack[-1] // @1BFB msg.data[stack[-1]:stack[-1] + 0x20] // } 1BF9 5B JUMPDEST 1BFA 80 DUP1 1BFB 35 CALLDATALOAD 1BFC 61 PUSH2 0x040f 1BFF 81 DUP2 1C00 61 PUSH2 0x2d14 1C03 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1BFB stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1BFC stack[1] = 0x040f // @1BFF stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2d14 label_1C04: // Incoming call from 0x206D, returns to 0x206E // Incoming call from 0x2097, returns to 0x2098 // Inputs[2] // { // @1C08 stack[-2] // @1C0B stack[-1] // } 1C04 5B JUMPDEST 1C05 60 PUSH1 0x00 1C07 80 DUP1 1C08 83 DUP4 1C09 60 PUSH1 0x1f 1C0B 84 DUP5 1C0C 01 ADD 1C0D 12 SLT 1C0E 61 PUSH2 0x1c16 1C11 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C05 stack[0] = 0x00 // @1C07 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1c16, if stack[-1] + 0x1f i< stack[-2] label_1C12: // Incoming jump from 0x1C11, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1C15 memory[0x00:0x00] } 1C12 60 PUSH1 0x00 1C14 80 DUP1 1C15 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C15 revert(memory[0x00:0x00]); } // Block terminates label_1C16: // Incoming jump from 0x1C11, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1C18 stack[-3] // @1C19 msg.data[stack[-3]:stack[-3] + 0x20] // } 1C16 5B JUMPDEST 1C17 50 POP 1C18 81 DUP2 1C19 35 CALLDATALOAD 1C1A 60 PUSH1 0x01 1C1C 60 PUSH1 0x01 1C1E 60 PUSH1 0x40 1C20 1B SHL 1C21 03 SUB 1C22 81 DUP2 1C23 11 GT 1C24 15 ISZERO 1C25 61 PUSH2 0x1c2d 1C28 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1C19 stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x1c2d, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_1C29: // Incoming jump from 0x1C28, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @1C2C memory[0x00:0x00] } 1C29 60 PUSH1 0x00 1C2B 80 DUP1 1C2C FD *REVERT // Stack delta = +0 // Outputs[1] { @1C2C revert(memory[0x00:0x00]); } // Block terminates label_1C2D: // Incoming jump from 0x1C28, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[4] // { // @1C30 stack[-3] // @1C32 stack[-2] // @1C34 stack[-4] // @1C37 stack[-1] // } 1C2D 5B JUMPDEST 1C2E 60 PUSH1 0x20 1C30 83 DUP4 1C31 01 ADD 1C32 91 SWAP2 1C33 50 POP 1C34 83 DUP4 1C35 60 PUSH1 0x20 1C37 82 DUP3 1C38 02 MUL 1C39 83 DUP4 1C3A 01 ADD 1C3B 11 GT 1C3C 15 ISZERO 1C3D 61 PUSH2 0x1c45 1C40 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1C32 stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x1c45, if !(stack[-3] + 0x20 + stack[-1] * 0x20 > stack[-4]) label_1C41: // Incoming jump from 0x1C40, if not !(stack[-3] + 0x20 + stack[-1] * 0x20 > stack[-4]) // Inputs[1] { @1C44 memory[0x00:0x00] } 1C41 60 PUSH1 0x00 1C43 80 DUP1 1C44 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C44 revert(memory[0x00:0x00]); } // Block terminates label_1C45: // Incoming jump from 0x1C40, if !(stack[-3] + 0x20 + stack[-1] * 0x20 > stack[-4]) // Inputs[5] // { // @1C46 stack[-1] // @1C46 stack[-4] // @1C48 stack[-2] // @1C48 stack[-5] // @1C49 stack[-3] // } 1C45 5B JUMPDEST 1C46 92 SWAP3 1C47 50 POP 1C48 92 SWAP3 1C49 90 SWAP1 1C4A 50 POP 1C4B 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1C46 stack[-4] = stack[-1] // @1C48 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] 1C4C 5B JUMPDEST 1C4D 60 PUSH1 0x00 1C4F 82 DUP3 1C50 60 PUSH1 0x1f 1C52 83 DUP4 1C53 01 ADD 1C54 12 SLT 1C55 61 PUSH2 0x1c5d 1C58 57 *JUMPI 1C59 60 PUSH1 0x00 1C5B 80 DUP1 1C5C FD *REVERT 1C5D 5B JUMPDEST 1C5E 81 DUP2 1C5F 35 CALLDATALOAD 1C60 61 PUSH2 0x1c70 1C63 61 PUSH2 0x1c6b 1C66 82 DUP3 1C67 61 PUSH2 0x2c23 1C6A 56 *JUMP label_1C6B: // Incoming return from call to 0x2C43 at 0x1D58 1C6B 5B JUMPDEST 1C6C 61 PUSH2 0x2bfd 1C6F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2bfd 1C70 5B JUMPDEST 1C71 91 SWAP2 1C72 50 POP 1C73 81 DUP2 1C74 81 DUP2 1C75 83 DUP4 1C76 52 MSTORE 1C77 60 PUSH1 0x20 1C79 84 DUP5 1C7A 01 ADD 1C7B 93 SWAP4 1C7C 50 POP 1C7D 60 PUSH1 0x20 1C7F 81 DUP2 1C80 01 ADD 1C81 90 SWAP1 1C82 50 POP 1C83 83 DUP4 1C84 85 DUP6 1C85 60 PUSH1 0x40 1C87 84 DUP5 1C88 02 MUL 1C89 82 DUP3 1C8A 01 ADD 1C8B 11 GT 1C8C 15 ISZERO 1C8D 61 PUSH2 0x1c95 1C90 57 *JUMPI 1C91 60 PUSH1 0x00 1C93 80 DUP1 1C94 FD *REVERT 1C95 5B JUMPDEST 1C96 60 PUSH1 0x00 1C98 5B JUMPDEST 1C99 83 DUP4 1C9A 81 DUP2 1C9B 10 LT 1C9C 15 ISZERO 1C9D 61 PUSH2 0x1cc3 1CA0 57 *JUMPI 1CA1 81 DUP2 1CA2 61 PUSH2 0x1cab 1CA5 88 DUP9 1CA6 82 DUP3 1CA7 61 PUSH2 0x1d89 1CAA 56 *JUMP 1CAB 5B JUMPDEST 1CAC 84 DUP5 1CAD 52 MSTORE 1CAE 50 POP 1CAF 60 PUSH1 0x20 1CB1 90 SWAP1 1CB2 92 SWAP3 1CB3 01 ADD 1CB4 91 SWAP2 1CB5 60 PUSH1 0x40 1CB7 91 SWAP2 1CB8 90 SWAP1 1CB9 91 SWAP2 1CBA 01 ADD 1CBB 90 SWAP1 1CBC 60 PUSH1 0x01 1CBE 01 ADD 1CBF 61 PUSH2 0x1c98 1CC2 56 *JUMP 1CC3 5B JUMPDEST 1CC4 50 POP 1CC5 50 POP 1CC6 50 POP 1CC7 50 POP 1CC8 92 SWAP3 1CC9 91 SWAP2 1CCA 50 POP 1CCB 50 POP 1CCC 56 *JUMP 1CCD 5B JUMPDEST 1CCE 80 DUP1 1CCF 35 CALLDATALOAD 1CD0 61 PUSH2 0x040f 1CD3 81 DUP2 1CD4 61 PUSH2 0x2d28 1CD7 56 *JUMP label_1CD8: // Incoming jump from 0x2150 // Incoming jump from 0x2177 // Incoming jump from 0x2131 // Inputs[2] // { // @1CD9 stack[-1] // @1CDA msg.data[stack[-1]:stack[-1] + 0x20] // } 1CD8 5B JUMPDEST 1CD9 80 DUP1 1CDA 35 CALLDATALOAD 1CDB 61 PUSH2 0x040f 1CDE 81 DUP2 1CDF 61 PUSH2 0x2d31 1CE2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1CDA stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1CDB stack[1] = 0x040f // @1CDE stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2d31, returns to 0x040F label_1CE3: // Incoming jump from 0x20C1 // Inputs[2] // { // @1CE4 stack[-1] // @1CE5 msg.data[stack[-1]:stack[-1] + 0x20] // } 1CE3 5B JUMPDEST 1CE4 80 DUP1 1CE5 35 CALLDATALOAD 1CE6 61 PUSH2 0x040f 1CE9 81 DUP2 1CEA 61 PUSH2 0x2d3a 1CED 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1CE5 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1CE6 stack[1] = 0x040f // @1CE9 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2d3a, returns to 0x040F 1CEE 5B JUMPDEST 1CEF 80 DUP1 1CF0 51 MLOAD 1CF1 61 PUSH2 0x040f 1CF4 81 DUP2 1CF5 61 PUSH2 0x2d3a 1CF8 56 *JUMP 1CF9 5B JUMPDEST 1CFA 60 PUSH1 0x00 1CFC 80 DUP1 1CFD 83 DUP4 1CFE 60 PUSH1 0x1f 1D00 84 DUP5 1D01 01 ADD 1D02 12 SLT 1D03 61 PUSH2 0x1d0b 1D06 57 *JUMPI 1D07 60 PUSH1 0x00 1D09 80 DUP1 1D0A FD *REVERT 1D0B 5B JUMPDEST 1D0C 50 POP 1D0D 81 DUP2 1D0E 35 CALLDATALOAD 1D0F 60 PUSH1 0x01 1D11 60 PUSH1 0x01 1D13 60 PUSH1 0x40 1D15 1B SHL 1D16 03 SUB 1D17 81 DUP2 1D18 11 GT 1D19 15 ISZERO 1D1A 61 PUSH2 0x1d22 1D1D 57 *JUMPI 1D1E 60 PUSH1 0x00 1D20 80 DUP1 1D21 FD *REVERT 1D22 5B JUMPDEST 1D23 60 PUSH1 0x20 1D25 83 DUP4 1D26 01 ADD 1D27 91 SWAP2 1D28 50 POP 1D29 83 DUP4 1D2A 60 PUSH1 0x01 1D2C 82 DUP3 1D2D 02 MUL 1D2E 83 DUP4 1D2F 01 ADD 1D30 11 GT 1D31 15 ISZERO 1D32 61 PUSH2 0x1c45 1D35 57 *JUMPI 1D36 60 PUSH1 0x00 1D38 80 DUP1 1D39 FD *REVERT label_1D3A: // Incoming call from 0x2113, returns to 0x1382 // Inputs[2] // { // @1D3D stack[-2] // @1D40 stack[-1] // } 1D3A 5B JUMPDEST 1D3B 60 PUSH1 0x00 1D3D 82 DUP3 1D3E 60 PUSH1 0x1f 1D40 83 DUP4 1D41 01 ADD 1D42 12 SLT 1D43 61 PUSH2 0x1d4b 1D46 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D3B stack[0] = 0x00 } // Block ends with conditional jump to 0x1d4b, if stack[-1] + 0x1f i< stack[-2] label_1D47: // Incoming jump from 0x1D46, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1D4A memory[0x00:0x00] } 1D47 60 PUSH1 0x00 1D49 80 DUP1 1D4A FD *REVERT // Stack delta = +0 // Outputs[1] { @1D4A revert(memory[0x00:0x00]); } // Block terminates label_1D4B: // Incoming jump from 0x1D46, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1D4C stack[-2] // @1D4D msg.data[stack[-2]:stack[-2] + 0x20] // } 1D4B 5B JUMPDEST 1D4C 81 DUP2 1D4D 35 CALLDATALOAD 1D4E 61 PUSH2 0x1d59 1D51 61 PUSH2 0x1c6b 1D54 82 DUP3 1D55 61 PUSH2 0x2c43 1D58 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D4D stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1D4E stack[1] = 0x1d59 // @1D51 stack[2] = 0x1c6b // @1D54 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2c43, returns to 0x1C6B label_1D59: // Incoming return from call to 0x1C6B at 0x1D58 // Inputs[5] // { // @1D5A stack[-1] // @1D5A stack[-3] // @1D5C stack[-2] // @1D61 stack[-4] // @1D67 stack[-5] // } 1D59 5B JUMPDEST 1D5A 91 SWAP2 1D5B 50 POP 1D5C 80 DUP1 1D5D 82 DUP3 1D5E 52 MSTORE 1D5F 60 PUSH1 0x20 1D61 83 DUP4 1D62 01 ADD 1D63 60 PUSH1 0x20 1D65 83 DUP4 1D66 01 ADD 1D67 85 DUP6 1D68 83 DUP4 1D69 83 DUP4 1D6A 01 ADD 1D6B 11 GT 1D6C 15 ISZERO 1D6D 61 PUSH2 0x1d75 1D70 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1D5A stack[-3] = stack[-1] // @1D5E memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @1D62 stack[-1] = stack[-4] + 0x20 // @1D66 stack[0] = stack[-1] + 0x20 // } // Block ends with conditional jump to 0x1d75, if !(stack[-4] + 0x20 + stack[-2] > stack[-5]) label_1D71: // Incoming jump from 0x1D70, if not !(stack[-4] + 0x20 + stack[-2] > stack[-5]) // Inputs[1] { @1D74 memory[0x00:0x00] } 1D71 60 PUSH1 0x00 1D73 80 DUP1 1D74 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D74 revert(memory[0x00:0x00]); } // Block terminates label_1D75: // Incoming jump from 0x1D70, if !(stack[-4] + 0x20 + stack[-2] > stack[-5]) // Inputs[3] // { // @1D79 stack[-3] // @1D7A stack[-1] // @1D7B stack[-2] // } 1D75 5B JUMPDEST 1D76 61 PUSH2 0x1d80 1D79 83 DUP4 1D7A 82 DUP3 1D7B 84 DUP5 1D7C 61 PUSH2 0x2cb7 1D7F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D76 stack[0] = 0x1d80 // @1D79 stack[1] = stack[-3] // @1D7A stack[2] = stack[-1] // @1D7B stack[3] = stack[-2] // } // Block ends with call to 0x2cb7, returns to 0x1D80 label_1D80: // Incoming return from call to 0x2CB7 at 0x1D7F // Inputs[3] // { // @1D84 stack[-7] // @1D84 stack[-4] // @1D85 stack[-6] // } 1D80 5B JUMPDEST 1D81 50 POP 1D82 50 POP 1D83 50 POP 1D84 92 SWAP3 1D85 91 SWAP2 1D86 50 POP 1D87 50 POP 1D88 56 *JUMP // Stack delta = -6 // Outputs[1] { @1D84 stack[-7] = stack[-4] } // Block ends with unconditional jump to stack[-7] 1D89 5B JUMPDEST 1D8A 60 PUSH1 0x00 1D8C 60 PUSH1 0x40 1D8E 82 DUP3 1D8F 84 DUP5 1D90 03 SUB 1D91 12 SLT 1D92 15 ISZERO 1D93 61 PUSH2 0x1d9b 1D96 57 *JUMPI 1D97 60 PUSH1 0x00 1D99 80 DUP1 1D9A FD *REVERT 1D9B 5B JUMPDEST 1D9C 61 PUSH2 0x1da5 1D9F 60 PUSH1 0x40 1DA1 61 PUSH2 0x2bfd 1DA4 56 *JUMP 1DA5 5B JUMPDEST 1DA6 90 SWAP1 1DA7 50 POP 1DA8 60 PUSH1 0x00 1DAA 61 PUSH2 0x1db3 1DAD 84 DUP5 1DAE 84 DUP5 1DAF 61 PUSH2 0x1bf9 1DB2 56 *JUMP 1DB3 5B JUMPDEST 1DB4 82 DUP3 1DB5 52 MSTORE 1DB6 50 POP 1DB7 60 PUSH1 0x20 1DB9 61 PUSH2 0x1dc4 1DBC 84 DUP5 1DBD 84 DUP5 1DBE 83 DUP4 1DBF 01 ADD 1DC0 61 PUSH2 0x1cd8 1DC3 56 *JUMP 1DC4 5B JUMPDEST 1DC5 60 PUSH1 0x20 1DC7 83 DUP4 1DC8 01 ADD 1DC9 52 MSTORE 1DCA 50 POP 1DCB 92 SWAP3 1DCC 91 SWAP2 1DCD 50 POP 1DCE 50 POP 1DCF 56 *JUMP 1DD0 5B JUMPDEST 1DD1 80 DUP1 1DD2 35 CALLDATALOAD 1DD3 61 PUSH2 0x040f 1DD6 81 DUP2 1DD7 61 PUSH2 0x2d43 1DDA 56 *JUMP label_1DDB: // Incoming jump from 0x02CA // Incoming jump from 0x097E // Incoming jump from 0x03D2 // Incoming jump from 0x0233 // Incoming jump from 0x03AC // Inputs[2] // { // @1DE0 stack[-1] // @1DE1 stack[-2] // } 1DDB 5B JUMPDEST 1DDC 60 PUSH1 0x00 1DDE 60 PUSH1 0x20 1DE0 82 DUP3 1DE1 84 DUP5 1DE2 03 SUB 1DE3 12 SLT 1DE4 15 ISZERO 1DE5 61 PUSH2 0x1ded 1DE8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DDC stack[0] = 0x00 } // Block ends with conditional jump to 0x1ded, if !(stack[-2] - stack[-1] i< 0x20) label_1DE9: // Incoming jump from 0x1DE8, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1DEC memory[0x00:0x00] } 1DE9 60 PUSH1 0x00 1DEB 80 DUP1 1DEC FD *REVERT // Stack delta = +0 // Outputs[1] { @1DEC revert(memory[0x00:0x00]); } // Block terminates label_1DED: // Incoming jump from 0x1DE8, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1DF3 stack[-3] // @1DF4 stack[-2] // } 1DED 5B JUMPDEST 1DEE 60 PUSH1 0x00 1DF0 61 PUSH2 0x1382 1DF3 84 DUP5 1DF4 84 DUP5 1DF5 61 PUSH2 0x1bf9 1DF8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DEE stack[0] = 0x00 // @1DF0 stack[1] = 0x1382 // @1DF3 stack[2] = stack[-3] // @1DF4 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1bf9 label_1DF9: // Incoming jump from 0x0399 // Inputs[2] // { // @1DFF stack[-1] // @1E00 stack[-2] // } 1DF9 5B JUMPDEST 1DFA 60 PUSH1 0x00 1DFC 80 DUP1 1DFD 60 PUSH1 0x40 1DFF 83 DUP4 1E00 85 DUP6 1E01 03 SUB 1E02 12 SLT 1E03 15 ISZERO 1E04 61 PUSH2 0x1e0c 1E07 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DFA stack[0] = 0x00 // @1DFC stack[1] = 0x00 // } // Block ends with conditional jump to 0x1e0c, if !(stack[-2] - stack[-1] i< 0x40) label_1E08: // Incoming jump from 0x1E07, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1E0B memory[0x00:0x00] } 1E08 60 PUSH1 0x00 1E0A 80 DUP1 1E0B FD *REVERT // Stack delta = +0 // Outputs[1] { @1E0B revert(memory[0x00:0x00]); } // Block terminates label_1E0C: // Incoming jump from 0x1E07, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1E12 stack[-4] // @1E13 stack[-3] // } 1E0C 5B JUMPDEST 1E0D 60 PUSH1 0x00 1E0F 61 PUSH2 0x1e18 1E12 85 DUP6 1E13 85 DUP6 1E14 61 PUSH2 0x1bf9 1E17 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E0D stack[0] = 0x00 // @1E0F stack[1] = 0x1e18 // @1E12 stack[2] = stack[-4] // @1E13 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1bf9 1E18 5B JUMPDEST 1E19 92 SWAP3 1E1A 50 POP 1E1B 50 POP 1E1C 60 PUSH1 0x20 1E1E 61 PUSH2 0x1e29 1E21 85 DUP6 1E22 82 DUP3 1E23 86 DUP7 1E24 01 ADD 1E25 61 PUSH2 0x1bf9 1E28 56 *JUMP 1E29 5B JUMPDEST 1E2A 91 SWAP2 1E2B 50 POP 1E2C 50 POP 1E2D 92 SWAP3 1E2E 50 POP 1E2F 92 SWAP3 1E30 90 SWAP1 1E31 50 POP 1E32 56 *JUMP label_1E33: // Incoming jump from 0x027B // Inputs[2] // { // @1E42 stack[-1] // @1E43 stack[-2] // } 1E33 5B JUMPDEST 1E34 60 PUSH1 0x00 1E36 80 DUP1 1E37 60 PUSH1 0x00 1E39 80 DUP1 1E3A 60 PUSH1 0x00 1E3C 80 DUP1 1E3D 60 PUSH1 0x00 1E3F 80 DUP1 1E40 60 PUSH1 0xa0 1E42 89 DUP10 1E43 8B DUP12 1E44 03 SUB 1E45 12 SLT 1E46 15 ISZERO 1E47 61 PUSH2 0x1e4f 1E4A 57 *JUMPI // Stack delta = +8 // Outputs[8] // { // @1E34 stack[0] = 0x00 // @1E36 stack[1] = 0x00 // @1E37 stack[2] = 0x00 // @1E39 stack[3] = 0x00 // @1E3A stack[4] = 0x00 // @1E3C stack[5] = 0x00 // @1E3D stack[6] = 0x00 // @1E3F stack[7] = 0x00 // } // Block ends with conditional jump to 0x1e4f, if !(stack[-2] - stack[-1] i< 0xa0) label_1E4B: // Incoming jump from 0x1E4A, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @1E4E memory[0x00:0x00] } 1E4B 60 PUSH1 0x00 1E4D 80 DUP1 1E4E FD *REVERT // Stack delta = +0 // Outputs[1] { @1E4E revert(memory[0x00:0x00]); } // Block terminates label_1E4F: // Incoming jump from 0x1E4A, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @1E55 stack[-10] // @1E56 stack[-9] // } 1E4F 5B JUMPDEST 1E50 60 PUSH1 0x00 1E52 61 PUSH2 0x1e5b 1E55 8B DUP12 1E56 8B DUP12 1E57 61 PUSH2 0x1bf9 1E5A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E50 stack[0] = 0x00 // @1E52 stack[1] = 0x1e5b // @1E55 stack[2] = stack[-10] // @1E56 stack[3] = stack[-9] // } // Block ends with unconditional jump to 0x1bf9 1E5B 5B JUMPDEST 1E5C 98 SWAP9 1E5D 50 POP 1E5E 50 POP 1E5F 60 PUSH1 0x20 1E61 61 PUSH2 0x1e6c 1E64 8B DUP12 1E65 82 DUP3 1E66 8C DUP13 1E67 01 ADD 1E68 61 PUSH2 0x1bf9 1E6B 56 *JUMP 1E6C 5B JUMPDEST 1E6D 97 SWAP8 1E6E 50 POP 1E6F 50 POP 1E70 60 PUSH1 0x40 1E72 89 DUP10 1E73 01 ADD 1E74 35 CALLDATALOAD 1E75 60 PUSH1 0x01 1E77 60 PUSH1 0x01 1E79 60 PUSH1 0x40 1E7B 1B SHL 1E7C 03 SUB 1E7D 81 DUP2 1E7E 11 GT 1E7F 15 ISZERO 1E80 61 PUSH2 0x1e88 1E83 57 *JUMPI 1E84 60 PUSH1 0x00 1E86 80 DUP1 1E87 FD *REVERT 1E88 5B JUMPDEST 1E89 61 PUSH2 0x1e94 1E8C 8B DUP12 1E8D 82 DUP3 1E8E 8C DUP13 1E8F 01 ADD 1E90 61 PUSH2 0x1c04 1E93 56 *JUMP 1E94 5B JUMPDEST 1E95 96 SWAP7 1E96 50 POP 1E97 96 SWAP7 1E98 50 POP 1E99 50 POP 1E9A 60 PUSH1 0x60 1E9C 89 DUP10 1E9D 01 ADD 1E9E 35 CALLDATALOAD 1E9F 60 PUSH1 0x01 1EA1 60 PUSH1 0x01 1EA3 60 PUSH1 0x40 1EA5 1B SHL 1EA6 03 SUB 1EA7 81 DUP2 1EA8 11 GT 1EA9 15 ISZERO 1EAA 61 PUSH2 0x1eb2 1EAD 57 *JUMPI 1EAE 60 PUSH1 0x00 1EB0 80 DUP1 1EB1 FD *REVERT 1EB2 5B JUMPDEST 1EB3 61 PUSH2 0x1ebe 1EB6 8B DUP12 1EB7 82 DUP3 1EB8 8C DUP13 1EB9 01 ADD 1EBA 61 PUSH2 0x1c04 1EBD 56 *JUMP 1EBE 5B JUMPDEST 1EBF 94 SWAP5 1EC0 50 POP 1EC1 94 SWAP5 1EC2 50 POP 1EC3 50 POP 1EC4 60 PUSH1 0x80 1EC6 89 DUP10 1EC7 01 ADD 1EC8 35 CALLDATALOAD 1EC9 60 PUSH1 0x01 1ECB 60 PUSH1 0x01 1ECD 60 PUSH1 0x40 1ECF 1B SHL 1ED0 03 SUB 1ED1 81 DUP2 1ED2 11 GT 1ED3 15 ISZERO 1ED4 61 PUSH2 0x1edc 1ED7 57 *JUMPI 1ED8 60 PUSH1 0x00 1EDA 80 DUP1 1EDB FD *REVERT 1EDC 5B JUMPDEST 1EDD 61 PUSH2 0x1ee8 1EE0 8B DUP12 1EE1 82 DUP3 1EE2 8C DUP13 1EE3 01 ADD 1EE4 61 PUSH2 0x1cf9 1EE7 56 *JUMP 1EE8 5B JUMPDEST 1EE9 92 SWAP3 1EEA 50 POP 1EEB 92 SWAP3 1EEC 50 POP 1EED 50 POP 1EEE 92 SWAP3 1EEF 95 SWAP6 1EF0 98 SWAP9 1EF1 50 POP 1EF2 92 SWAP3 1EF3 95 SWAP6 1EF4 98 SWAP9 1EF5 90 SWAP1 1EF6 93 SWAP4 1EF7 96 SWAP7 1EF8 50 POP 1EF9 56 *JUMP label_1EFA: // Incoming jump from 0x03BF // Inputs[2] // { // @1F06 stack[-1] // @1F07 stack[-2] // } 1EFA 5B JUMPDEST 1EFB 60 PUSH1 0x00 1EFD 80 DUP1 1EFE 60 PUSH1 0x00 1F00 80 DUP1 1F01 60 PUSH1 0x00 1F03 80 DUP1 1F04 60 PUSH1 0xa0 1F06 87 DUP8 1F07 89 DUP10 1F08 03 SUB 1F09 12 SLT 1F0A 15 ISZERO 1F0B 61 PUSH2 0x1f13 1F0E 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @1EFB stack[0] = 0x00 // @1EFD stack[1] = 0x00 // @1EFE stack[2] = 0x00 // @1F00 stack[3] = 0x00 // @1F01 stack[4] = 0x00 // @1F03 stack[5] = 0x00 // } // Block ends with conditional jump to 0x1f13, if !(stack[-2] - stack[-1] i< 0xa0) label_1F0F: // Incoming jump from 0x1F0E, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @1F12 memory[0x00:0x00] } 1F0F 60 PUSH1 0x00 1F11 80 DUP1 1F12 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F12 revert(memory[0x00:0x00]); } // Block terminates label_1F13: // Incoming jump from 0x1F0E, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @1F19 stack[-8] // @1F1A stack[-7] // } 1F13 5B JUMPDEST 1F14 60 PUSH1 0x00 1F16 61 PUSH2 0x1f1f 1F19 89 DUP10 1F1A 89 DUP10 1F1B 61 PUSH2 0x1bf9 1F1E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F14 stack[0] = 0x00 // @1F16 stack[1] = 0x1f1f // @1F19 stack[2] = stack[-8] // @1F1A stack[3] = stack[-7] // } // Block ends with unconditional jump to 0x1bf9 1F1F 5B JUMPDEST 1F20 96 SWAP7 1F21 50 POP 1F22 50 POP 1F23 60 PUSH1 0x20 1F25 61 PUSH2 0x1f30 1F28 89 DUP10 1F29 82 DUP3 1F2A 8A DUP11 1F2B 01 ADD 1F2C 61 PUSH2 0x1bf9 1F2F 56 *JUMP 1F30 5B JUMPDEST 1F31 95 SWAP6 1F32 50 POP 1F33 50 POP 1F34 60 PUSH1 0x40 1F36 61 PUSH2 0x1f41 1F39 89 DUP10 1F3A 82 DUP3 1F3B 8A DUP11 1F3C 01 ADD 1F3D 61 PUSH2 0x1cd8 1F40 56 *JUMP 1F41 5B JUMPDEST 1F42 94 SWAP5 1F43 50 POP 1F44 50 POP 1F45 60 PUSH1 0x60 1F47 61 PUSH2 0x1f52 1F4A 89 DUP10 1F4B 82 DUP3 1F4C 8A DUP11 1F4D 01 ADD 1F4E 61 PUSH2 0x1cd8 1F51 56 *JUMP 1F52 5B JUMPDEST 1F53 93 SWAP4 1F54 50 POP 1F55 50 POP 1F56 60 PUSH1 0x80 1F58 87 DUP8 1F59 01 ADD 1F5A 35 CALLDATALOAD 1F5B 60 PUSH1 0x01 1F5D 60 PUSH1 0x01 1F5F 60 PUSH1 0x40 1F61 1B SHL 1F62 03 SUB 1F63 81 DUP2 1F64 11 GT 1F65 15 ISZERO 1F66 61 PUSH2 0x1f6e 1F69 57 *JUMPI 1F6A 60 PUSH1 0x00 1F6C 80 DUP1 1F6D FD *REVERT 1F6E 5B JUMPDEST 1F6F 61 PUSH2 0x1f7a 1F72 89 DUP10 1F73 82 DUP3 1F74 8A DUP11 1F75 01 ADD 1F76 61 PUSH2 0x1cf9 1F79 56 *JUMP 1F7A 5B JUMPDEST 1F7B 92 SWAP3 1F7C 50 POP 1F7D 92 SWAP3 1F7E 50 POP 1F7F 50 POP 1F80 92 SWAP3 1F81 95 SWAP6 1F82 50 POP 1F83 92 SWAP3 1F84 95 SWAP6 1F85 50 POP 1F86 92 SWAP3 1F87 95 SWAP6 1F88 56 *JUMP label_1F89: // Incoming jump from 0x0328 // Inputs[2] // { // @1F8F stack[-1] // @1F90 stack[-2] // } 1F89 5B JUMPDEST 1F8A 60 PUSH1 0x00 1F8C 80 DUP1 1F8D 60 PUSH1 0x40 1F8F 83 DUP4 1F90 85 DUP6 1F91 03 SUB 1F92 12 SLT 1F93 15 ISZERO 1F94 61 PUSH2 0x1f9c 1F97 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1F8A stack[0] = 0x00 // @1F8C stack[1] = 0x00 // } // Block ends with conditional jump to 0x1f9c, if !(stack[-2] - stack[-1] i< 0x40) label_1F98: // Incoming jump from 0x1F97, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1F9B memory[0x00:0x00] } 1F98 60 PUSH1 0x00 1F9A 80 DUP1 1F9B FD *REVERT // Stack delta = +0 // Outputs[1] { @1F9B revert(memory[0x00:0x00]); } // Block terminates label_1F9C: // Incoming jump from 0x1F97, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1FA2 stack[-4] // @1FA3 stack[-3] // } 1F9C 5B JUMPDEST 1F9D 60 PUSH1 0x00 1F9F 61 PUSH2 0x1fa8 1FA2 85 DUP6 1FA3 85 DUP6 1FA4 61 PUSH2 0x1bf9 1FA7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F9D stack[0] = 0x00 // @1F9F stack[1] = 0x1fa8 // @1FA2 stack[2] = stack[-4] // @1FA3 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1bf9 1FA8 5B JUMPDEST 1FA9 92 SWAP3 1FAA 50 POP 1FAB 50 POP 1FAC 60 PUSH1 0x20 1FAE 61 PUSH2 0x1e29 1FB1 85 DUP6 1FB2 82 DUP3 1FB3 86 DUP7 1FB4 01 ADD 1FB5 61 PUSH2 0x1ccd 1FB8 56 *JUMP label_1FB9: // Incoming jump from 0x01D5 // Inputs[2] // { // @1FBF stack[-1] // @1FC0 stack[-2] // } 1FB9 5B JUMPDEST 1FBA 60 PUSH1 0x00 1FBC 80 DUP1 1FBD 60 PUSH1 0x40 1FBF 83 DUP4 1FC0 85 DUP6 1FC1 03 SUB 1FC2 12 SLT 1FC3 15 ISZERO 1FC4 61 PUSH2 0x1fcc 1FC7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1FBA stack[0] = 0x00 // @1FBC stack[1] = 0x00 // } // Block ends with conditional jump to 0x1fcc, if !(stack[-2] - stack[-1] i< 0x40) label_1FC8: // Incoming jump from 0x1FC7, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1FCB memory[0x00:0x00] } 1FC8 60 PUSH1 0x00 1FCA 80 DUP1 1FCB FD *REVERT // Stack delta = +0 // Outputs[1] { @1FCB revert(memory[0x00:0x00]); } // Block terminates label_1FCC: // Incoming jump from 0x1FC7, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1FD2 stack[-4] // @1FD3 stack[-3] // } 1FCC 5B JUMPDEST 1FCD 60 PUSH1 0x00 1FCF 61 PUSH2 0x1fd8 1FD2 85 DUP6 1FD3 85 DUP6 1FD4 61 PUSH2 0x1bf9 1FD7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1FCD stack[0] = 0x00 // @1FCF stack[1] = 0x1fd8 // @1FD2 stack[2] = stack[-4] // @1FD3 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1bf9 1FD8 5B JUMPDEST 1FD9 92 SWAP3 1FDA 50 POP 1FDB 50 POP 1FDC 60 PUSH1 0x20 1FDE 61 PUSH2 0x1e29 1FE1 85 DUP6 1FE2 82 DUP3 1FE3 86 DUP7 1FE4 01 ADD 1FE5 61 PUSH2 0x1cd8 1FE8 56 *JUMP label_1FE9: // Incoming jump from 0x03E5 // Inputs[2] // { // @1FF1 stack[-1] // @1FF2 stack[-2] // } 1FE9 5B JUMPDEST 1FEA 60 PUSH1 0x00 1FEC 80 DUP1 1FED 60 PUSH1 0x00 1FEF 60 PUSH1 0x60 1FF1 84 DUP5 1FF2 86 DUP7 1FF3 03 SUB 1FF4 12 SLT 1FF5 15 ISZERO 1FF6 61 PUSH2 0x1ffe 1FF9 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1FEA stack[0] = 0x00 // @1FEC stack[1] = 0x00 // @1FED stack[2] = 0x00 // } // Block ends with conditional jump to 0x1ffe, if !(stack[-2] - stack[-1] i< 0x60) label_1FFA: // Incoming jump from 0x1FF9, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1FFD memory[0x00:0x00] } 1FFA 60 PUSH1 0x00 1FFC 80 DUP1 1FFD FD *REVERT // Stack delta = +0 // Outputs[1] { @1FFD revert(memory[0x00:0x00]); } // Block terminates label_1FFE: // Incoming jump from 0x1FF9, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @2004 stack[-5] // @2005 stack[-4] // } 1FFE 5B JUMPDEST 1FFF 60 PUSH1 0x00 2001 61 PUSH2 0x200a 2004 86 DUP7 2005 86 DUP7 2006 61 PUSH2 0x1bf9 2009 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1FFF stack[0] = 0x00 // @2001 stack[1] = 0x200a // @2004 stack[2] = stack[-5] // @2005 stack[3] = stack[-4] // } // Block ends with unconditional jump to 0x1bf9 200A 5B JUMPDEST 200B 93 SWAP4 200C 50 POP 200D 50 POP 200E 60 PUSH1 0x20 2010 61 PUSH2 0x201b 2013 86 DUP7 2014 82 DUP3 2015 87 DUP8 2016 01 ADD 2017 61 PUSH2 0x1cd8 201A 56 *JUMP 201B 5B JUMPDEST 201C 92 SWAP3 201D 50 POP 201E 50 POP 201F 60 PUSH1 0x40 2021 61 PUSH2 0x202c 2024 86 DUP7 2025 82 DUP3 2026 87 DUP8 2027 01 ADD 2028 61 PUSH2 0x1cd8 202B 56 *JUMP 202C 5B JUMPDEST 202D 91 SWAP2 202E 50 POP 202F 50 POP 2030 92 SWAP3 2031 50 POP 2032 92 SWAP3 2033 50 POP 2034 92 SWAP3 2035 56 *JUMP label_2036: // Incoming call from 0x028E, returns to 0x028F // Inputs[2] // { // @203F stack[-1] // @2040 stack[-2] // } 2036 5B JUMPDEST 2037 60 PUSH1 0x00 2039 80 DUP1 203A 60 PUSH1 0x00 203C 80 DUP1 203D 60 PUSH1 0x40 203F 85 DUP6 2040 87 DUP8 2041 03 SUB 2042 12 SLT 2043 15 ISZERO 2044 61 PUSH2 0x204c 2047 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2037 stack[0] = 0x00 // @2039 stack[1] = 0x00 // @203A stack[2] = 0x00 // @203C stack[3] = 0x00 // } // Block ends with conditional jump to 0x204c, if !(stack[-2] - stack[-1] i< 0x40) label_2048: // Incoming jump from 0x2047, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @204B memory[0x00:0x00] } 2048 60 PUSH1 0x00 204A 80 DUP1 204B FD *REVERT // Stack delta = +0 // Outputs[1] { @204B revert(memory[0x00:0x00]); } // Block terminates label_204C: // Incoming jump from 0x2047, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @204D stack[-5] // @204E msg.data[stack[-5]:stack[-5] + 0x20] // } 204C 5B JUMPDEST 204D 84 DUP5 204E 35 CALLDATALOAD 204F 60 PUSH1 0x01 2051 60 PUSH1 0x01 2053 60 PUSH1 0x40 2055 1B SHL 2056 03 SUB 2057 81 DUP2 2058 11 GT 2059 15 ISZERO 205A 61 PUSH2 0x2062 205D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @204E stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] } // Block ends with conditional jump to 0x2062, if !(msg.data[stack[-5]:stack[-5] + 0x20] > (0x01 << 0x40) - 0x01) label_205E: // Incoming jump from 0x205D, if not !(msg.data[stack[-5]:stack[-5] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2061 memory[0x00:0x00] } 205E 60 PUSH1 0x00 2060 80 DUP1 2061 FD *REVERT // Stack delta = +0 // Outputs[1] { @2061 revert(memory[0x00:0x00]); } // Block terminates label_2062: // Incoming jump from 0x205D, if !(msg.data[stack[-5]:stack[-5] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2066 stack[-7] // @2067 stack[-1] // @2068 stack[-6] // } 2062 5B JUMPDEST 2063 61 PUSH2 0x206e 2066 87 DUP8 2067 82 DUP3 2068 88 DUP9 2069 01 ADD 206A 61 PUSH2 0x1c04 206D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2063 stack[0] = 0x206e // @2066 stack[1] = stack[-7] // @2069 stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x1c04, returns to 0x206E label_206E: // Incoming return from call to 0x1C04 at 0x206D // Inputs[6] // { // @206F stack[-6] // @206F stack[-1] // @2071 stack[-7] // @2071 stack[-2] // @2076 stack[-8] // @2078 msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // } 206E 5B JUMPDEST 206F 94 SWAP5 2070 50 POP 2071 94 SWAP5 2072 50 POP 2073 50 POP 2074 60 PUSH1 0x20 2076 85 DUP6 2077 01 ADD 2078 35 CALLDATALOAD 2079 60 PUSH1 0x01 207B 60 PUSH1 0x01 207D 60 PUSH1 0x40 207F 1B SHL 2080 03 SUB 2081 81 DUP2 2082 11 GT 2083 15 ISZERO 2084 61 PUSH2 0x208c 2087 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @206F stack[-6] = stack[-1] // @2071 stack[-7] = stack[-2] // @2078 stack[-3] = msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x208c, if !(msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) label_2088: // Incoming jump from 0x2087, if not !(msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @208B memory[0x00:0x00] } 2088 60 PUSH1 0x00 208A 80 DUP1 208B FD *REVERT // Stack delta = +0 // Outputs[1] { @208B revert(memory[0x00:0x00]); } // Block terminates label_208C: // Incoming jump from 0x2087, if !(msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2090 stack[-7] // @2091 stack[-1] // @2092 stack[-6] // } 208C 5B JUMPDEST 208D 61 PUSH2 0x2098 2090 87 DUP8 2091 82 DUP3 2092 88 DUP9 2093 01 ADD 2094 61 PUSH2 0x1c04 2097 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @208D stack[0] = 0x2098 // @2090 stack[1] = stack[-7] // @2093 stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x1c04, returns to 0x2098 label_2098: // Incoming return from call to 0x1C04 at 0x2097 // Inputs[7] // { // @2099 stack[-1] // @2099 stack[-7] // @209A stack[-10] // @209B stack[-6] // @209C stack[-9] // @209E stack[-8] // @209E stack[-2] // } 2098 5B JUMPDEST 2099 95 SWAP6 209A 98 SWAP9 209B 94 SWAP5 209C 97 SWAP8 209D 50 POP 209E 95 SWAP6 209F 50 POP 20A0 50 POP 20A1 50 POP 20A2 50 POP 20A3 56 *JUMP // Stack delta = -6 // Outputs[4] // { // @2099 stack[-7] = stack[-1] // @209A stack[-10] = stack[-7] // @209C stack[-9] = stack[-6] // @209E stack[-8] = stack[-2] // } // Block ends with unconditional jump to stack[-10] label_20A4: // Incoming jump from 0x01FE // Inputs[2] // { // @20A9 stack[-1] // @20AA stack[-2] // } 20A4 5B JUMPDEST 20A5 60 PUSH1 0x00 20A7 60 PUSH1 0x20 20A9 82 DUP3 20AA 84 DUP5 20AB 03 SUB 20AC 12 SLT 20AD 15 ISZERO 20AE 61 PUSH2 0x20b6 20B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20A5 stack[0] = 0x00 } // Block ends with conditional jump to 0x20b6, if !(stack[-2] - stack[-1] i< 0x20) label_20B2: // Incoming jump from 0x20B1, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @20B5 memory[0x00:0x00] } 20B2 60 PUSH1 0x00 20B4 80 DUP1 20B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @20B5 revert(memory[0x00:0x00]); } // Block terminates label_20B6: // Incoming jump from 0x20B1, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @20BC stack[-3] // @20BD stack[-2] // } 20B6 5B JUMPDEST 20B7 60 PUSH1 0x00 20B9 61 PUSH2 0x1382 20BC 84 DUP5 20BD 84 DUP5 20BE 61 PUSH2 0x1ce3 20C1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @20B7 stack[0] = 0x00 // @20B9 stack[1] = 0x1382 // @20BC stack[2] = stack[-3] // @20BD stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1ce3 20C2 5B JUMPDEST 20C3 60 PUSH1 0x00 20C5 60 PUSH1 0x20 20C7 82 DUP3 20C8 84 DUP5 20C9 03 SUB 20CA 12 SLT 20CB 15 ISZERO 20CC 61 PUSH2 0x20d4 20CF 57 *JUMPI 20D0 60 PUSH1 0x00 20D2 80 DUP1 20D3 FD *REVERT 20D4 5B JUMPDEST 20D5 60 PUSH1 0x00 20D7 61 PUSH2 0x1382 20DA 84 DUP5 20DB 84 DUP5 20DC 61 PUSH2 0x1cee 20DF 56 *JUMP label_20E0: // Incoming call from 0x0315, returns to 0x0316 // Incoming call from 0x02FA, returns to 0x02FB // Inputs[2] // { // @20E5 stack[-1] // @20E6 stack[-2] // } 20E0 5B JUMPDEST 20E1 60 PUSH1 0x00 20E3 60 PUSH1 0x20 20E5 82 DUP3 20E6 84 DUP5 20E7 03 SUB 20E8 12 SLT 20E9 15 ISZERO 20EA 61 PUSH2 0x20f2 20ED 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20E1 stack[0] = 0x00 } // Block ends with conditional jump to 0x20f2, if !(stack[-2] - stack[-1] i< 0x20) label_20EE: // Incoming jump from 0x20ED, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @20F1 memory[0x00:0x00] } 20EE 60 PUSH1 0x00 20F0 80 DUP1 20F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @20F1 revert(memory[0x00:0x00]); } // Block terminates label_20F2: // Incoming jump from 0x20ED, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @20F3 stack[-2] // @20F4 msg.data[stack[-2]:stack[-2] + 0x20] // } 20F2 5B JUMPDEST 20F3 81 DUP2 20F4 35 CALLDATALOAD 20F5 60 PUSH1 0x01 20F7 60 PUSH1 0x01 20F9 60 PUSH1 0x40 20FB 1B SHL 20FC 03 SUB 20FD 81 DUP2 20FE 11 GT 20FF 15 ISZERO 2100 61 PUSH2 0x2108 2103 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20F4 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2108, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_2104: // Incoming jump from 0x2103, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2107 memory[0x00:0x00] } 2104 60 PUSH1 0x00 2106 80 DUP1 2107 FD *REVERT // Stack delta = +0 // Outputs[1] { @2107 revert(memory[0x00:0x00]); } // Block terminates label_2108: // Incoming jump from 0x2103, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @210C stack[-4] // @210D stack[-1] // @210E stack[-3] // } 2108 5B JUMPDEST 2109 61 PUSH2 0x1382 210C 84 DUP5 210D 82 DUP3 210E 85 DUP6 210F 01 ADD 2110 61 PUSH2 0x1d3a 2113 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2109 stack[0] = 0x1382 // @210C stack[1] = stack[-4] // @210F stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x1d3a, returns to 0x1382 label_2114: // Incoming jump from 0x025B // Incoming jump from 0x033B // Incoming jump from 0x0376 // Incoming jump from 0x0248 // Inputs[2] // { // @2119 stack[-1] // @211A stack[-2] // } 2114 5B JUMPDEST 2115 60 PUSH1 0x00 2117 60 PUSH1 0x20 2119 82 DUP3 211A 84 DUP5 211B 03 SUB 211C 12 SLT 211D 15 ISZERO 211E 61 PUSH2 0x2126 2121 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2115 stack[0] = 0x00 } // Block ends with conditional jump to 0x2126, if !(stack[-2] - stack[-1] i< 0x20) label_2122: // Incoming jump from 0x2121, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2125 memory[0x00:0x00] } 2122 60 PUSH1 0x00 2124 80 DUP1 2125 FD *REVERT // Stack delta = +0 // Outputs[1] { @2125 revert(memory[0x00:0x00]); } // Block terminates label_2126: // Incoming jump from 0x2121, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @212C stack[-3] // @212D stack[-2] // } 2126 5B JUMPDEST 2127 60 PUSH1 0x00 2129 61 PUSH2 0x1382 212C 84 DUP5 212D 84 DUP5 212E 61 PUSH2 0x1cd8 2131 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2127 stack[0] = 0x00 // @2129 stack[1] = 0x1382 // @212C stack[2] = stack[-3] // @212D stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1cd8 label_2132: // Incoming jump from 0x02A1 // Inputs[2] // { // @2138 stack[-1] // @2139 stack[-2] // } 2132 5B JUMPDEST 2133 60 PUSH1 0x00 2135 80 DUP1 2136 60 PUSH1 0x40 2138 83 DUP4 2139 85 DUP6 213A 03 SUB 213B 12 SLT 213C 15 ISZERO 213D 61 PUSH2 0x2145 2140 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2133 stack[0] = 0x00 // @2135 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2145, if !(stack[-2] - stack[-1] i< 0x40) label_2141: // Incoming jump from 0x2140, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2144 memory[0x00:0x00] } 2141 60 PUSH1 0x00 2143 80 DUP1 2144 FD *REVERT // Stack delta = +0 // Outputs[1] { @2144 revert(memory[0x00:0x00]); } // Block terminates label_2145: // Incoming jump from 0x2140, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @214B stack[-4] // @214C stack[-3] // } 2145 5B JUMPDEST 2146 60 PUSH1 0x00 2148 61 PUSH2 0x1fd8 214B 85 DUP6 214C 85 DUP6 214D 61 PUSH2 0x1cd8 2150 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2146 stack[0] = 0x00 // @2148 stack[1] = 0x1fd8 // @214B stack[2] = stack[-4] // @214C stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1cd8 label_2151: // Incoming jump from 0x0363 // Inputs[2] // { // @215F stack[-1] // @2160 stack[-2] // } 2151 5B JUMPDEST 2152 60 PUSH1 0x00 2154 80 DUP1 2155 60 PUSH1 0x00 2157 80 DUP1 2158 60 PUSH1 0x00 215A 80 DUP1 215B 60 PUSH1 0x00 215D 60 PUSH1 0xe0 215F 88 DUP9 2160 8A DUP11 2161 03 SUB 2162 12 SLT 2163 15 ISZERO 2164 61 PUSH2 0x216c 2167 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @2152 stack[0] = 0x00 // @2154 stack[1] = 0x00 // @2155 stack[2] = 0x00 // @2157 stack[3] = 0x00 // @2158 stack[4] = 0x00 // @215A stack[5] = 0x00 // @215B stack[6] = 0x00 // } // Block ends with conditional jump to 0x216c, if !(stack[-2] - stack[-1] i< 0xe0) label_2168: // Incoming jump from 0x2167, if not !(stack[-2] - stack[-1] i< 0xe0) // Inputs[1] { @216B memory[0x00:0x00] } 2168 60 PUSH1 0x00 216A 80 DUP1 216B FD *REVERT // Stack delta = +0 // Outputs[1] { @216B revert(memory[0x00:0x00]); } // Block terminates label_216C: // Incoming jump from 0x2167, if !(stack[-2] - stack[-1] i< 0xe0) // Inputs[2] // { // @2172 stack[-9] // @2173 stack[-8] // } 216C 5B JUMPDEST 216D 60 PUSH1 0x00 216F 61 PUSH2 0x2178 2172 8A DUP11 2173 8A DUP11 2174 61 PUSH2 0x1cd8 2177 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @216D stack[0] = 0x00 // @216F stack[1] = 0x2178 // @2172 stack[2] = stack[-9] // @2173 stack[3] = stack[-8] // } // Block ends with unconditional jump to 0x1cd8 2178 5B JUMPDEST 2179 97 SWAP8 217A 50 POP 217B 50 POP 217C 60 PUSH1 0x20 217E 61 PUSH2 0x2189 2181 8A DUP11 2182 82 DUP3 2183 8B DUP12 2184 01 ADD 2185 61 PUSH2 0x1dd0 2188 56 *JUMP 2189 5B JUMPDEST 218A 96 SWAP7 218B 50 POP 218C 50 POP 218D 60 PUSH1 0x40 218F 61 PUSH2 0x219a 2192 8A DUP11 2193 82 DUP3 2194 8B DUP12 2195 01 ADD 2196 61 PUSH2 0x1cd8 2199 56 *JUMP 219A 5B JUMPDEST 219B 95 SWAP6 219C 50 POP 219D 50 POP 219E 60 PUSH1 0x60 21A0 61 PUSH2 0x21ab 21A3 8A DUP11 21A4 82 DUP3 21A5 8B DUP12 21A6 01 ADD 21A7 61 PUSH2 0x1cd8 21AA 56 *JUMP 21AB 5B JUMPDEST 21AC 94 SWAP5 21AD 50 POP 21AE 50 POP 21AF 60 PUSH1 0x80 21B1 88 DUP9 21B2 01 ADD 21B3 35 CALLDATALOAD 21B4 60 PUSH1 0x01 21B6 60 PUSH1 0x01 21B8 60 PUSH1 0x40 21BA 1B SHL 21BB 03 SUB 21BC 81 DUP2 21BD 11 GT 21BE 15 ISZERO 21BF 61 PUSH2 0x21c7 21C2 57 *JUMPI 21C3 60 PUSH1 0x00 21C5 80 DUP1 21C6 FD *REVERT 21C7 5B JUMPDEST 21C8 61 PUSH2 0x21d3 21CB 8A DUP11 21CC 82 DUP3 21CD 8B DUP12 21CE 01 ADD 21CF 61 PUSH2 0x1c4c 21D2 56 *JUMP 21D3 5B JUMPDEST 21D4 93 SWAP4 21D5 50 POP 21D6 50 POP 21D7 60 PUSH1 0xa0 21D9 61 PUSH2 0x21e4 21DC 8A DUP11 21DD 82 DUP3 21DE 8B DUP12 21DF 01 ADD 21E0 61 PUSH2 0x1cd8 21E3 56 *JUMP 21E4 5B JUMPDEST 21E5 92 SWAP3 21E6 50 POP 21E7 50 POP 21E8 60 PUSH1 0xc0 21EA 88 DUP9 21EB 01 ADD 21EC 35 CALLDATALOAD 21ED 60 PUSH1 0x01 21EF 60 PUSH1 0x01 21F1 60 PUSH1 0x40 21F3 1B SHL 21F4 03 SUB 21F5 81 DUP2 21F6 11 GT 21F7 15 ISZERO 21F8 61 PUSH2 0x2200 21FB 57 *JUMPI 21FC 60 PUSH1 0x00 21FE 80 DUP1 21FF FD *REVERT 2200 5B JUMPDEST 2201 61 PUSH2 0x220c 2204 8A DUP11 2205 82 DUP3 2206 8B DUP12 2207 01 ADD 2208 61 PUSH2 0x1d3a 220B 56 *JUMP 220C 5B JUMPDEST 220D 91 SWAP2 220E 50 POP 220F 50 POP 2210 92 SWAP3 2211 95 SWAP6 2212 98 SWAP9 2213 91 SWAP2 2214 94 SWAP5 2215 97 SWAP8 2216 50 POP 2217 92 SWAP3 2218 95 SWAP6 2219 50 POP 221A 56 *JUMP 221B 5B JUMPDEST 221C 60 PUSH1 0x00 221E 61 PUSH2 0x2227 2221 83 DUP4 2222 83 DUP4 2223 61 PUSH2 0x223b 2226 56 *JUMP 2227 5B JUMPDEST 2228 50 POP 2229 50 POP 222A 60 PUSH1 0x20 222C 01 ADD 222D 90 SWAP1 222E 56 *JUMP label_222F: // Incoming jump from 0x2361 // Inputs[2] // { // @2235 stack[-2] // @2236 stack[-1] // } 222F 5B JUMPDEST 2230 60 PUSH1 0x00 2232 61 PUSH2 0x2227 2235 83 DUP4 2236 83 DUP4 2237 61 PUSH2 0x2381 223A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2230 stack[0] = 0x00 // @2232 stack[1] = 0x2227 // @2235 stack[2] = stack[-2] // @2236 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x2381 label_223B: // Incoming call from 0x2903, returns to 0x040F // Inputs[1] { @223F stack[-1] } 223B 5B JUMPDEST 223C 61 PUSH2 0x2244 223F 81 DUP2 2240 61 PUSH2 0x2c7d 2243 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @223C stack[0] = 0x2244 // @223F stack[1] = stack[-1] // } // Block ends with call to 0x2c7d, returns to 0x2244 label_2244: // Incoming return from call to 0x2C7D at 0x2243 // Incoming return from call to 0x2C88 at 0x2380 // Incoming return from call to 0x0A9A at 0x2389 // Inputs[3] // { // @2245 stack[-3] // @2246 stack[-1] // @2249 stack[-4] // } 2244 5B JUMPDEST 2245 82 DUP3 2246 52 MSTORE 2247 50 POP 2248 50 POP 2249 56 *JUMP // Stack delta = -4 // Outputs[1] { @2246 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] 224A 5B JUMPDEST 224B 60 PUSH1 0x00 224D 61 PUSH2 0x2255 2250 82 DUP3 2251 61 PUSH2 0x2c70 2254 56 *JUMP 2255 5B JUMPDEST 2256 61 PUSH2 0x225f 2259 81 DUP2 225A 85 DUP6 225B 61 PUSH2 0x2c74 225E 56 *JUMP 225F 5B JUMPDEST 2260 93 SWAP4 2261 50 POP 2262 61 PUSH2 0x226a 2265 83 DUP4 2266 61 PUSH2 0x2c6a 2269 56 *JUMP 226A 5B JUMPDEST 226B 80 DUP1 226C 60 PUSH1 0x00 226E 5B JUMPDEST 226F 83 DUP4 2270 81 DUP2 2271 10 LT 2272 15 ISZERO 2273 61 PUSH2 0x2298 2276 57 *JUMPI 2277 81 DUP2 2278 51 MLOAD 2279 61 PUSH2 0x2282 227C 88 DUP9 227D 82 DUP3 227E 61 PUSH2 0x221b 2281 56 *JUMP 2282 5B JUMPDEST 2283 97 SWAP8 2284 50 POP 2285 61 PUSH2 0x228d 2288 83 DUP4 2289 61 PUSH2 0x2c6a 228C 56 *JUMP 228D 5B JUMPDEST 228E 92 SWAP3 228F 50 POP 2290 50 POP 2291 60 PUSH1 0x01 2293 01 ADD 2294 61 PUSH2 0x226e 2297 56 *JUMP label_2298: // Incoming jump from 0x2356, if !(0x00 < stack[-2]) // Inputs[3] // { // @229A stack[-7] // @229A stack[-2] // @229B stack[-8] // } 2298 5B JUMPDEST 2299 50 POP 229A 94 SWAP5 229B 95 SWAP6 229C 94 SWAP5 229D 50 POP 229E 50 POP 229F 50 POP 22A0 50 POP 22A1 50 POP 22A2 56 *JUMP // Stack delta = -7 // Outputs[1] { @229B stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] 22A3 5B JUMPDEST 22A4 60 PUSH1 0x00 22A6 61 PUSH2 0x22ae 22A9 82 DUP3 22AA 61 PUSH2 0x2c70 22AD 56 *JUMP 22AE 5B JUMPDEST 22AF 61 PUSH2 0x22b8 22B2 81 DUP2 22B3 85 DUP6 22B4 61 PUSH2 0x2c74 22B7 56 *JUMP 22B8 5B JUMPDEST 22B9 93 SWAP4 22BA 50 POP 22BB 61 PUSH2 0x22c3 22BE 83 DUP4 22BF 61 PUSH2 0x2c6a 22C2 56 *JUMP 22C3 5B JUMPDEST 22C4 80 DUP1 22C5 60 PUSH1 0x00 22C7 5B JUMPDEST 22C8 83 DUP4 22C9 81 DUP2 22CA 10 LT 22CB 15 ISZERO 22CC 61 PUSH2 0x2298 22CF 57 *JUMPI 22D0 81 DUP2 22D1 51 MLOAD 22D2 61 PUSH2 0x22db 22D5 88 DUP9 22D6 82 DUP3 22D7 61 PUSH2 0x221b 22DA 56 *JUMP 22DB 5B JUMPDEST 22DC 97 SWAP8 22DD 50 POP 22DE 61 PUSH2 0x22e6 22E1 83 DUP4 22E2 61 PUSH2 0x2c6a 22E5 56 *JUMP 22E6 5B JUMPDEST 22E7 92 SWAP3 22E8 50 POP 22E9 50 POP 22EA 60 PUSH1 0x01 22EC 01 ADD 22ED 61 PUSH2 0x22c7 22F0 56 *JUMP 22F1 5B JUMPDEST 22F2 60 PUSH1 0x00 22F4 61 PUSH2 0x22fd 22F7 83 DUP4 22F8 85 DUP6 22F9 61 PUSH2 0x2c74 22FC 56 *JUMP 22FD 5B JUMPDEST 22FE 93 SWAP4 22FF 50 POP 2300 60 PUSH1 0x01 2302 60 PUSH1 0x01 2304 60 PUSH1 0xfb 2306 1B SHL 2307 03 SUB 2308 83 DUP4 2309 11 GT 230A 15 ISZERO 230B 61 PUSH2 0x2313 230E 57 *JUMPI 230F 60 PUSH1 0x00 2311 80 DUP1 2312 FD *REVERT 2313 5B JUMPDEST 2314 60 PUSH1 0x20 2316 83 DUP4 2317 02 MUL 2318 92 SWAP3 2319 50 POP 231A 61 PUSH2 0x2324 231D 83 DUP4 231E 85 DUP6 231F 84 DUP5 2320 61 PUSH2 0x2cb7 2323 56 *JUMP 2324 5B JUMPDEST 2325 50 POP 2326 50 POP 2327 01 ADD 2328 90 SWAP1 2329 56 *JUMP label_232A: // Incoming call from 0x2A1F, returns to 0x291F // Inputs[1] { @2330 stack[-1] } 232A 5B JUMPDEST 232B 60 PUSH1 0x00 232D 61 PUSH2 0x2335 2330 82 DUP3 2331 61 PUSH2 0x2c70 2334 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @232B stack[0] = 0x00 // @232D stack[1] = 0x2335 // @2330 stack[2] = stack[-1] // } // Block ends with call to 0x2c70, returns to 0x2335 label_2335: // Incoming return from call to 0x2C70 at 0x2334 // Inputs[2] // { // @2339 stack[-1] // @233A stack[-4] // } 2335 5B JUMPDEST 2336 61 PUSH2 0x233f 2339 81 DUP2 233A 85 DUP6 233B 61 PUSH2 0x2c74 233E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2336 stack[0] = 0x233f // @2339 stack[1] = stack[-1] // @233A stack[2] = stack[-4] // } // Block ends with call to 0x2c74, returns to 0x233F label_233F: // Incoming return from call to 0x2C74 at 0x233E // Inputs[3] // { // @2340 stack[-5] // @2340 stack[-1] // @2345 stack[-4] // } 233F 5B JUMPDEST 2340 93 SWAP4 2341 50 POP 2342 61 PUSH2 0x234a 2345 83 DUP4 2346 61 PUSH2 0x2c6a 2349 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2340 stack[-5] = stack[-1] // @2342 stack[-1] = 0x234a // @2345 stack[0] = stack[-4] // } // Block ends with call to 0x2c6a, returns to 0x234A label_234A: // Incoming return from call to 0x2C6A at 0x2349 // Inputs[2] // { // @234B stack[-1] // @234F stack[-2] // } 234A 5B JUMPDEST 234B 80 DUP1 234C 60 PUSH1 0x00 234E 5B JUMPDEST 234F 83 DUP4 2350 81 DUP2 2351 10 LT 2352 15 ISZERO 2353 61 PUSH2 0x2298 2356 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @234B stack[0] = stack[-1] // @234C stack[1] = 0x00 // } // Block ends with conditional jump to 0x2298, if !(0x00 < stack[-2]) label_2357: // Incoming jump from 0x2356, if not !(0x00 < stack[-2]) // Inputs[3] // { // @2357 stack[-2] // @2358 memory[stack[-2]:stack[-2] + 0x20] // @235C stack[-7] // } 2357 81 DUP2 2358 51 MLOAD 2359 61 PUSH2 0x2362 235C 88 DUP9 235D 82 DUP3 235E 61 PUSH2 0x222f 2361 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2358 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2359 stack[1] = 0x2362 // @235C stack[2] = stack[-7] // @235D stack[3] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x222f 2362 5B JUMPDEST 2363 97 SWAP8 2364 50 POP 2365 61 PUSH2 0x236d 2368 83 DUP4 2369 61 PUSH2 0x2c6a 236C 56 *JUMP 236D 5B JUMPDEST 236E 92 SWAP3 236F 50 POP 2370 50 POP 2371 60 PUSH1 0x01 2373 01 ADD 2374 61 PUSH2 0x234e 2377 56 *JUMP label_2378: // Incoming jump from 0x2A2D // Inputs[1] { @237C stack[-1] } 2378 5B JUMPDEST 2379 61 PUSH2 0x2244 237C 81 DUP2 237D 61 PUSH2 0x2c88 2380 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2379 stack[0] = 0x2244 // @237C stack[1] = stack[-1] // } // Block ends with call to 0x2c88, returns to 0x2244 label_2381: // Incoming jump from 0x223A // Inputs[1] { @2385 stack[-1] } 2381 5B JUMPDEST 2382 61 PUSH2 0x2244 2385 81 DUP2 2386 61 PUSH2 0x0a9a 2389 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2382 stack[0] = 0x2244 // @2385 stack[1] = stack[-1] // } // Block ends with call to 0x0a9a, returns to 0x2244 label_238A: // Incoming call from 0x2A7C, returns to 0x291F // Inputs[1] { @2390 stack[-1] } 238A 5B JUMPDEST 238B 60 PUSH1 0x00 238D 61 PUSH2 0x2395 2390 82 DUP3 2391 61 PUSH2 0x2c70 2394 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @238B stack[0] = 0x00 // @238D stack[1] = 0x2395 // @2390 stack[2] = stack[-1] // } // Block ends with call to 0x2c70, returns to 0x2395 label_2395: // Incoming return from call to 0x2C70 at 0x2394 // Inputs[2] // { // @2399 stack[-1] // @239A stack[-4] // } 2395 5B JUMPDEST 2396 61 PUSH2 0x239f 2399 81 DUP2 239A 85 DUP6 239B 61 PUSH2 0x2c74 239E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2396 stack[0] = 0x239f // @2399 stack[1] = stack[-1] // @239A stack[2] = stack[-4] // } // Block ends with call to 0x2c74, returns to 0x239F label_239F: // Incoming return from call to 0x2C74 at 0x239E // Inputs[4] // { // @23A0 stack[-1] // @23A0 stack[-5] // @23A5 stack[-2] // @23A9 stack[-4] // } 239F 5B JUMPDEST 23A0 93 SWAP4 23A1 50 POP 23A2 61 PUSH2 0x23af 23A5 81 DUP2 23A6 85 DUP6 23A7 60 PUSH1 0x20 23A9 86 DUP7 23AA 01 ADD 23AB 61 PUSH2 0x2cc3 23AE 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @23A0 stack[-5] = stack[-1] // @23A2 stack[-1] = 0x23af // @23A5 stack[0] = stack[-2] // @23A6 stack[1] = stack[-1] // @23AA stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x2cc3, returns to 0x23AF label_23AF: // Incoming return from call to 0x2CC3 at 0x23AE // Inputs[1] { @23B3 stack[-1] } 23AF 5B JUMPDEST 23B0 61 PUSH2 0x23b8 23B3 81 DUP2 23B4 61 PUSH2 0x2d04 23B7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23B0 stack[0] = 0x23b8 // @23B3 stack[1] = stack[-1] // } // Block ends with call to 0x2d04, returns to 0x23B8 label_23B8: // Incoming return from call to 0x2D04 at 0x23B7 // Inputs[4] // { // @23B9 stack[-2] // @23B9 stack[-1] // @23BA stack[-5] // @23BC stack[-6] // } 23B8 5B JUMPDEST 23B9 90 SWAP1 23BA 93 SWAP4 23BB 01 ADD 23BC 93 SWAP4 23BD 92 SWAP3 23BE 50 POP 23BF 50 POP 23C0 50 POP 23C1 56 *JUMP // Stack delta = -5 // Outputs[1] { @23BC stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] 23C2 5B JUMPDEST 23C3 61 PUSH2 0x2244 23C6 61 PUSH2 0x23ce 23C9 82 DUP3 23CA 61 PUSH2 0x2cac 23CD 56 *JUMP 23CE 5B JUMPDEST 23CF 61 PUSH2 0x2cf3 23D2 56 *JUMP 23D3 5B JUMPDEST 23D4 60 PUSH1 0x00 23D6 61 PUSH2 0x23e0 23D9 60 PUSH1 0x1c 23DB 83 DUP4 23DC 61 PUSH2 0x2c74 23DF 56 *JUMP 23E0 5B JUMPDEST 23E1 7F PUSH32 0x4665652076616c75652073686f756c6420626520706f73697469766500000000 2402 81 DUP2 2403 52 MSTORE 2404 60 PUSH1 0x20 2406 01 ADD 2407 92 SWAP3 2408 91 SWAP2 2409 50 POP 240A 50 POP 240B 56 *JUMP 240C 5B JUMPDEST 240D 60 PUSH1 0x00 240F 61 PUSH2 0x2419 2412 60 PUSH1 0x1f 2414 83 DUP4 2415 61 PUSH2 0x2c74 2418 56 *JUMP 2419 5B JUMPDEST 241A 7F PUSH32 0x526f6c65733a206163636f756e7420616c72656164792068617320726f6c6500 243B 81 DUP2 243C 52 MSTORE 243D 60 PUSH1 0x20 243F 01 ADD 2440 92 SWAP3 2441 91 SWAP2 2442 50 POP 2443 50 POP 2444 56 *JUMP 2445 5B JUMPDEST 2446 60 PUSH1 0x00 2448 61 PUSH2 0x2452 244B 60 PUSH1 0x26 244D 83 DUP4 244E 61 PUSH2 0x2c74 2451 56 *JUMP 2452 5B JUMPDEST 2453 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 2474 81 DUP2 2475 52 MSTORE 2476 65 PUSH6 0x646472657373 247D 60 PUSH1 0xd0 247F 1B SHL 2480 60 PUSH1 0x20 2482 82 DUP3 2483 01 ADD 2484 52 MSTORE 2485 60 PUSH1 0x40 2487 01 ADD 2488 92 SWAP3 2489 91 SWAP2 248A 50 POP 248B 50 POP 248C 56 *JUMP 248D 5B JUMPDEST 248E 60 PUSH1 0x00 2490 61 PUSH2 0x249a 2493 60 PUSH1 0x20 2495 83 DUP4 2496 61 PUSH2 0x2c74 2499 56 *JUMP 249A 5B JUMPDEST 249B 7F PUSH32 0x5f736574546f6b656e5552493a20546f6b656e2073686f756c64206578697374 24BC 81 DUP2 24BD 52 MSTORE 24BE 60 PUSH1 0x20 24C0 01 ADD 24C1 92 SWAP3 24C2 91 SWAP2 24C3 50 POP 24C4 50 POP 24C5 56 *JUMP 24C6 5B JUMPDEST 24C7 60 PUSH1 0x00 24C9 61 PUSH2 0x24d3 24CC 60 PUSH1 0x25 24CE 83 DUP4 24CF 61 PUSH2 0x2c74 24D2 56 *JUMP 24D3 5B JUMPDEST 24D4 7F PUSH32 0x64657374696e6174696f6e2061646472657373206d757374206265206e6f6e2d 24F5 81 DUP2 24F6 52 MSTORE 24F7 64 PUSH5 0x3d32b93797 24FD 60 PUSH1 0xd9 24FF 1B SHL 2500 60 PUSH1 0x20 2502 82 DUP3 2503 01 ADD 2504 52 MSTORE 2505 60 PUSH1 0x40 2507 01 ADD 2508 92 SWAP3 2509 91 SWAP2 250A 50 POP 250B 50 POP 250C 56 *JUMP label_250D: // Incoming call from 0x2ADC, returns to 0x040F // Inputs[1] { @2515 stack[-1] } 250D 5B JUMPDEST 250E 60 PUSH1 0x00 2510 61 PUSH2 0x251a 2513 60 PUSH1 0x21 2515 83 DUP4 2516 61 PUSH2 0x2c74 2519 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @250E stack[0] = 0x00 // @2510 stack[1] = 0x251a // @2513 stack[2] = 0x21 // @2515 stack[3] = stack[-1] // } // Block ends with call to 0x2c74, returns to 0x251A label_251A: // Incoming return from call to 0x2C74 at 0x2519 // Inputs[3] // { // @253C stack[-1] // @254B stack[-4] // @254C stack[-3] // } 251A 5B JUMPDEST 251B 7F PUSH32 0x526f6c65733a206163636f756e7420646f6573206e6f74206861766520726f6c 253C 81 DUP2 253D 52 MSTORE 253E 60 PUSH1 0x65 2540 60 PUSH1 0xf8 2542 1B SHL 2543 60 PUSH1 0x20 2545 82 DUP3 2546 01 ADD 2547 52 MSTORE 2548 60 PUSH1 0x40 254A 01 ADD 254B 92 SWAP3 254C 91 SWAP2 254D 50 POP 254E 50 POP 254F 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @253D memory[stack[-1]:stack[-1] + 0x20] = 0x526f6c65733a206163636f756e7420646f6573206e6f74206861766520726f6c // @2547 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x65 << 0xf8 // @254B stack[-4] = 0x40 + stack[-1] // } // Block ends with unconditional jump to stack[-4] 2550 5B JUMPDEST 2551 60 PUSH1 0x00 2553 61 PUSH2 0x255d 2556 60 PUSH1 0x2b 2558 83 DUP4 2559 61 PUSH2 0x2c74 255C 56 *JUMP 255D 5B JUMPDEST 255E 7F PUSH32 0x4e656564206f70657261746f7220617070726f76616c20666f72203372642070 257F 81 DUP2 2580 52 MSTORE 2581 6A PUSH11 0x30b93a3c90313ab9373997 258D 60 PUSH1 0xa9 258F 1B SHL 2590 60 PUSH1 0x20 2592 82 DUP3 2593 01 ADD 2594 52 MSTORE 2595 60 PUSH1 0x40 2597 01 ADD 2598 92 SWAP3 2599 91 SWAP2 259A 50 POP 259B 50 POP 259C 56 *JUMP 259D 5B JUMPDEST 259E 60 PUSH1 0x00 25A0 61 PUSH2 0x25aa 25A3 60 PUSH1 0x2f 25A5 83 DUP4 25A6 61 PUSH2 0x2c74 25A9 56 *JUMP 25AA 5B JUMPDEST 25AB 7F PUSH32 0x4e656564206f70657261746f7220617070726f76616c20666f72203372642070 25CC 81 DUP2 25CD 52 MSTORE 25CE 6E PUSH15 0x30b93a3c903a3930b739b332b93997 25DE 60 PUSH1 0x89 25E0 1B SHL 25E1 60 PUSH1 0x20 25E3 82 DUP3 25E4 01 ADD 25E5 52 MSTORE 25E6 60 PUSH1 0x40 25E8 01 ADD 25E9 92 SWAP3 25EA 91 SWAP2 25EB 50 POP 25EC 50 POP 25ED 56 *JUMP 25EE 5B JUMPDEST 25EF 60 PUSH1 0x00 25F1 61 PUSH2 0x25fb 25F4 60 PUSH1 0x3e 25F6 83 DUP4 25F7 61 PUSH2 0x2c74 25FA 56 *JUMP 25FB 5B JUMPDEST 25FC 7F PUSH32 0x636f6e74726163742072657475726e656420616e20756e6b6e6f776e2076616c 261D 81 DUP2 261E 52 MSTORE 261F 7F PUSH32 0x75652066726f6d206f6e45524331313535426174636852656365697665640000 2640 60 PUSH1 0x20 2642 82 DUP3 2643 01 ADD 2644 52 MSTORE 2645 60 PUSH1 0x40 2647 01 ADD 2648 92 SWAP3 2649 91 SWAP2 264A 50 POP 264B 50 POP 264C 56 *JUMP label_264D: // Incoming call from 0x2B1C, returns to 0x040F // Inputs[1] { @2655 stack[-1] } 264D 5B JUMPDEST 264E 60 PUSH1 0x00 2650 61 PUSH2 0x265a 2653 60 PUSH1 0x20 2655 83 DUP4 2656 61 PUSH2 0x2c74 2659 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @264E stack[0] = 0x00 // @2650 stack[1] = 0x265a // @2653 stack[2] = 0x20 // @2655 stack[3] = stack[-1] // } // Block ends with call to 0x2c74, returns to 0x265A label_265A: // Incoming return from call to 0x2C74 at 0x2659 // Inputs[3] // { // @267C stack[-1] // @2681 stack[-4] // @2682 stack[-3] // } 265A 5B JUMPDEST 265B 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 267C 81 DUP2 267D 52 MSTORE 267E 60 PUSH1 0x20 2680 01 ADD 2681 92 SWAP3 2682 91 SWAP2 2683 50 POP 2684 50 POP 2685 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @267D memory[stack[-1]:stack[-1] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @2681 stack[-4] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-4] label_2686: // Incoming call from 0x2B2C, returns to 0x040F // Inputs[1] { @268E stack[-1] } 2686 5B JUMPDEST 2687 60 PUSH1 0x00 2689 61 PUSH2 0x2693 268C 60 PUSH1 0x22 268E 83 DUP4 268F 61 PUSH2 0x2c74 2692 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2687 stack[0] = 0x00 // @2689 stack[1] = 0x2693 // @268C stack[2] = 0x22 // @268E stack[3] = stack[-1] // } // Block ends with call to 0x2c74, returns to 0x2693 label_2693: // Incoming return from call to 0x2C74 at 0x2692 // Inputs[3] // { // @26B5 stack[-1] // @26C5 stack[-4] // @26C6 stack[-3] // } 2693 5B JUMPDEST 2694 7F PUSH32 0x526f6c65733a206163636f756e7420697320746865207a65726f206164647265 26B5 81 DUP2 26B6 52 MSTORE 26B7 61 PUSH2 0x7373 26BA 60 PUSH1 0xf0 26BC 1B SHL 26BD 60 PUSH1 0x20 26BF 82 DUP3 26C0 01 ADD 26C1 52 MSTORE 26C2 60 PUSH1 0x40 26C4 01 ADD 26C5 92 SWAP3 26C6 91 SWAP2 26C7 50 POP 26C8 50 POP 26C9 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @26B6 memory[stack[-1]:stack[-1] + 0x20] = 0x526f6c65733a206163636f756e7420697320746865207a65726f206164647265 // @26C1 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x7373 << 0xf0 // @26C5 stack[-4] = 0x40 + stack[-1] // } // Block ends with unconditional jump to stack[-4] 26CA 5B JUMPDEST 26CB 60 PUSH1 0x00 26CD 61 PUSH2 0x26d7 26D0 60 PUSH1 0x17 26D2 83 DUP4 26D3 61 PUSH2 0x2c74 26D6 56 *JUMP 26D7 5B JUMPDEST 26D8 7F PUSH32 0x546f6b656e20697320616c7265616479206d696e746564000000000000000000 26F9 81 DUP2 26FA 52 MSTORE 26FB 60 PUSH1 0x20 26FD 01 ADD 26FE 92 SWAP3 26FF 91 SWAP2 2700 50 POP 2701 50 POP 2702 56 *JUMP 2703 5B JUMPDEST 2704 60 PUSH1 0x00 2706 61 PUSH2 0x2710 2709 60 PUSH1 0x19 270B 83 DUP4 270C 61 PUSH2 0x2c74 270F 56 *JUMP 2710 5B JUMPDEST 2711 7F PUSH32 0x537570706c792073686f756c6420626520706f73697469766500000000000000 2732 81 DUP2 2733 52 MSTORE 2734 60 PUSH1 0x20 2736 01 ADD 2737 92 SWAP3 2738 91 SWAP2 2739 50 POP 273A 50 POP 273B 56 *JUMP 273C 5B JUMPDEST 273D 60 PUSH1 0x00 273F 61 PUSH2 0x2749 2742 60 PUSH1 0x29 2744 83 DUP4 2745 61 PUSH2 0x2c74 2748 56 *JUMP 2749 5B JUMPDEST 274A 7F PUSH32 0x5f69647320616e64205f76616c756573206172726179206c656e676874206d75 276B 81 DUP2 276C 52 MSTORE 276D 68 PUSH9 0x39ba1036b0ba31b417 2777 60 PUSH1 0xb9 2779 1B SHL 277A 60 PUSH1 0x20 277C 82 DUP3 277D 01 ADD 277E 52 MSTORE 277F 60 PUSH1 0x40 2781 01 ADD 2782 92 SWAP3 2783 91 SWAP2 2784 50 POP 2785 50 POP 2786 56 *JUMP 2787 5B JUMPDEST 2788 60 PUSH1 0x00 278A 61 PUSH2 0x2794 278D 60 PUSH1 0x1b 278F 83 DUP4 2790 61 PUSH2 0x2c74 2793 56 *JUMP 2794 5B JUMPDEST 2795 7F PUSH32 0x526563697069656e742073686f756c642062652070726573656e740000000000 27B6 81 DUP2 27B7 52 MSTORE 27B8 60 PUSH1 0x20 27BA 01 ADD 27BB 92 SWAP3 27BC 91 SWAP2 27BD 50 POP 27BE 50 POP 27BF 56 *JUMP 27C0 5B JUMPDEST 27C1 60 PUSH1 0x00 27C3 61 PUSH2 0x27cd 27C6 60 PUSH1 0x39 27C8 83 DUP4 27C9 61 PUSH2 0x2c74 27CC 56 *JUMP 27CD 5B JUMPDEST 27CE 7F PUSH32 0x636f6e74726163742072657475726e656420616e20756e6b6e6f776e2076616c 27EF 81 DUP2 27F0 52 MSTORE 27F1 7F PUSH32 0x75652066726f6d206f6e45524331313535526563656976656400000000000000 2812 60 PUSH1 0x20 2814 82 DUP3 2815 01 ADD 2816 52 MSTORE 2817 60 PUSH1 0x40 2819 01 ADD 281A 92 SWAP3 281B 91 SWAP2 281C 50 POP 281D 50 POP 281E 56 *JUMP 281F 5B JUMPDEST 2820 60 PUSH1 0x00 2822 61 PUSH2 0x282c 2825 60 PUSH1 0x15 2827 83 DUP4 2828 61 PUSH2 0x2c74 282B 56 *JUMP 282C 5B JUMPDEST 282D 74 PUSH21 0x2fba379036bab9ba103132903737b716bd32b93797 2843 60 PUSH1 0x59 2845 1B SHL 2846 81 DUP2 2847 52 MSTORE 2848 60 PUSH1 0x20 284A 01 ADD 284B 92 SWAP3 284C 91 SWAP2 284D 50 POP 284E 50 POP 284F 56 *JUMP 2850 5B JUMPDEST 2851 60 PUSH1 0x00 2853 61 PUSH2 0x285d 2856 60 PUSH1 0x1a 2858 83 DUP4 2859 61 PUSH2 0x2c74 285C 56 *JUMP 285D 5B JUMPDEST 285E 7F PUSH32 0x7369676e65722073686f756c64207369676e20746f6b656e4964000000000000 287F 81 DUP2 2880 52 MSTORE 2881 60 PUSH1 0x20 2883 01 ADD 2884 92 SWAP3 2885 91 SWAP2 2886 50 POP 2887 50 POP 2888 56 *JUMP 2889 5B JUMPDEST 288A 60 PUSH1 0x00 288C 61 PUSH2 0x2896 288F 60 PUSH1 0x11 2891 83 DUP4 2892 61 PUSH2 0x2c74 2895 56 *JUMP 2896 5B JUMPDEST 2897 70 PUSH17 0x1d5c9a481cda1bdd5b19081899481cd95d 28A9 60 PUSH1 0x7a 28AB 1B SHL 28AC 81 DUP2 28AD 52 MSTORE 28AE 60 PUSH1 0x20 28B0 01 ADD 28B1 92 SWAP3 28B2 91 SWAP2 28B3 50 POP 28B4 50 POP 28B5 56 *JUMP 28B6 5B JUMPDEST 28B7 61 PUSH2 0x2244 28BA 61 PUSH2 0x28c2 28BD 82 DUP3 28BE 61 PUSH2 0x0a9a 28C1 56 *JUMP 28C2 5B JUMPDEST 28C3 61 PUSH2 0x0a9a 28C6 56 *JUMP 28C7 5B JUMPDEST 28C8 61 PUSH2 0x2244 28CB 81 DUP2 28CC 61 PUSH2 0x2ca6 28CF 56 *JUMP 28D0 5B JUMPDEST 28D1 60 PUSH1 0x00 28D3 61 PUSH2 0x28dc 28D6 82 DUP3 28D7 85 DUP6 28D8 61 PUSH2 0x23c2 28DB 56 *JUMP 28DC 5B JUMPDEST 28DD 60 PUSH1 0x14 28DF 82 DUP3 28E0 01 ADD 28E1 91 SWAP2 28E2 50 POP 28E3 61 PUSH2 0x28ec 28E6 82 DUP3 28E7 84 DUP5 28E8 61 PUSH2 0x28b6 28EB 56 *JUMP 28EC 5B JUMPDEST 28ED 50 POP 28EE 60 PUSH1 0x20 28F0 01 ADD 28F1 92 SWAP3 28F2 91 SWAP2 28F3 50 POP 28F4 50 POP 28F5 56 *JUMP label_28F6: // Incoming jump from 0x02E4 // Inputs[2] // { // @28F9 stack[-1] // @28FF stack[-2] // } 28F6 5B JUMPDEST 28F7 60 PUSH1 0x20 28F9 81 DUP2 28FA 01 ADD 28FB 61 PUSH2 0x040f 28FE 82 DUP3 28FF 84 DUP5 2900 61 PUSH2 0x223b 2903 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @28FA stack[0] = stack[-1] + 0x20 // @28FB stack[1] = 0x040f // @28FE stack[2] = stack[-1] // @28FF stack[3] = stack[-2] // } // Block ends with call to 0x223b, returns to 0x040F 2904 5B JUMPDEST 2905 60 PUSH1 0x40 2907 81 DUP2 2908 01 ADD 2909 61 PUSH2 0x2912 290C 82 DUP3 290D 85 DUP6 290E 61 PUSH2 0x223b 2911 56 *JUMP 2912 5B JUMPDEST 2913 61 PUSH2 0x291f 2916 60 PUSH1 0x20 2918 83 DUP4 2919 01 ADD 291A 84 DUP5 291B 61 PUSH2 0x2381 291E 56 *JUMP label_291F: // Incoming return from call to 0x232A at 0x2A1F // Incoming return from call to 0x238A at 0x2A7C // Inputs[3] // { // @2920 stack[-5] // @2920 stack[-1] // @2921 stack[-4] // } 291F 5B JUMPDEST 2920 93 SWAP4 2921 92 SWAP3 2922 50 POP 2923 50 POP 2924 50 POP 2925 56 *JUMP // Stack delta = -4 // Outputs[1] { @2920 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] 2926 5B JUMPDEST 2927 60 PUSH1 0xa0 2929 81 DUP2 292A 01 ADD 292B 61 PUSH2 0x2934 292E 82 DUP3 292F 88 DUP9 2930 61 PUSH2 0x223b 2933 56 *JUMP 2934 5B JUMPDEST 2935 61 PUSH2 0x2941 2938 60 PUSH1 0x20 293A 83 DUP4 293B 01 ADD 293C 87 DUP8 293D 61 PUSH2 0x223b 2940 56 *JUMP 2941 5B JUMPDEST 2942 81 DUP2 2943 81 DUP2 2944 03 SUB 2945 60 PUSH1 0x40 2947 83 DUP4 2948 01 ADD 2949 52 MSTORE 294A 61 PUSH2 0x2953 294D 81 DUP2 294E 86 DUP7 294F 61 PUSH2 0x232a 2952 56 *JUMP 2953 5B JUMPDEST 2954 90 SWAP1 2955 50 POP 2956 81 DUP2 2957 81 DUP2 2958 03 SUB 2959 60 PUSH1 0x60 295B 83 DUP4 295C 01 ADD 295D 52 MSTORE 295E 61 PUSH2 0x2967 2961 81 DUP2 2962 85 DUP6 2963 61 PUSH2 0x232a 2966 56 *JUMP 2967 5B JUMPDEST 2968 90 SWAP1 2969 50 POP 296A 81 DUP2 296B 81 DUP2 296C 03 SUB 296D 60 PUSH1 0x80 296F 83 DUP4 2970 01 ADD 2971 52 MSTORE 2972 61 PUSH2 0x297b 2975 81 DUP2 2976 84 DUP5 2977 61 PUSH2 0x238a 297A 56 *JUMP 297B 5B JUMPDEST 297C 97 SWAP8 297D 96 SWAP7 297E 50 POP 297F 50 POP 2980 50 POP 2981 50 POP 2982 50 POP 2983 50 POP 2984 50 POP 2985 56 *JUMP 2986 5B JUMPDEST 2987 60 PUSH1 0xa0 2989 81 DUP2 298A 01 ADD 298B 61 PUSH2 0x2994 298E 82 DUP3 298F 88 DUP9 2990 61 PUSH2 0x223b 2993 56 *JUMP 2994 5B JUMPDEST 2995 61 PUSH2 0x29a1 2998 60 PUSH1 0x20 299A 83 DUP4 299B 01 ADD 299C 87 DUP8 299D 61 PUSH2 0x223b 29A0 56 *JUMP 29A1 5B JUMPDEST 29A2 61 PUSH2 0x29ae 29A5 60 PUSH1 0x40 29A7 83 DUP4 29A8 01 ADD 29A9 86 DUP7 29AA 61 PUSH2 0x2381 29AD 56 *JUMP 29AE 5B JUMPDEST 29AF 61 PUSH2 0x29bb 29B2 60 PUSH1 0x60 29B4 83 DUP4 29B5 01 ADD 29B6 85 DUP6 29B7 61 PUSH2 0x2381 29BA 56 *JUMP 29BB 5B JUMPDEST 29BC 81 DUP2 29BD 81 DUP2 29BE 03 SUB 29BF 60 PUSH1 0x80 29C1 83 DUP4 29C2 01 ADD 29C3 52 MSTORE 29C4 61 PUSH2 0x297b 29C7 81 DUP2 29C8 84 DUP5 29C9 61 PUSH2 0x238a 29CC 56 *JUMP 29CD 5B JUMPDEST 29CE 60 PUSH1 0x20 29D0 80 DUP1 29D1 82 DUP3 29D2 52 MSTORE 29D3 81 DUP2 29D4 01 ADD 29D5 61 PUSH2 0x291f 29D8 81 DUP2 29D9 84 DUP5 29DA 61 PUSH2 0x22a3 29DD 56 *JUMP 29DE 5B JUMPDEST 29DF 60 PUSH1 0x40 29E1 80 DUP1 29E2 82 DUP3 29E3 52 MSTORE 29E4 81 DUP2 29E5 01 ADD 29E6 61 PUSH2 0x29f0 29E9 81 DUP2 29EA 86 DUP7 29EB 88 DUP9 29EC 61 PUSH2 0x22f1 29EF 56 *JUMP 29F0 5B JUMPDEST 29F1 90 SWAP1 29F2 50 POP 29F3 81 DUP2 29F4 81 DUP2 29F5 03 SUB 29F6 60 PUSH1 0x20 29F8 83 DUP4 29F9 01 ADD 29FA 52 MSTORE 29FB 61 PUSH2 0x2a05 29FE 81 DUP2 29FF 84 DUP5 2A00 86 DUP7 2A01 61 PUSH2 0x22f1 2A04 56 *JUMP 2A05 5B JUMPDEST 2A06 96 SWAP7 2A07 95 SWAP6 2A08 50 POP 2A09 50 POP 2A0A 50 POP 2A0B 50 POP 2A0C 50 POP 2A0D 50 POP 2A0E 56 *JUMP label_2A0F: // Incoming jump from 0x026D // Inputs[2] // { // @2A13 stack[-1] // @2A1B stack[-2] // } 2A0F 5B JUMPDEST 2A10 60 PUSH1 0x20 2A12 80 DUP1 2A13 82 DUP3 2A14 52 MSTORE 2A15 81 DUP2 2A16 01 ADD 2A17 61 PUSH2 0x291f 2A1A 81 DUP2 2A1B 84 DUP5 2A1C 61 PUSH2 0x232a 2A1F 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2A14 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2A16 stack[0] = stack[-1] + 0x20 // @2A17 stack[1] = 0x291f // @2A1A stack[2] = stack[-1] + 0x20 // @2A1B stack[3] = stack[-2] // } // Block ends with call to 0x232a, returns to 0x291F label_2A20: // Incoming jump from 0x0210 // Inputs[2] // { // @2A23 stack[-1] // @2A29 stack[-2] // } 2A20 5B JUMPDEST 2A21 60 PUSH1 0x20 2A23 81 DUP2 2A24 01 ADD 2A25 61 PUSH2 0x040f 2A28 82 DUP3 2A29 84 DUP5 2A2A 61 PUSH2 0x2378 2A2D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2A24 stack[0] = stack[-1] + 0x20 // @2A25 stack[1] = 0x040f // @2A28 stack[2] = stack[-1] // @2A29 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x2378 2A2E 5B JUMPDEST 2A2F 60 PUSH1 0x80 2A31 81 DUP2 2A32 01 ADD 2A33 61 PUSH2 0x2a3c 2A36 82 DUP3 2A37 87 DUP8 2A38 61 PUSH2 0x2381 2A3B 56 *JUMP 2A3C 5B JUMPDEST 2A3D 61 PUSH2 0x2a49 2A40 60 PUSH1 0x20 2A42 83 DUP4 2A43 01 ADD 2A44 86 DUP7 2A45 61 PUSH2 0x28c7 2A48 56 *JUMP 2A49 5B JUMPDEST 2A4A 61 PUSH2 0x2a56 2A4D 60 PUSH1 0x40 2A4F 83 DUP4 2A50 01 ADD 2A51 85 DUP6 2A52 61 PUSH2 0x2381 2A55 56 *JUMP 2A56 5B JUMPDEST 2A57 61 PUSH2 0x2a63 2A5A 60 PUSH1 0x60 2A5C 83 DUP4 2A5D 01 ADD 2A5E 84 DUP5 2A5F 61 PUSH2 0x2381 2A62 56 *JUMP 2A63 5B JUMPDEST 2A64 95 SWAP6 2A65 94 SWAP5 2A66 50 POP 2A67 50 POP 2A68 50 POP 2A69 50 POP 2A6A 50 POP 2A6B 56 *JUMP label_2A6C: // Incoming call from 0x0225, returns to 0x01E8 // Inputs[2] // { // @2A70 stack[-1] // @2A78 stack[-2] // } 2A6C 5B JUMPDEST 2A6D 60 PUSH1 0x20 2A6F 80 DUP1 2A70 82 DUP3 2A71 52 MSTORE 2A72 81 DUP2 2A73 01 ADD 2A74 61 PUSH2 0x291f 2A77 81 DUP2 2A78 84 DUP5 2A79 61 PUSH2 0x238a 2A7C 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2A71 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2A73 stack[0] = stack[-1] + 0x20 // @2A74 stack[1] = 0x291f // @2A77 stack[2] = stack[-1] + 0x20 // @2A78 stack[3] = stack[-2] // } // Block ends with call to 0x238a, returns to 0x291F 2A7D 5B JUMPDEST 2A7E 60 PUSH1 0x20 2A80 80 DUP1 2A81 82 DUP3 2A82 52 MSTORE 2A83 81 DUP2 2A84 01 ADD 2A85 61 PUSH2 0x040f 2A88 81 DUP2 2A89 61 PUSH2 0x23d3 2A8C 56 *JUMP 2A8D 5B JUMPDEST 2A8E 60 PUSH1 0x20 2A90 80 DUP1 2A91 82 DUP3 2A92 52 MSTORE 2A93 81 DUP2 2A94 01 ADD 2A95 61 PUSH2 0x040f 2A98 81 DUP2 2A99 61 PUSH2 0x240c 2A9C 56 *JUMP 2A9D 5B JUMPDEST 2A9E 60 PUSH1 0x20 2AA0 80 DUP1 2AA1 82 DUP3 2AA2 52 MSTORE 2AA3 81 DUP2 2AA4 01 ADD 2AA5 61 PUSH2 0x040f 2AA8 81 DUP2 2AA9 61 PUSH2 0x2445 2AAC 56 *JUMP 2AAD 5B JUMPDEST 2AAE 60 PUSH1 0x20 2AB0 80 DUP1 2AB1 82 DUP3 2AB2 52 MSTORE 2AB3 81 DUP2 2AB4 01 ADD 2AB5 61 PUSH2 0x040f 2AB8 81 DUP2 2AB9 61 PUSH2 0x248d 2ABC 56 *JUMP 2ABD 5B JUMPDEST 2ABE 60 PUSH1 0x20 2AC0 80 DUP1 2AC1 82 DUP3 2AC2 52 MSTORE 2AC3 81 DUP2 2AC4 01 ADD 2AC5 61 PUSH2 0x040f 2AC8 81 DUP2 2AC9 61 PUSH2 0x24c6 2ACC 56 *JUMP label_2ACD: // Incoming jump from 0x199B // Inputs[1] { @2AD1 stack[-1] } 2ACD 5B JUMPDEST 2ACE 60 PUSH1 0x20 2AD0 80 DUP1 2AD1 82 DUP3 2AD2 52 MSTORE 2AD3 81 DUP2 2AD4 01 ADD 2AD5 61 PUSH2 0x040f 2AD8 81 DUP2 2AD9 61 PUSH2 0x250d 2ADC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2AD2 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2AD4 stack[0] = stack[-1] + 0x20 // @2AD5 stack[1] = 0x040f // @2AD8 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x250d, returns to 0x040F 2ADD 5B JUMPDEST 2ADE 60 PUSH1 0x20 2AE0 80 DUP1 2AE1 82 DUP3 2AE2 52 MSTORE 2AE3 81 DUP2 2AE4 01 ADD 2AE5 61 PUSH2 0x040f 2AE8 81 DUP2 2AE9 61 PUSH2 0x2550 2AEC 56 *JUMP 2AED 5B JUMPDEST 2AEE 60 PUSH1 0x20 2AF0 80 DUP1 2AF1 82 DUP3 2AF2 52 MSTORE 2AF3 81 DUP2 2AF4 01 ADD 2AF5 61 PUSH2 0x040f 2AF8 81 DUP2 2AF9 61 PUSH2 0x259d 2AFC 56 *JUMP 2AFD 5B JUMPDEST 2AFE 60 PUSH1 0x20 2B00 80 DUP1 2B01 82 DUP3 2B02 52 MSTORE 2B03 81 DUP2 2B04 01 ADD 2B05 61 PUSH2 0x040f 2B08 81 DUP2 2B09 61 PUSH2 0x25ee 2B0C 56 *JUMP label_2B0D: // Incoming jump from 0x0AE6 // Incoming jump from 0x0A2F // Incoming jump from 0x0B6E // Inputs[1] { @2B11 stack[-1] } 2B0D 5B JUMPDEST 2B0E 60 PUSH1 0x20 2B10 80 DUP1 2B11 82 DUP3 2B12 52 MSTORE 2B13 81 DUP2 2B14 01 ADD 2B15 61 PUSH2 0x040f 2B18 81 DUP2 2B19 61 PUSH2 0x264d 2B1C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2B12 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2B14 stack[0] = stack[-1] + 0x20 // @2B15 stack[1] = 0x040f // @2B18 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x264d, returns to 0x040F label_2B1D: // Incoming jump from 0x1460 // Inputs[1] { @2B21 stack[-1] } 2B1D 5B JUMPDEST 2B1E 60 PUSH1 0x20 2B20 80 DUP1 2B21 82 DUP3 2B22 52 MSTORE 2B23 81 DUP2 2B24 01 ADD 2B25 61 PUSH2 0x040f 2B28 81 DUP2 2B29 61 PUSH2 0x2686 2B2C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2B22 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2B24 stack[0] = stack[-1] + 0x20 // @2B25 stack[1] = 0x040f // @2B28 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2686, returns to 0x040F 2B2D 5B JUMPDEST 2B2E 60 PUSH1 0x20 2B30 80 DUP1 2B31 82 DUP3 2B32 52 MSTORE 2B33 81 DUP2 2B34 01 ADD 2B35 61 PUSH2 0x040f 2B38 81 DUP2 2B39 61 PUSH2 0x26ca 2B3C 56 *JUMP 2B3D 5B JUMPDEST 2B3E 60 PUSH1 0x20 2B40 80 DUP1 2B41 82 DUP3 2B42 52 MSTORE 2B43 81 DUP2 2B44 01 ADD 2B45 61 PUSH2 0x040f 2B48 81 DUP2 2B49 61 PUSH2 0x2703 2B4C 56 *JUMP 2B4D 5B JUMPDEST 2B4E 60 PUSH1 0x20 2B50 80 DUP1 2B51 82 DUP3 2B52 52 MSTORE 2B53 81 DUP2 2B54 01 ADD 2B55 61 PUSH2 0x040f 2B58 81 DUP2 2B59 61 PUSH2 0x273c 2B5C 56 *JUMP 2B5D 5B JUMPDEST 2B5E 60 PUSH1 0x20 2B60 80 DUP1 2B61 82 DUP3 2B62 52 MSTORE 2B63 81 DUP2 2B64 01 ADD 2B65 61 PUSH2 0x040f 2B68 81 DUP2 2B69 61 PUSH2 0x2787 2B6C 56 *JUMP 2B6D 5B JUMPDEST 2B6E 60 PUSH1 0x20 2B70 80 DUP1 2B71 82 DUP3 2B72 52 MSTORE 2B73 81 DUP2 2B74 01 ADD 2B75 61 PUSH2 0x040f 2B78 81 DUP2 2B79 61 PUSH2 0x27c0 2B7C 56 *JUMP 2B7D 5B JUMPDEST 2B7E 60 PUSH1 0x20 2B80 80 DUP1 2B81 82 DUP3 2B82 52 MSTORE 2B83 81 DUP2 2B84 01 ADD 2B85 61 PUSH2 0x040f 2B88 81 DUP2 2B89 61 PUSH2 0x281f 2B8C 56 *JUMP 2B8D 5B JUMPDEST 2B8E 60 PUSH1 0x20 2B90 80 DUP1 2B91 82 DUP3 2B92 52 MSTORE 2B93 81 DUP2 2B94 01 ADD 2B95 61 PUSH2 0x040f 2B98 81 DUP2 2B99 61 PUSH2 0x2850 2B9C 56 *JUMP 2B9D 5B JUMPDEST 2B9E 60 PUSH1 0x20 2BA0 80 DUP1 2BA1 82 DUP3 2BA2 52 MSTORE 2BA3 81 DUP2 2BA4 01 ADD 2BA5 61 PUSH2 0x040f 2BA8 81 DUP2 2BA9 61 PUSH2 0x2889 2BAC 56 *JUMP 2BAD 5B JUMPDEST 2BAE 60 PUSH1 0x20 2BB0 81 DUP2 2BB1 01 ADD 2BB2 61 PUSH2 0x040f 2BB5 82 DUP3 2BB6 84 DUP5 2BB7 61 PUSH2 0x2381 2BBA 56 *JUMP 2BBB 5B JUMPDEST 2BBC 60 PUSH1 0x60 2BBE 81 DUP2 2BBF 01 ADD 2BC0 61 PUSH2 0x2bc9 2BC3 82 DUP3 2BC4 86 DUP7 2BC5 61 PUSH2 0x2381 2BC8 56 *JUMP 2BC9 5B JUMPDEST 2BCA 81 DUP2 2BCB 81 DUP2 2BCC 03 SUB 2BCD 60 PUSH1 0x20 2BCF 83 DUP4 2BD0 01 ADD 2BD1 52 MSTORE 2BD2 61 PUSH2 0x2bdb 2BD5 81 DUP2 2BD6 85 DUP6 2BD7 61 PUSH2 0x224a 2BDA 56 *JUMP 2BDB 5B JUMPDEST 2BDC 90 SWAP1 2BDD 50 POP 2BDE 81 DUP2 2BDF 81 DUP2 2BE0 03 SUB 2BE1 60 PUSH1 0x40 2BE3 83 DUP4 2BE4 01 ADD 2BE5 52 MSTORE 2BE6 61 PUSH2 0x2a63 2BE9 81 DUP2 2BEA 84 DUP5 2BEB 61 PUSH2 0x232a 2BEE 56 *JUMP 2BEF 5B JUMPDEST 2BF0 60 PUSH1 0x40 2BF2 81 DUP2 2BF3 01 ADD 2BF4 61 PUSH2 0x2912 2BF7 82 DUP3 2BF8 85 DUP6 2BF9 61 PUSH2 0x2381 2BFC 56 *JUMP label_2BFD: // Incoming jump from 0x1C6F // Inputs[2] // { // @2C00 memory[0x40:0x60] // @2C01 stack[-1] // } 2BFD 5B JUMPDEST 2BFE 60 PUSH1 0x40 2C00 51 MLOAD 2C01 81 DUP2 2C02 81 DUP2 2C03 01 ADD 2C04 60 PUSH1 0x01 2C06 60 PUSH1 0x01 2C08 60 PUSH1 0x40 2C0A 1B SHL 2C0B 03 SUB 2C0C 81 DUP2 2C0D 11 GT 2C0E 82 DUP3 2C0F 82 DUP3 2C10 10 LT 2C11 17 OR 2C12 15 ISZERO 2C13 61 PUSH2 0x2c1b 2C16 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2C00 stack[0] = memory[0x40:0x60] // @2C03 stack[1] = memory[0x40:0x60] + stack[-1] // } // Block ends with conditional jump to 0x2c1b, if !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > (0x01 << 0x40) - 0x01)) label_2C17: // Incoming jump from 0x2C16, if not !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > (0x01 << 0x40) - 0x01)) // Inputs[1] { @2C1A memory[0x00:0x00] } 2C17 60 PUSH1 0x00 2C19 80 DUP1 2C1A FD *REVERT // Stack delta = +0 // Outputs[1] { @2C1A revert(memory[0x00:0x00]); } // Block terminates label_2C1B: // Incoming jump from 0x2C16, if !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > (0x01 << 0x40) - 0x01)) // Inputs[4] // { // @2C1E stack[-1] // @2C1F stack[-4] // @2C1F stack[-2] // @2C20 stack[-3] // } 2C1B 5B JUMPDEST 2C1C 60 PUSH1 0x40 2C1E 52 MSTORE 2C1F 91 SWAP2 2C20 90 SWAP1 2C21 50 POP 2C22 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2C1E memory[0x40:0x60] = stack[-1] // @2C1F stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] 2C23 5B JUMPDEST 2C24 60 PUSH1 0x00 2C26 60 PUSH1 0x01 2C28 60 PUSH1 0x01 2C2A 60 PUSH1 0x40 2C2C 1B SHL 2C2D 03 SUB 2C2E 82 DUP3 2C2F 11 GT 2C30 15 ISZERO 2C31 61 PUSH2 0x2c39 2C34 57 *JUMPI 2C35 60 PUSH1 0x00 2C37 80 DUP1 2C38 FD *REVERT 2C39 5B JUMPDEST 2C3A 50 POP 2C3B 60 PUSH1 0x20 2C3D 90 SWAP1 2C3E 81 DUP2 2C3F 02 MUL 2C40 01 ADD 2C41 90 SWAP1 2C42 56 *JUMP label_2C43: // Incoming call from 0x1D58, returns to 0x1C6B // Inputs[1] { @2C4E stack[-1] } 2C43 5B JUMPDEST 2C44 60 PUSH1 0x00 2C46 60 PUSH1 0x01 2C48 60 PUSH1 0x01 2C4A 60 PUSH1 0x40 2C4C 1B SHL 2C4D 03 SUB 2C4E 82 DUP3 2C4F 11 GT 2C50 15 ISZERO 2C51 61 PUSH2 0x2c59 2C54 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2C44 stack[0] = 0x00 } // Block ends with conditional jump to 0x2c59, if !(stack[-1] > (0x01 << 0x40) - 0x01) label_2C55: // Incoming jump from 0x2C54, if not !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2C58 memory[0x00:0x00] } 2C55 60 PUSH1 0x00 2C57 80 DUP1 2C58 FD *REVERT // Stack delta = +0 // Outputs[1] { @2C58 revert(memory[0x00:0x00]); } // Block terminates label_2C59: // Incoming jump from 0x2C54, if !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @2C5F stack[-2] // @2C68 stack[-3] // } 2C59 5B JUMPDEST 2C5A 50 POP 2C5B 60 PUSH1 0x20 2C5D 60 PUSH1 0x1f 2C5F 91 SWAP2 2C60 90 SWAP1 2C61 91 SWAP2 2C62 01 ADD 2C63 60 PUSH1 0x1f 2C65 19 NOT 2C66 16 AND 2C67 01 ADD 2C68 90 SWAP1 2C69 56 *JUMP // Stack delta = -2 // Outputs[1] { @2C68 stack[-3] = (~0x1f & 0x1f + stack[-2]) + 0x20 } // Block ends with unconditional jump to stack[-3] label_2C6A: // Incoming call from 0x2349, returns to 0x234A // Inputs[2] // { // @2C6D stack[-1] // @2C6E stack[-2] // } 2C6A 5B JUMPDEST 2C6B 60 PUSH1 0x20 2C6D 01 ADD 2C6E 90 SWAP1 2C6F 56 *JUMP // Stack delta = -1 // Outputs[1] { @2C6E stack[-2] = 0x20 + stack[-1] } // Block ends with unconditional jump to stack[-2] label_2C70: // Incoming call from 0x2334, returns to 0x2335 // Incoming call from 0x2394, returns to 0x2395 // Inputs[3] // { // @2C71 memory[stack[-1]:stack[-1] + 0x20] // @2C71 stack[-1] // @2C72 stack[-2] // } 2C70 5B JUMPDEST 2C71 51 MLOAD 2C72 90 SWAP1 2C73 56 *JUMP // Stack delta = -1 // Outputs[1] { @2C72 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_2C74: // Incoming call from 0x2659, returns to 0x265A // Incoming call from 0x233E, returns to 0x233F // Incoming call from 0x2692, returns to 0x2693 // Incoming call from 0x239E, returns to 0x239F // Incoming call from 0x2519, returns to 0x251A // Inputs[3] // { // @2C75 stack[-1] // @2C75 stack[-2] // @2C7B stack[-3] // } 2C74 5B JUMPDEST 2C75 90 SWAP1 2C76 81 DUP2 2C77 52 MSTORE 2C78 60 PUSH1 0x20 2C7A 01 ADD 2C7B 90 SWAP1 2C7C 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2C77 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @2C7B stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_2C7D: // Incoming call from 0x2D1C, returns to 0x2D1D // Incoming call from 0x2243, returns to 0x2244 // Inputs[1] { @2C83 stack[-1] } 2C7D 5B JUMPDEST 2C7E 60 PUSH1 0x00 2C80 61 PUSH2 0x040f 2C83 82 DUP3 2C84 61 PUSH2 0x2c9a 2C87 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2C7E stack[0] = 0x00 // @2C80 stack[1] = 0x040f // @2C83 stack[2] = stack[-1] // } // Block ends with call to 0x2c9a, returns to 0x040F label_2C88: // Incoming call from 0x2380, returns to 0x2244 // Inputs[2] // { // @2C89 stack[-1] // @2C8B stack[-2] // } 2C88 5B JUMPDEST 2C89 15 ISZERO 2C8A 15 ISZERO 2C8B 90 SWAP1 2C8C 56 *JUMP // Stack delta = -1 // Outputs[1] { @2C8B stack[-2] = !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_2C8D: // Incoming call from 0x2D42, returns to 0x2D1D // Inputs[2] // { // @2C97 stack[-1] // @2C98 stack[-2] // } 2C8D 5B JUMPDEST 2C8E 60 PUSH1 0x01 2C90 60 PUSH1 0x01 2C92 60 PUSH1 0xe0 2C94 1B SHL 2C95 03 SUB 2C96 19 NOT 2C97 16 AND 2C98 90 SWAP1 2C99 56 *JUMP // Stack delta = -1 // Outputs[1] { @2C98 stack[-2] = ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block ends with unconditional jump to stack[-2] label_2C9A: // Incoming call from 0x2C87, returns to 0x040F // Inputs[2] // { // @2CA3 stack[-1] // @2CA4 stack[-2] // } 2C9A 5B JUMPDEST 2C9B 60 PUSH1 0x01 2C9D 60 PUSH1 0x01 2C9F 60 PUSH1 0xa0 2CA1 1B SHL 2CA2 03 SUB 2CA3 16 AND 2CA4 90 SWAP1 2CA5 56 *JUMP // Stack delta = -1 // Outputs[1] { @2CA4 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] } // Block ends with unconditional jump to stack[-2] 2CA6 5B JUMPDEST 2CA7 60 PUSH1 0xff 2CA9 16 AND 2CAA 90 SWAP1 2CAB 56 *JUMP 2CAC 5B JUMPDEST 2CAD 60 PUSH1 0x00 2CAF 61 PUSH2 0x040f 2CB2 82 DUP3 2CB3 61 PUSH2 0x2c7d 2CB6 56 *JUMP label_2CB7: // Incoming call from 0x1D7F, returns to 0x1D80 // Inputs[5] // { // @2CB8 stack[-3] // @2CB9 stack[-1] // @2CBA stack[-2] // @2CBB msg.data[stack[-1]:stack[-1] + stack[-3]] // @2CC2 stack[-4] // } 2CB7 5B JUMPDEST 2CB8 82 DUP3 2CB9 81 DUP2 2CBA 83 DUP4 2CBB 37 CALLDATACOPY 2CBC 50 POP 2CBD 60 PUSH1 0x00 2CBF 91 SWAP2 2CC0 01 ADD 2CC1 52 MSTORE 2CC2 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2CBB memory[stack[-2]:stack[-2] + stack[-3]] = msg.data[stack[-1]:stack[-1] + stack[-3]] // @2CC1 memory[stack[-3] + stack[-2]:stack[-3] + stack[-2] + 0x20] = 0x00 // } // Block ends with unconditional jump to stack[-4] label_2CC3: // Incoming call from 0x23AE, returns to 0x23AF // Inputs[1] { @2CC7 stack[-3] } 2CC3 5B JUMPDEST 2CC4 60 PUSH1 0x00 2CC6 5B JUMPDEST 2CC7 83 DUP4 2CC8 81 DUP2 2CC9 10 LT 2CCA 15 ISZERO 2CCB 61 PUSH2 0x2cde 2CCE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2CC4 stack[0] = 0x00 } // Block ends with conditional jump to 0x2cde, if !(0x00 < stack[-3]) label_2CCF: // Incoming jump from 0x2CCE, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x2CCE, if not !(0x00 < stack[-3]) // Inputs[4] // { // @2CCF stack[-2] // @2CD0 stack[-1] // @2CD2 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2CD3 stack[-3] // } 2CCF 81 DUP2 2CD0 81 DUP2 2CD1 01 ADD 2CD2 51 MLOAD 2CD3 83 DUP4 2CD4 82 DUP3 2CD5 01 ADD 2CD6 52 MSTORE 2CD7 60 PUSH1 0x20 2CD9 01 ADD 2CDA 61 PUSH2 0x2cc6 2CDD 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2CD6 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2CD9 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2cc6 label_2CDE: // Incoming jump from 0x2CCE, if !(stack[-1] < stack[-4]) // Incoming jump from 0x2CCE, if !(0x00 < stack[-3]) // Inputs[2] // { // @2CDF stack[-4] // @2CE0 stack[-1] // } 2CDE 5B JUMPDEST 2CDF 83 DUP4 2CE0 81 DUP2 2CE1 11 GT 2CE2 15 ISZERO 2CE3 61 PUSH2 0x2ced 2CE6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2ced, if !(stack[-1] > stack[-4]) label_2CE7: // Incoming jump from 0x2CE6, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @2CE9 stack[-4] // @2CEA stack[-3] // @2CF2 stack[-5] // } 2CE7 60 PUSH1 0x00 2CE9 84 DUP5 2CEA 84 DUP5 2CEB 01 ADD 2CEC 52 MSTORE 2CED 5B JUMPDEST 2CEE 50 POP 2CEF 50 POP 2CF0 50 POP 2CF1 50 POP 2CF2 56 *JUMP // Stack delta = -5 // Outputs[1] { @2CEC memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] 2CF3 5B JUMPDEST 2CF4 60 PUSH1 0x00 2CF6 61 PUSH2 0x040f 2CF9 82 DUP3 2CFA 60 PUSH1 0x00 2CFC 61 PUSH2 0x040f 2CFF 82 DUP3 2D00 61 PUSH2 0x2d0e 2D03 56 *JUMP label_2D04: // Incoming call from 0x23B7, returns to 0x23B8 // Inputs[2] // { // @2D07 stack[-1] // @2D0C stack[-2] // } 2D04 5B JUMPDEST 2D05 60 PUSH1 0x1f 2D07 01 ADD 2D08 60 PUSH1 0x1f 2D0A 19 NOT 2D0B 16 AND 2D0C 90 SWAP1 2D0D 56 *JUMP // Stack delta = -1 // Outputs[1] { @2D0C stack[-2] = ~0x1f & 0x1f + stack[-1] } // Block ends with unconditional jump to stack[-2] 2D0E 5B JUMPDEST 2D0F 60 PUSH1 0x60 2D11 1B SHL 2D12 90 SWAP1 2D13 56 *JUMP label_2D14: // Incoming jump from 0x1C03 // Inputs[1] { @2D18 stack[-1] } 2D14 5B JUMPDEST 2D15 61 PUSH2 0x2d1d 2D18 81 DUP2 2D19 61 PUSH2 0x2c7d 2D1C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2D15 stack[0] = 0x2d1d // @2D18 stack[1] = stack[-1] // } // Block ends with call to 0x2c7d, returns to 0x2D1D label_2D1D: // Incoming return from call to 0x2C8D at 0x2D42 // Incoming return from call to 0x2C7D at 0x2D1C // Incoming return from call to 0x0A9A at 0x2D39 // Inputs[2] // { // @2D1E stack[-2] // @2D1F stack[-1] // } 2D1D 5B JUMPDEST 2D1E 81 DUP2 2D1F 14 EQ 2D20 61 PUSH2 0x04f8 2D23 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x04f8, if stack[-2] == stack[-1] label_2D24: // Incoming jump from 0x2D23, if not stack[-2] == stack[-1] // Inputs[1] { @2D27 memory[0x00:0x00] } 2D24 60 PUSH1 0x00 2D26 80 DUP1 2D27 FD *REVERT // Stack delta = +0 // Outputs[1] { @2D27 revert(memory[0x00:0x00]); } // Block terminates 2D28 5B JUMPDEST 2D29 61 PUSH2 0x2d1d 2D2C 81 DUP2 2D2D 61 PUSH2 0x2c88 2D30 56 *JUMP label_2D31: // Incoming call from 0x1CE2, returns to 0x040F // Inputs[1] { @2D35 stack[-1] } 2D31 5B JUMPDEST 2D32 61 PUSH2 0x2d1d 2D35 81 DUP2 2D36 61 PUSH2 0x0a9a 2D39 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2D32 stack[0] = 0x2d1d // @2D35 stack[1] = stack[-1] // } // Block ends with call to 0x0a9a, returns to 0x2D1D label_2D3A: // Incoming call from 0x1CED, returns to 0x040F // Inputs[1] { @2D3E stack[-1] } 2D3A 5B JUMPDEST 2D3B 61 PUSH2 0x2d1d 2D3E 81 DUP2 2D3F 61 PUSH2 0x2c8d 2D42 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2D3B stack[0] = 0x2d1d // @2D3E stack[1] = stack[-1] // } // Block ends with call to 0x2c8d, returns to 0x2D1D 2D43 5B JUMPDEST 2D44 61 PUSH2 0x2d1d 2D47 81 DUP2 2D48 61 PUSH2 0x2ca6 2D4B 56 *JUMP 2D4C FE *ASSERT 2D4D A3 LOG3 2D4E 65 PUSH6 0x627a7a723158 2D55 20 SHA3 2D56 D1 D1 2D57 50 POP 2D58 28 28 2D59 9C SWAP13 2D5A A7 A7 2D5B 2C 2C 2D5C 51 MLOAD 2D5D B9 B9 2D5E 04 DIV 2D5F C9 C9 2D60 88 DUP9 2D61 F4 DELEGATECALL 2D62 3B EXTCODESIZE 2D63 D0 D0 2D64 95 SWAP6 2D65 D7 D7 2D66 32 ORIGIN 2D67 8A DUP11 2D68 74 PUSH21 0x7c72dc3c22456b7036d43e2a7e6c6578706572696d 2D7E 65 PUSH6 0x6e74616cf564 2D85 73 PUSH20 0x6f6c63430005110040