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 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x0070 // Incoming jump from 0x013F // Incoming jump from 0x01C2, if not 0x06fdde03 == stack[-1] // Incoming jump from 0x0165 // Incoming jump from 0x00F8 // Incoming jump from 0x01A1 // Incoming jump from 0x00D2 // Incoming jump from 0x0096 // 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 0x1fe7 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 0x1fe7 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 0x2bdb 01E7 56 *JUMP label_01E8: // Incoming return from call to 0x2A9A 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 0x20d2 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 0x20d2 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 0x2a4e 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 0x2a4e 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 0x0CDF at 0x0355 // Incoming return from call to 0x0DA3 at 0x038B // Incoming return from call to 0x0434 at 0x0218 // Incoming return from call to 0x0AF0 at 0x0307 // 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 0x2a9a 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 0x2a9a, 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 0x1e09 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 0x1e09 0234 5B JUMPDEST 0235 61 PUSH2 0x04c2 0238 56 *JUMP label_0239: // Incoming return from call to 0x0D91 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 0x2142 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 0x2142 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 0x2142 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 0x2142 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 0x2a3d 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 0x2a3d 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 0x1e61 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 0x1e61 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 0x2064 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 0x2064, returns to 0x028F label_028F: // Incoming return from call to 0x2064 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 0x2160 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 0x2160 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 0x2932 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 0x1e09 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 0x1e09 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 0x2924 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 0x2924 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 0x210e 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 0x210e, returns to 0x02FB label_02FB: // Incoming return from call to 0x210E 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 0x210e 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 0x210e, returns to 0x0316 label_0316: // Incoming return from call to 0x210E 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 0x1fb7 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 0x1fb7 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 0x2142 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 0x2142 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 0x29fb 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 0x217f 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 0x217f 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 0x2142 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 0x2142 0377 5B JUMPDEST 0378 61 PUSH2 0x0d76 037B 56 *JUMP label_037C: // Incoming jump from 0x007C, if 0xe5c8b03d == stack[-1] 037C 5B JUMPDEST 037D 61 PUSH2 0x0239 0380 61 PUSH2 0x0d91 0383 56 *JUMP // Stack delta = +1 // Outputs[1] { @037D stack[0] = 0x0239 } // Block ends with call to 0x0d91, returns to 0x0239 label_0384: // Incoming jump from 0x0087, if 0xe8a3d485 == stack[-1] 0384 5B JUMPDEST 0385 61 PUSH2 0x0219 0388 61 PUSH2 0x0da3 038B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0385 stack[0] = 0x0219 } // Block ends with call to 0x0da3, 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 0x1e27 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 0x1e27 039A 5B JUMPDEST 039B 61 PUSH2 0x0dfe 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 0x1e09 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 0x1e09 03AD 5B JUMPDEST 03AE 61 PUSH2 0x0e2c 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 0x1f28 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 0x1f28 03C0 5B JUMPDEST 03C1 61 PUSH2 0x0e59 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 0x1e09 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 0x1e09 03D3 5B JUMPDEST 03D4 61 PUSH2 0x1013 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 0x2017 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 0x2017 03E6 5B JUMPDEST 03E7 61 PUSH2 0x1040 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 0x2CC8 at 0x2CB5 // Incoming return from call to 0x267B at 0x2B4A // Incoming return from call to 0x26B4 at 0x2B5A // Incoming return from call to 0x2D68 at 0x1D1B // Incoming return from call to 0x2269 at 0x2931 // Incoming return from call to 0x2D5F at 0x1D10 // Incoming return from call to 0x253B at 0x2B0A // 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 0x047B, if 0x1f < stack[-1] // Incoming jump from 0x0B37, if 0x1f < stack[-1] // Incoming jump from 0x0DEA, if 0x1f < stack[-1] // Incoming jump from 0x0D26, 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] > 0x20 + stack[-1] // Incoming jump from 0x04B0, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // 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 0x0D39 // Incoming jump from 0x0B4A // Incoming jump from 0x0DFD // Incoming jump from 0x0B2F, if !((storage[0x0b] & ~0x00 + 0x0100 * !(storage[0x0b] & 0x01)) / 0x02) // Incoming jump from 0x0D1E, if !((storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02) // Incoming jump from 0x0DE2, if !((storage[0x05] & ~0x00 + 0x0100 * !(storage[0x05] & 0x01)) / 0x02) // Incoming jump from 0x048E // Incoming jump from 0x0473, if !((storage[0x0a] & ~0x00 + 0x0100 * !(storage[0x0a] & 0x01)) / 0x02) // Incoming jump from 0x04B9 // 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 0x2b3b 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 0x1138 04F7 56 *JUMP label_04F8: // Incoming jump from 0x2D51, 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 0x1180 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 0x2aeb 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 0x2b7b 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 0x2b1b 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 0x12bb 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 0x12cd 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 0x2a0c 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 0x12da 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 0x1316 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[-1] // @0948 stack[-2] // @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[-1] // @096B stack[-2] // @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 0x1e09 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 0x1e09 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 0x2b3b 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 0x2b3b 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 0x13c5 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 jump from 0x0A99 // Incoming call from 0x2D67, returns to 0x2D4B // Incoming call from 0x23B7, returns to 0x2272 // Incoming return from call to 0x1C09 at 0x1C1B // 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 0x0ACA, returns to 0x0ACB // Incoming call from 0x0B52, returns to 0x0B53 // Incoming call from 0x0A13, returns to 0x0A14 // 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 0x140d 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 0x140d, returns to 0x0AB4 label_0AB4: // Incoming return from call to 0x140D 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 0x2b3b 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 0x2b3b 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 0x1411 0AEF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0AE8 stack[0] = 0x04f8 // @0AEB stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x1411 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 0x2b3b 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 0x2b3b 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 0x1428 0B77 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B70 stack[0] = 0x04f8 // @0B73 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x1428 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 0x2a4e 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 0x0d42 0D3E 61 PUSH2 0x0a9d 0D41 56 *JUMP 0D42 5B JUMPDEST 0D43 61 PUSH2 0x0d5e 0D46 57 *JUMPI 0D47 60 PUSH1 0x40 0D49 51 MLOAD 0D4A 62 PUSH3 0x461bcd 0D4E 60 PUSH1 0xe5 0D50 1B SHL 0D51 81 DUP2 0D52 52 MSTORE 0D53 60 PUSH1 0x04 0D55 01 ADD 0D56 61 PUSH2 0x04e6 0D59 90 SWAP1 0D5A 61 PUSH2 0x2b3b 0D5D 56 *JUMP 0D5E 5B JUMPDEST 0D5F 61 PUSH2 0x0d6d 0D62 87 DUP8 0D63 87 DUP8 0D64 87 DUP8 0D65 87 DUP8 0D66 87 DUP8 0D67 87 DUP8 0D68 87 DUP8 0D69 61 PUSH2 0x143b 0D6C 56 *JUMP 0D6D 5B JUMPDEST 0D6E 50 POP 0D6F 50 POP 0D70 50 POP 0D71 50 POP 0D72 50 POP 0D73 50 POP 0D74 50 POP 0D75 56 *JUMP 0D76 5B JUMPDEST 0D77 60 PUSH1 0x08 0D79 60 PUSH1 0x20 0D7B 52 MSTORE 0D7C 60 PUSH1 0x00 0D7E 90 SWAP1 0D7F 81 DUP2 0D80 52 MSTORE 0D81 60 PUSH1 0x40 0D83 90 SWAP1 0D84 20 SHA3 0D85 54 SLOAD 0D86 60 PUSH1 0x01 0D88 60 PUSH1 0x01 0D8A 60 PUSH1 0xa0 0D8C 1B SHL 0D8D 03 SUB 0D8E 16 AND 0D8F 81 DUP2 0D90 56 *JUMP label_0D91: // Incoming call from 0x0383, returns to 0x0239 0D91 5B JUMPDEST 0D92 61 PUSH2 0x0da1 0D95 61 PUSH2 0x0d9c 0D98 61 PUSH2 0x140d 0D9B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D92 stack[0] = 0x0da1 // @0D95 stack[1] = 0x0d9c // } // Block ends with call to 0x140d, returns to 0x0D9C label_0D9C: // Incoming return from call to 0x140D at 0x0D9B 0D9C 5B JUMPDEST 0D9D 61 PUSH2 0x1138 0DA0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1138 label_0DA1: // Incoming return from call to 0x0D9C at 0x0D9B // Inputs[1] { @0DA2 stack[-1] } 0DA1 5B JUMPDEST 0DA2 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0DA3: // Incoming call from 0x038B, returns to 0x0219 // Inputs[2] // { // @0DA7 storage[0x05] // @0DAB memory[0x40:0x60] // } 0DA3 5B JUMPDEST 0DA4 60 PUSH1 0x05 0DA6 80 DUP1 0DA7 54 SLOAD 0DA8 60 PUSH1 0x40 0DAA 80 DUP1 0DAB 51 MLOAD 0DAC 60 PUSH1 0x20 0DAE 60 PUSH1 0x02 0DB0 60 PUSH1 0x01 0DB2 85 DUP6 0DB3 16 AND 0DB4 15 ISZERO 0DB5 61 PUSH2 0x0100 0DB8 02 MUL 0DB9 60 PUSH1 0x00 0DBB 19 NOT 0DBC 01 ADD 0DBD 90 SWAP1 0DBE 94 SWAP5 0DBF 16 AND 0DC0 93 SWAP4 0DC1 90 SWAP1 0DC2 93 SWAP4 0DC3 04 DIV 0DC4 60 PUSH1 0x1f 0DC6 81 DUP2 0DC7 01 ADD 0DC8 84 DUP5 0DC9 90 SWAP1 0DCA 04 DIV 0DCB 84 DUP5 0DCC 02 MUL 0DCD 82 DUP3 0DCE 01 ADD 0DCF 84 DUP5 0DD0 01 ADD 0DD1 90 SWAP1 0DD2 92 SWAP3 0DD3 52 MSTORE 0DD4 81 DUP2 0DD5 81 DUP2 0DD6 52 MSTORE 0DD7 92 SWAP3 0DD8 91 SWAP2 0DD9 83 DUP4 0DDA 01 ADD 0DDB 82 DUP3 0DDC 82 DUP3 0DDD 80 DUP1 0DDE 15 ISZERO 0DDF 61 PUSH2 0x04ba 0DE2 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @0DD2 stack[2] = (storage[0x05] & ~0x00 + 0x0100 * !(storage[0x05] & 0x01)) / 0x02 // @0DD3 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x05] & ~0x00 + 0x0100 * !(storage[0x05] & 0x01)) / 0x02 + 0x1f) / 0x20) // @0DD6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x05] & ~0x00 + 0x0100 * !(storage[0x05] & 0x01)) / 0x02 // @0DD7 stack[0] = memory[0x40:0x60] // @0DD8 stack[1] = 0x05 // @0DDA stack[3] = memory[0x40:0x60] + 0x20 // @0DDB stack[4] = 0x05 // @0DDC 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_0DE3: // Incoming jump from 0x0DE2, if not !((storage[0x05] & ~0x00 + 0x0100 * !(storage[0x05] & 0x01)) / 0x02) // Inputs[1] { @0DE3 stack[-1] } 0DE3 80 DUP1 0DE4 60 PUSH1 0x1f 0DE6 10 LT 0DE7 61 PUSH2 0x048f 0DEA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048f, if 0x1f < stack[-1] label_0DEB: // Incoming jump from 0x0DEA, if not 0x1f < stack[-1] // Inputs[4] // { // @0DEF stack[-2] // @0DF0 storage[stack[-2]] // @0DF3 stack[-3] // @0DF5 stack[-1] // } 0DEB 61 PUSH2 0x0100 0DEE 80 DUP1 0DEF 83 DUP4 0DF0 54 SLOAD 0DF1 04 DIV 0DF2 02 MUL 0DF3 83 DUP4 0DF4 52 MSTORE 0DF5 91 SWAP2 0DF6 60 PUSH1 0x20 0DF8 01 ADD 0DF9 91 SWAP2 0DFA 61 PUSH2 0x04ba 0DFD 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0DF4 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0DF9 stack[-1] = stack[-1] // @0DF9 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x04ba 0DFE 5B JUMPDEST 0DFF 60 PUSH1 0x01 0E01 60 PUSH1 0x01 0E03 60 PUSH1 0xa0 0E05 1B SHL 0E06 03 SUB 0E07 91 SWAP2 0E08 82 DUP3 0E09 16 AND 0E0A 60 PUSH1 0x00 0E0C 90 SWAP1 0E0D 81 DUP2 0E0E 52 MSTORE 0E0F 60 PUSH1 0x07 0E11 60 PUSH1 0x20 0E13 90 SWAP1 0E14 81 DUP2 0E15 52 MSTORE 0E16 60 PUSH1 0x40 0E18 80 DUP1 0E19 83 DUP4 0E1A 20 SHA3 0E1B 93 SWAP4 0E1C 90 SWAP1 0E1D 94 SWAP5 0E1E 16 AND 0E1F 82 DUP3 0E20 52 MSTORE 0E21 91 SWAP2 0E22 90 SWAP1 0E23 91 SWAP2 0E24 52 MSTORE 0E25 20 SHA3 0E26 54 SLOAD 0E27 60 PUSH1 0xff 0E29 16 AND 0E2A 90 SWAP1 0E2B 56 *JUMP 0E2C 5B JUMPDEST 0E2D 61 PUSH2 0x0e34 0E30 61 PUSH2 0x0a9d 0E33 56 *JUMP 0E34 5B JUMPDEST 0E35 61 PUSH2 0x0e50 0E38 57 *JUMPI 0E39 60 PUSH1 0x40 0E3B 51 MLOAD 0E3C 62 PUSH3 0x461bcd 0E40 60 PUSH1 0xe5 0E42 1B SHL 0E43 81 DUP2 0E44 52 MSTORE 0E45 60 PUSH1 0x04 0E47 01 ADD 0E48 61 PUSH2 0x04e6 0E4B 90 SWAP1 0E4C 61 PUSH2 0x2b3b 0E4F 56 *JUMP 0E50 5B JUMPDEST 0E51 61 PUSH2 0x04f8 0E54 81 DUP2 0E55 61 PUSH2 0x14e2 0E58 56 *JUMP 0E59 5B JUMPDEST 0E5A 60 PUSH1 0x01 0E5C 60 PUSH1 0x01 0E5E 60 PUSH1 0xa0 0E60 1B SHL 0E61 03 SUB 0E62 85 DUP6 0E63 16 AND 0E64 61 PUSH2 0x0e7f 0E67 57 *JUMPI 0E68 60 PUSH1 0x40 0E6A 51 MLOAD 0E6B 62 PUSH3 0x461bcd 0E6F 60 PUSH1 0xe5 0E71 1B SHL 0E72 81 DUP2 0E73 52 MSTORE 0E74 60 PUSH1 0x04 0E76 01 ADD 0E77 61 PUSH2 0x04e6 0E7A 90 SWAP1 0E7B 61 PUSH2 0x2bab 0E7E 56 *JUMP 0E7F 5B JUMPDEST 0E80 60 PUSH1 0x01 0E82 60 PUSH1 0x01 0E84 60 PUSH1 0xa0 0E86 1B SHL 0E87 03 SUB 0E88 86 DUP7 0E89 16 AND 0E8A 33 CALLER 0E8B 14 EQ 0E8C 80 DUP1 0E8D 61 PUSH2 0x0ebe 0E90 57 *JUMPI 0E91 50 POP 0E92 60 PUSH1 0x01 0E94 60 PUSH1 0x01 0E96 60 PUSH1 0xa0 0E98 1B SHL 0E99 03 SUB 0E9A 86 DUP7 0E9B 16 AND 0E9C 60 PUSH1 0x00 0E9E 90 SWAP1 0E9F 81 DUP2 0EA0 52 MSTORE 0EA1 60 PUSH1 0x07 0EA3 60 PUSH1 0x20 0EA5 90 SWAP1 0EA6 81 DUP2 0EA7 52 MSTORE 0EA8 60 PUSH1 0x40 0EAA 80 DUP1 0EAB 83 DUP4 0EAC 20 SHA3 0EAD 33 CALLER 0EAE 84 DUP5 0EAF 52 MSTORE 0EB0 90 SWAP1 0EB1 91 SWAP2 0EB2 52 MSTORE 0EB3 90 SWAP1 0EB4 20 SHA3 0EB5 54 SLOAD 0EB6 60 PUSH1 0xff 0EB8 16 AND 0EB9 15 ISZERO 0EBA 15 ISZERO 0EBB 60 PUSH1 0x01 0EBD 14 EQ 0EBE 5B JUMPDEST 0EBF 61 PUSH2 0x0eda 0EC2 57 *JUMPI 0EC3 60 PUSH1 0x40 0EC5 51 MLOAD 0EC6 62 PUSH3 0x461bcd 0ECA 60 PUSH1 0xe5 0ECC 1B SHL 0ECD 81 DUP2 0ECE 52 MSTORE 0ECF 60 PUSH1 0x04 0ED1 01 ADD 0ED2 61 PUSH2 0x04e6 0ED5 90 SWAP1 0ED6 61 PUSH2 0x2b1b 0ED9 56 *JUMP 0EDA 5B JUMPDEST 0EDB 60 PUSH1 0x00 0EDD 84 DUP5 0EDE 81 DUP2 0EDF 52 MSTORE 0EE0 60 PUSH1 0x06 0EE2 60 PUSH1 0x20 0EE4 90 SWAP1 0EE5 81 DUP2 0EE6 52 MSTORE 0EE7 60 PUSH1 0x40 0EE9 80 DUP1 0EEA 83 DUP4 0EEB 20 SHA3 0EEC 60 PUSH1 0x01 0EEE 60 PUSH1 0x01 0EF0 60 PUSH1 0xa0 0EF2 1B SHL 0EF3 03 SUB 0EF4 8A DUP11 0EF5 16 AND 0EF6 84 DUP5 0EF7 52 MSTORE 0EF8 90 SWAP1 0EF9 91 SWAP2 0EFA 52 MSTORE 0EFB 90 SWAP1 0EFC 20 SHA3 0EFD 54 SLOAD 0EFE 61 PUSH2 0x0f0d 0F01 90 SWAP1 0F02 84 DUP5 0F03 63 PUSH4 0xffffffff 0F08 61 PUSH2 0x12bb 0F0B 16 AND 0F0C 56 *JUMP 0F0D 5B JUMPDEST 0F0E 60 PUSH1 0x00 0F10 85 DUP6 0F11 81 DUP2 0F12 52 MSTORE 0F13 60 PUSH1 0x06 0F15 60 PUSH1 0x20 0F17 90 SWAP1 0F18 81 DUP2 0F19 52 MSTORE 0F1A 60 PUSH1 0x40 0F1C 80 DUP1 0F1D 83 DUP4 0F1E 20 SHA3 0F1F 60 PUSH1 0x01 0F21 60 PUSH1 0x01 0F23 60 PUSH1 0xa0 0F25 1B SHL 0F26 03 SUB 0F27 8B DUP12 0F28 81 DUP2 0F29 16 AND 0F2A 85 DUP6 0F2B 52 MSTORE 0F2C 92 SWAP3 0F2D 52 MSTORE 0F2E 80 DUP1 0F2F 83 DUP4 0F30 20 SHA3 0F31 93 SWAP4 0F32 90 SWAP1 0F33 93 SWAP4 0F34 55 SSTORE 0F35 87 DUP8 0F36 16 AND 0F37 81 DUP2 0F38 52 MSTORE 0F39 20 SHA3 0F3A 54 SLOAD 0F3B 61 PUSH2 0x0f45 0F3E 90 SWAP1 0F3F 84 DUP5 0F40 90 SWAP1 0F41 61 PUSH2 0x12cd 0F44 56 *JUMP 0F45 5B JUMPDEST 0F46 60 PUSH1 0x00 0F48 85 DUP6 0F49 81 DUP2 0F4A 52 MSTORE 0F4B 60 PUSH1 0x06 0F4D 60 PUSH1 0x20 0F4F 90 SWAP1 0F50 81 DUP2 0F51 52 MSTORE 0F52 60 PUSH1 0x40 0F54 80 DUP1 0F55 83 DUP4 0F56 20 SHA3 0F57 60 PUSH1 0x01 0F59 60 PUSH1 0x01 0F5B 60 PUSH1 0xa0 0F5D 1B SHL 0F5E 03 SUB 0F5F 80 DUP1 0F60 8B DUP12 0F61 16 AND 0F62 80 DUP1 0F63 86 DUP7 0F64 52 MSTORE 0F65 91 SWAP2 0F66 90 SWAP1 0F67 93 SWAP4 0F68 52 MSTORE 0F69 92 SWAP3 0F6A 81 DUP2 0F6B 90 SWAP1 0F6C 20 SHA3 0F6D 93 SWAP4 0F6E 90 SWAP1 0F6F 93 SWAP4 0F70 55 SSTORE 0F71 91 SWAP2 0F72 51 MLOAD 0F73 90 SWAP1 0F74 91 SWAP2 0F75 88 DUP9 0F76 16 AND 0F77 90 SWAP1 0F78 33 CALLER 0F79 90 SWAP1 0F7A 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 0F9B 90 SWAP1 0F9C 61 PUSH2 0x0fa8 0F9F 90 SWAP1 0FA0 89 DUP10 0FA1 90 SWAP1 0FA2 89 DUP10 0FA3 90 SWAP1 0FA4 61 PUSH2 0x2c1d 0FA7 56 *JUMP 0FA8 5B JUMPDEST 0FA9 60 PUSH1 0x40 0FAB 51 MLOAD 0FAC 80 DUP1 0FAD 91 SWAP2 0FAE 03 SUB 0FAF 90 SWAP1 0FB0 A4 LOG4 0FB1 61 PUSH2 0x0fc2 0FB4 85 DUP6 0FB5 60 PUSH1 0x01 0FB7 60 PUSH1 0x01 0FB9 60 PUSH1 0xa0 0FBB 1B SHL 0FBC 03 SUB 0FBD 16 AND 0FBE 61 PUSH2 0x12da 0FC1 56 *JUMP 0FC2 5B JUMPDEST 0FC3 15 ISZERO 0FC4 61 PUSH2 0x100b 0FC7 57 *JUMPI 0FC8 61 PUSH2 0x100b 0FCB 33 CALLER 0FCC 87 DUP8 0FCD 87 DUP8 0FCE 87 DUP8 0FCF 87 DUP8 0FD0 87 DUP8 0FD1 87 DUP8 0FD2 80 DUP1 0FD3 80 DUP1 0FD4 60 PUSH1 0x1f 0FD6 01 ADD 0FD7 60 PUSH1 0x20 0FD9 80 DUP1 0FDA 91 SWAP2 0FDB 04 DIV 0FDC 02 MUL 0FDD 60 PUSH1 0x20 0FDF 01 ADD 0FE0 60 PUSH1 0x40 0FE2 51 MLOAD 0FE3 90 SWAP1 0FE4 81 DUP2 0FE5 01 ADD 0FE6 60 PUSH1 0x40 0FE8 52 MSTORE 0FE9 80 DUP1 0FEA 93 SWAP4 0FEB 92 SWAP3 0FEC 91 SWAP2 0FED 90 SWAP1 0FEE 81 DUP2 0FEF 81 DUP2 0FF0 52 MSTORE 0FF1 60 PUSH1 0x20 0FF3 01 ADD 0FF4 83 DUP4 0FF5 83 DUP4 0FF6 80 DUP1 0FF7 82 DUP3 0FF8 84 DUP5 0FF9 37 CALLDATACOPY 0FFA 60 PUSH1 0x00 0FFC 92 SWAP3 0FFD 01 ADD 0FFE 91 SWAP2 0FFF 90 SWAP1 1000 91 SWAP2 1001 52 MSTORE 1002 50 POP 1003 61 PUSH2 0x152a 1006 92 SWAP3 1007 50 POP 1008 50 POP 1009 50 POP 100A 56 *JUMP 100B 5B JUMPDEST 100C 50 POP 100D 50 POP 100E 50 POP 100F 50 POP 1010 50 POP 1011 50 POP 1012 56 *JUMP 1013 5B JUMPDEST 1014 61 PUSH2 0x101b 1017 61 PUSH2 0x0a9d 101A 56 *JUMP 101B 5B JUMPDEST 101C 61 PUSH2 0x1037 101F 57 *JUMPI 1020 60 PUSH1 0x40 1022 51 MLOAD 1023 62 PUSH3 0x461bcd 1027 60 PUSH1 0xe5 1029 1B SHL 102A 81 DUP2 102B 52 MSTORE 102C 60 PUSH1 0x04 102E 01 ADD 102F 61 PUSH2 0x04e6 1032 90 SWAP1 1033 61 PUSH2 0x2b3b 1036 56 *JUMP 1037 5B JUMPDEST 1038 61 PUSH2 0x04f8 103B 81 DUP2 103C 61 PUSH2 0x15d9 103F 56 *JUMP 1040 5B JUMPDEST 1041 60 PUSH1 0x01 1043 60 PUSH1 0x01 1045 60 PUSH1 0xa0 1047 1B SHL 1048 03 SUB 1049 83 DUP4 104A 16 AND 104B 33 CALLER 104C 14 EQ 104D 80 DUP1 104E 61 PUSH2 0x107f 1051 57 *JUMPI 1052 50 POP 1053 60 PUSH1 0x01 1055 60 PUSH1 0x01 1057 60 PUSH1 0xa0 1059 1B SHL 105A 03 SUB 105B 83 DUP4 105C 16 AND 105D 60 PUSH1 0x00 105F 90 SWAP1 1060 81 DUP2 1061 52 MSTORE 1062 60 PUSH1 0x07 1064 60 PUSH1 0x20 1066 90 SWAP1 1067 81 DUP2 1068 52 MSTORE 1069 60 PUSH1 0x40 106B 80 DUP1 106C 83 DUP4 106D 20 SHA3 106E 33 CALLER 106F 84 DUP5 1070 52 MSTORE 1071 90 SWAP1 1072 91 SWAP2 1073 52 MSTORE 1074 90 SWAP1 1075 20 SHA3 1076 54 SLOAD 1077 60 PUSH1 0xff 1079 16 AND 107A 15 ISZERO 107B 15 ISZERO 107C 60 PUSH1 0x01 107E 14 EQ 107F 5B JUMPDEST 1080 61 PUSH2 0x109b 1083 57 *JUMPI 1084 60 PUSH1 0x40 1086 51 MLOAD 1087 62 PUSH3 0x461bcd 108B 60 PUSH1 0xe5 108D 1B SHL 108E 81 DUP2 108F 52 MSTORE 1090 60 PUSH1 0x04 1092 01 ADD 1093 61 PUSH2 0x04e6 1096 90 SWAP1 1097 61 PUSH2 0x2b0b 109A 56 *JUMP 109B 5B JUMPDEST 109C 60 PUSH1 0x00 109E 82 DUP3 109F 81 DUP2 10A0 52 MSTORE 10A1 60 PUSH1 0x06 10A3 60 PUSH1 0x20 10A5 90 SWAP1 10A6 81 DUP2 10A7 52 MSTORE 10A8 60 PUSH1 0x40 10AA 80 DUP1 10AB 83 DUP4 10AC 20 SHA3 10AD 60 PUSH1 0x01 10AF 60 PUSH1 0x01 10B1 60 PUSH1 0xa0 10B3 1B SHL 10B4 03 SUB 10B5 87 DUP8 10B6 16 AND 10B7 84 DUP5 10B8 52 MSTORE 10B9 90 SWAP1 10BA 91 SWAP2 10BB 52 MSTORE 10BC 90 SWAP1 10BD 20 SHA3 10BE 54 SLOAD 10BF 61 PUSH2 0x10ce 10C2 90 SWAP1 10C3 82 DUP3 10C4 63 PUSH4 0xffffffff 10C9 61 PUSH2 0x12bb 10CC 16 AND 10CD 56 *JUMP 10CE 5B JUMPDEST 10CF 60 PUSH1 0x00 10D1 83 DUP4 10D2 81 DUP2 10D3 52 MSTORE 10D4 60 PUSH1 0x06 10D6 60 PUSH1 0x20 10D8 90 SWAP1 10D9 81 DUP2 10DA 52 MSTORE 10DB 60 PUSH1 0x40 10DD 80 DUP1 10DE 83 DUP4 10DF 20 SHA3 10E0 60 PUSH1 0x01 10E2 60 PUSH1 0x01 10E4 60 PUSH1 0xa0 10E6 1B SHL 10E7 03 SUB 10E8 88 DUP9 10E9 16 AND 10EA 80 DUP1 10EB 85 DUP6 10EC 52 MSTORE 10ED 92 SWAP3 10EE 52 MSTORE 10EF 80 DUP1 10F0 83 DUP4 10F1 20 SHA3 10F2 93 SWAP4 10F3 90 SWAP1 10F4 93 SWAP4 10F5 55 SSTORE 10F6 91 SWAP2 10F7 51 MLOAD 10F8 90 SWAP1 10F9 91 SWAP2 10FA 90 SWAP1 10FB 33 CALLER 10FC 90 SWAP1 10FD 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 111E 90 SWAP1 111F 61 PUSH2 0x112b 1122 90 SWAP1 1123 87 DUP8 1124 90 SWAP1 1125 87 DUP8 1126 90 SWAP1 1127 61 PUSH2 0x2c1d 112A 56 *JUMP 112B 5B JUMPDEST 112C 60 PUSH1 0x40 112E 51 MLOAD 112F 80 DUP1 1130 91 SWAP2 1131 03 SUB 1132 90 SWAP1 1133 A4 LOG4 1134 50 POP 1135 50 POP 1136 50 POP 1137 56 *JUMP label_1138: // Incoming jump from 0x0DA0 // Inputs[1] { @113E stack[-1] } 1138 5B JUMPDEST 1139 61 PUSH2 0x1149 113C 60 PUSH1 0x02 113E 82 DUP3 113F 63 PUSH4 0xffffffff 1144 61 PUSH2 0x165b 1147 16 AND 1148 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1139 stack[0] = 0x1149 // @113C stack[1] = 0x02 // @113E stack[2] = stack[-1] // } // Block ends with call to 0x165b & 0xffffffff, returns to 0x1149 label_1149: // Incoming return from call to 0x165B at 0x1148 // Inputs[4] // { // @114C memory[0x40:0x60] // @1155 stack[-1] // @117D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @117F stack[-2] // } 1149 5B JUMPDEST 114A 60 PUSH1 0x40 114C 51 MLOAD 114D 60 PUSH1 0x01 114F 60 PUSH1 0x01 1151 60 PUSH1 0xa0 1153 1B SHL 1154 03 SUB 1155 82 DUP3 1156 16 AND 1157 90 SWAP1 1158 7F PUSH32 0x3525e22824a8a7df2c9a6029941c824cf95b6447f1e13d5128fd3826d35afe8b 1179 90 SWAP1 117A 60 PUSH1 0x00 117C 90 SWAP1 117D A2 LOG2 117E 50 POP 117F 56 *JUMP // Stack delta = -2 // Outputs[1] { @117D log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x3525e22824a8a7df2c9a6029941c824cf95b6447f1e13d5128fd3826d35afe8b, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-2] 1180 5B JUMPDEST 1181 60 PUSH1 0x00 1183 81 DUP2 1184 81 DUP2 1185 52 MSTORE 1186 60 PUSH1 0x04 1188 60 PUSH1 0x20 118A 90 SWAP1 118B 81 DUP2 118C 52 MSTORE 118D 60 PUSH1 0x40 118F 91 SWAP2 1190 82 DUP3 1191 90 SWAP1 1192 20 SHA3 1193 80 DUP1 1194 54 SLOAD 1195 83 DUP4 1196 51 MLOAD 1197 60 PUSH1 0x02 1199 60 PUSH1 0x01 119B 83 DUP4 119C 16 AND 119D 15 ISZERO 119E 61 PUSH2 0x0100 11A1 02 MUL 11A2 60 PUSH1 0x00 11A4 19 NOT 11A5 01 ADD 11A6 90 SWAP1 11A7 92 SWAP3 11A8 16 AND 11A9 91 SWAP2 11AA 90 SWAP1 11AB 91 SWAP2 11AC 04 DIV 11AD 60 PUSH1 0x1f 11AF 81 DUP2 11B0 01 ADD 11B1 84 DUP5 11B2 90 SWAP1 11B3 04 DIV 11B4 84 DUP5 11B5 02 MUL 11B6 82 DUP3 11B7 01 ADD 11B8 84 DUP5 11B9 01 ADD 11BA 90 SWAP1 11BB 94 SWAP5 11BC 52 MSTORE 11BD 83 DUP4 11BE 81 DUP2 11BF 52 MSTORE 11C0 60 PUSH1 0x60 11C2 93 SWAP4 11C3 61 PUSH2 0x040f 11C6 93 SWAP4 11C7 91 SWAP2 11C8 92 SWAP3 11C9 91 SWAP2 11CA 83 DUP4 11CB 01 ADD 11CC 82 DUP3 11CD 82 DUP3 11CE 80 DUP1 11CF 15 ISZERO 11D0 61 PUSH2 0x121a 11D3 57 *JUMPI 11D4 80 DUP1 11D5 60 PUSH1 0x1f 11D7 10 LT 11D8 61 PUSH2 0x11ef 11DB 57 *JUMPI 11DC 61 PUSH2 0x0100 11DF 80 DUP1 11E0 83 DUP4 11E1 54 SLOAD 11E2 04 DIV 11E3 02 MUL 11E4 83 DUP4 11E5 52 MSTORE 11E6 91 SWAP2 11E7 60 PUSH1 0x20 11E9 01 ADD 11EA 91 SWAP2 11EB 61 PUSH2 0x121a 11EE 56 *JUMP 11EF 5B JUMPDEST 11F0 82 DUP3 11F1 01 ADD 11F2 91 SWAP2 11F3 90 SWAP1 11F4 60 PUSH1 0x00 11F6 52 MSTORE 11F7 60 PUSH1 0x20 11F9 60 PUSH1 0x00 11FB 20 SHA3 11FC 90 SWAP1 11FD 5B JUMPDEST 11FE 81 DUP2 11FF 54 SLOAD 1200 81 DUP2 1201 52 MSTORE 1202 90 SWAP1 1203 60 PUSH1 0x01 1205 01 ADD 1206 90 SWAP1 1207 60 PUSH1 0x20 1209 01 ADD 120A 80 DUP1 120B 83 DUP4 120C 11 GT 120D 61 PUSH2 0x11fd 1210 57 *JUMPI 1211 82 DUP3 1212 90 SWAP1 1213 03 SUB 1214 60 PUSH1 0x1f 1216 16 AND 1217 82 DUP3 1218 01 ADD 1219 91 SWAP2 121A 5B JUMPDEST 121B 50 POP 121C 50 POP 121D 60 PUSH1 0x03 121F 80 DUP1 1220 54 SLOAD 1221 60 PUSH1 0x40 1223 80 DUP1 1224 51 MLOAD 1225 60 PUSH1 0x20 1227 60 PUSH1 0x1f 1229 60 PUSH1 0x02 122B 60 PUSH1 0x00 122D 19 NOT 122E 61 PUSH2 0x0100 1231 60 PUSH1 0x01 1233 88 DUP9 1234 16 AND 1235 15 ISZERO 1236 02 MUL 1237 01 ADD 1238 90 SWAP1 1239 95 SWAP6 123A 16 AND 123B 94 SWAP5 123C 90 SWAP1 123D 94 SWAP5 123E 04 DIV 123F 93 SWAP4 1240 84 DUP5 1241 01 ADD 1242 81 DUP2 1243 90 SWAP1 1244 04 DIV 1245 81 DUP2 1246 02 MUL 1247 82 DUP3 1248 01 ADD 1249 81 DUP2 124A 01 ADD 124B 90 SWAP1 124C 92 SWAP3 124D 52 MSTORE 124E 82 DUP3 124F 81 DUP2 1250 52 MSTORE 1251 95 SWAP6 1252 50 POP 1253 91 SWAP2 1254 93 SWAP4 1255 50 POP 1256 91 SWAP2 1257 50 POP 1258 83 DUP4 1259 01 ADD 125A 82 DUP3 125B 82 DUP3 125C 80 DUP1 125D 15 ISZERO 125E 61 PUSH2 0x12a8 1261 57 *JUMPI 1262 80 DUP1 1263 60 PUSH1 0x1f 1265 10 LT 1266 61 PUSH2 0x127d 1269 57 *JUMPI 126A 61 PUSH2 0x0100 126D 80 DUP1 126E 83 DUP4 126F 54 SLOAD 1270 04 DIV 1271 02 MUL 1272 83 DUP4 1273 52 MSTORE 1274 91 SWAP2 1275 60 PUSH1 0x20 1277 01 ADD 1278 91 SWAP2 1279 61 PUSH2 0x12a8 127C 56 *JUMP 127D 5B JUMPDEST 127E 82 DUP3 127F 01 ADD 1280 91 SWAP2 1281 90 SWAP1 1282 60 PUSH1 0x00 1284 52 MSTORE 1285 60 PUSH1 0x20 1287 60 PUSH1 0x00 1289 20 SHA3 128A 90 SWAP1 128B 5B JUMPDEST 128C 81 DUP2 128D 54 SLOAD 128E 81 DUP2 128F 52 MSTORE 1290 90 SWAP1 1291 60 PUSH1 0x01 1293 01 ADD 1294 90 SWAP1 1295 60 PUSH1 0x20 1297 01 ADD 1298 80 DUP1 1299 83 DUP4 129A 11 GT 129B 61 PUSH2 0x128b 129E 57 *JUMPI 129F 82 DUP3 12A0 90 SWAP1 12A1 03 SUB 12A2 60 PUSH1 0x1f 12A4 16 AND 12A5 82 DUP3 12A6 01 ADD 12A7 91 SWAP2 12A8 5B JUMPDEST 12A9 50 POP 12AA 50 POP 12AB 50 POP 12AC 50 POP 12AD 50 POP 12AE 61 PUSH2 0x16a3 12B1 90 SWAP1 12B2 91 SWAP2 12B3 90 SWAP1 12B4 63 PUSH4 0xffffffff 12B9 16 AND 12BA 56 *JUMP 12BB 5B JUMPDEST 12BC 60 PUSH1 0x00 12BE 82 DUP3 12BF 82 DUP3 12C0 11 GT 12C1 15 ISZERO 12C2 61 PUSH2 0x12c7 12C5 57 *JUMPI 12C6 FE *ASSERT 12C7 5B JUMPDEST 12C8 50 POP 12C9 90 SWAP1 12CA 03 SUB 12CB 90 SWAP1 12CC 56 *JUMP 12CD 5B JUMPDEST 12CE 81 DUP2 12CF 81 DUP2 12D0 01 ADD 12D1 82 DUP3 12D2 81 DUP2 12D3 10 LT 12D4 15 ISZERO 12D5 61 PUSH2 0x040f 12D8 57 *JUMPI 12D9 FE *ASSERT 12DA 5B JUMPDEST 12DB 60 PUSH1 0x00 12DD 81 DUP2 12DE 3F EXTCODEHASH 12DF 7F PUSH32 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 1300 81 DUP2 1301 81 DUP2 1302 14 EQ 1303 80 DUP1 1304 15 ISZERO 1305 90 SWAP1 1306 61 PUSH2 0x130e 1309 57 *JUMPI 130A 50 POP 130B 81 DUP2 130C 15 ISZERO 130D 15 ISZERO label_130E: // Incoming return from call to 0x1D68 at 0x2141 // Inputs[3] // { // @130F stack[-6] // @130F stack[-1] // @1310 stack[-5] // } 130E 5B JUMPDEST 130F 94 SWAP5 1310 93 SWAP4 1311 50 POP 1312 50 POP 1313 50 POP 1314 50 POP 1315 56 *JUMP // Stack delta = -5 // Outputs[1] { @130F stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] 1316 5B JUMPDEST 1317 60 PUSH1 0x40 1319 51 MLOAD 131A 63 PUSH4 0xbc197c81 131F 60 PUSH1 0xe0 1321 1B SHL 1322 80 DUP1 1323 82 DUP3 1324 52 MSTORE 1325 90 SWAP1 1326 60 PUSH1 0x01 1328 60 PUSH1 0x01 132A 60 PUSH1 0xa0 132C 1B SHL 132D 03 SUB 132E 86 DUP7 132F 16 AND 1330 90 SWAP1 1331 63 PUSH4 0xbc197c81 1336 90 SWAP1 1337 61 PUSH2 0x134c 133A 90 SWAP1 133B 8A DUP11 133C 90 SWAP1 133D 8A DUP11 133E 90 SWAP1 133F 89 DUP10 1340 90 SWAP1 1341 89 DUP10 1342 90 SWAP1 1343 89 DUP10 1344 90 SWAP1 1345 60 PUSH1 0x04 1347 01 ADD 1348 61 PUSH2 0x2954 134B 56 *JUMP 134C 5B JUMPDEST 134D 60 PUSH1 0x20 134F 60 PUSH1 0x40 1351 51 MLOAD 1352 80 DUP1 1353 83 DUP4 1354 03 SUB 1355 81 DUP2 1356 60 PUSH1 0x00 1358 87 DUP8 1359 80 DUP1 135A 3B EXTCODESIZE 135B 15 ISZERO 135C 80 DUP1 135D 15 ISZERO 135E 61 PUSH2 0x1366 1361 57 *JUMPI 1362 60 PUSH1 0x00 1364 80 DUP1 1365 FD *REVERT 1366 5B JUMPDEST 1367 50 POP 1368 5A GAS 1369 F1 CALL 136A 15 ISZERO 136B 80 DUP1 136C 15 ISZERO 136D 61 PUSH2 0x137a 1370 57 *JUMPI 1371 3D RETURNDATASIZE 1372 60 PUSH1 0x00 1374 80 DUP1 1375 3E RETURNDATACOPY 1376 3D RETURNDATASIZE 1377 60 PUSH1 0x00 1379 FD *REVERT 137A 5B JUMPDEST 137B 50 POP 137C 50 POP 137D 50 POP 137E 50 POP 137F 60 PUSH1 0x40 1381 51 MLOAD 1382 3D RETURNDATASIZE 1383 60 PUSH1 0x1f 1385 19 NOT 1386 60 PUSH1 0x1f 1388 82 DUP3 1389 01 ADD 138A 16 AND 138B 82 DUP3 138C 01 ADD 138D 80 DUP1 138E 60 PUSH1 0x40 1390 52 MSTORE 1391 50 POP 1392 61 PUSH2 0x139e 1395 91 SWAP2 1396 90 SWAP1 1397 81 DUP2 1398 01 ADD 1399 90 SWAP1 139A 61 PUSH2 0x20f0 139D 56 *JUMP 139E 5B JUMPDEST 139F 60 PUSH1 0x01 13A1 60 PUSH1 0x01 13A3 60 PUSH1 0xe0 13A5 1B SHL 13A6 03 SUB 13A7 19 NOT 13A8 16 AND 13A9 14 EQ 13AA 61 PUSH2 0x100b 13AD 57 *JUMPI 13AE 60 PUSH1 0x40 13B0 51 MLOAD 13B1 62 PUSH3 0x461bcd 13B5 60 PUSH1 0xe5 13B7 1B SHL 13B8 81 DUP2 13B9 52 MSTORE 13BA 60 PUSH1 0x04 13BC 01 ADD 13BD 61 PUSH2 0x04e6 13C0 90 SWAP1 13C1 61 PUSH2 0x2b2b 13C4 56 *JUMP label_13C5: // Incoming call from 0x1664, returns to 0x1665 // Inputs[1] { @13D0 stack[-1] } 13C5 5B JUMPDEST 13C6 60 PUSH1 0x00 13C8 60 PUSH1 0x01 13CA 60 PUSH1 0x01 13CC 60 PUSH1 0xa0 13CE 1B SHL 13CF 03 SUB 13D0 82 DUP3 13D1 16 AND 13D2 61 PUSH2 0x13ed 13D5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @13C6 stack[0] = 0x00 } // Block ends with conditional jump to 0x13ed, if stack[-1] & (0x01 << 0xa0) - 0x01 label_13D6: // Incoming jump from 0x13D5, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @13D8 memory[0x40:0x60] } 13D6 60 PUSH1 0x40 13D8 51 MLOAD 13D9 62 PUSH3 0x461bcd 13DD 60 PUSH1 0xe5 13DF 1B SHL 13E0 81 DUP2 13E1 52 MSTORE 13E2 60 PUSH1 0x04 13E4 01 ADD 13E5 61 PUSH2 0x04e6 13E8 90 SWAP1 13E9 61 PUSH2 0x2b4b 13EC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @13E1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13E8 stack[0] = 0x04e6 // @13E8 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2b4b label_13ED: // Incoming jump from 0x13D5, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[5] // { // @13F7 stack[-2] // @13FF stack[-3] // @1406 memory[0x00:0x40] // @1407 storage[keccak256(memory[0x00:0x40])] // @140B stack[-4] // } 13ED 5B JUMPDEST 13EE 50 POP 13EF 60 PUSH1 0x01 13F1 60 PUSH1 0x01 13F3 60 PUSH1 0xa0 13F5 1B SHL 13F6 03 SUB 13F7 16 AND 13F8 60 PUSH1 0x00 13FA 90 SWAP1 13FB 81 DUP2 13FC 52 MSTORE 13FD 60 PUSH1 0x20 13FF 91 SWAP2 1400 90 SWAP1 1401 91 SWAP2 1402 52 MSTORE 1403 60 PUSH1 0x40 1405 90 SWAP1 1406 20 SHA3 1407 54 SLOAD 1408 60 PUSH1 0xff 140A 16 AND 140B 90 SWAP1 140C 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @13FC memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1402 memory[0x20:0x40] = stack[-3] // @140B stack[-4] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_140D: // Incoming call from 0x0D9B, returns to 0x0D9C // Incoming call from 0x0AB3, returns to 0x0AB4 // Inputs[2] // { // @140E msg.sender // @140F stack[-1] // } 140D 5B JUMPDEST 140E 33 CALLER 140F 90 SWAP1 1410 56 *JUMP // Stack delta = +0 // Outputs[1] { @140F stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_1411: // Incoming jump from 0x0AEF // Inputs[2] // { // @1412 stack[-1] // @1413 memory[stack[-1]:stack[-1] + 0x20] // } 1411 5B JUMPDEST 1412 80 DUP1 1413 51 MLOAD 1414 61 PUSH2 0x1424 1417 90 SWAP1 1418 60 PUSH1 0x05 141A 90 SWAP1 141B 60 PUSH1 0x20 141D 84 DUP5 141E 01 ADD 141F 90 SWAP1 1420 61 PUSH2 0x1b8f 1423 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1417 stack[0] = 0x1424 // @141A stack[1] = 0x05 // @141F stack[2] = stack[-1] + 0x20 // @141F stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1b8f 1424 5B JUMPDEST 1425 50 POP 1426 50 POP 1427 56 *JUMP label_1428: // Incoming jump from 0x0B77 // Inputs[2] // { // @1429 stack[-1] // @142A memory[stack[-1]:stack[-1] + 0x20] // } 1428 5B JUMPDEST 1429 80 DUP1 142A 51 MLOAD 142B 61 PUSH2 0x1424 142E 90 SWAP1 142F 60 PUSH1 0x03 1431 90 SWAP1 1432 60 PUSH1 0x20 1434 84 DUP5 1435 01 ADD 1436 90 SWAP1 1437 61 PUSH2 0x1b8f 143A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @142E stack[0] = 0x1424 // @1431 stack[1] = 0x03 // @1436 stack[2] = stack[-1] + 0x20 // @1436 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1b8f 143B 5B JUMPDEST 143C 61 PUSH2 0x14ba 143F 60 PUSH1 0x01 1441 30 ADDRESS 1442 89 DUP10 1443 60 PUSH1 0x40 1445 51 MLOAD 1446 60 PUSH1 0x20 1448 01 ADD 1449 61 PUSH2 0x1453 144C 92 SWAP3 144D 91 SWAP2 144E 90 SWAP1 144F 61 PUSH2 0x28fe 1452 56 *JUMP 1453 5B JUMPDEST 1454 60 PUSH1 0x40 1456 51 MLOAD 1457 60 PUSH1 0x20 1459 81 DUP2 145A 83 DUP4 145B 03 SUB 145C 03 SUB 145D 81 DUP2 145E 52 MSTORE 145F 90 SWAP1 1460 60 PUSH1 0x40 1462 52 MSTORE 1463 80 DUP1 1464 51 MLOAD 1465 90 SWAP1 1466 60 PUSH1 0x20 1468 01 ADD 1469 20 SHA3 146A 88 DUP9 146B 88 DUP9 146C 88 DUP9 146D 60 PUSH1 0x40 146F 51 MLOAD 1470 60 PUSH1 0x00 1472 81 DUP2 1473 52 MSTORE 1474 60 PUSH1 0x20 1476 01 ADD 1477 60 PUSH1 0x40 1479 52 MSTORE 147A 60 PUSH1 0x40 147C 51 MLOAD 147D 61 PUSH2 0x1489 1480 94 SWAP5 1481 93 SWAP4 1482 92 SWAP3 1483 91 SWAP2 1484 90 SWAP1 1485 61 PUSH2 0x2a5c 1488 56 *JUMP 1489 5B JUMPDEST 148A 60 PUSH1 0x20 148C 60 PUSH1 0x40 148E 51 MLOAD 148F 60 PUSH1 0x20 1491 81 DUP2 1492 03 SUB 1493 90 SWAP1 1494 80 DUP1 1495 84 DUP5 1496 03 SUB 1497 90 SWAP1 1498 85 DUP6 1499 5A GAS 149A FA STATICCALL 149B 15 ISZERO 149C 80 DUP1 149D 15 ISZERO 149E 61 PUSH2 0x14ab 14A1 57 *JUMPI 14A2 3D RETURNDATASIZE 14A3 60 PUSH1 0x00 14A5 80 DUP1 14A6 3E RETURNDATACOPY 14A7 3D RETURNDATASIZE 14A8 60 PUSH1 0x00 14AA FD *REVERT 14AB 5B JUMPDEST 14AC 50 POP 14AD 50 POP 14AE 50 POP 14AF 60 PUSH1 0x20 14B1 60 PUSH1 0x40 14B3 51 MLOAD 14B4 03 SUB 14B5 51 MLOAD 14B6 61 PUSH2 0x0a7a 14B9 56 *JUMP 14BA 5B JUMPDEST 14BB 61 PUSH2 0x14d6 14BE 57 *JUMPI 14BF 60 PUSH1 0x40 14C1 51 MLOAD 14C2 62 PUSH3 0x461bcd 14C6 60 PUSH1 0xe5 14C8 1B SHL 14C9 81 DUP2 14CA 52 MSTORE 14CB 60 PUSH1 0x04 14CD 01 ADD 14CE 61 PUSH2 0x04e6 14D1 90 SWAP1 14D2 61 PUSH2 0x2bbb 14D5 56 *JUMP 14D6 5B JUMPDEST 14D7 61 PUSH2 0x0d6d 14DA 87 DUP8 14DB 84 DUP5 14DC 84 DUP5 14DD 84 DUP5 14DE 61 PUSH2 0x1798 14E1 56 *JUMP 14E2 5B JUMPDEST 14E3 61 PUSH2 0x14f3 14E6 60 PUSH1 0x02 14E8 82 DUP3 14E9 63 PUSH4 0xffffffff 14EE 61 PUSH2 0x1ae6 14F1 16 AND 14F2 56 *JUMP 14F3 5B JUMPDEST 14F4 60 PUSH1 0x40 14F6 51 MLOAD 14F7 60 PUSH1 0x01 14F9 60 PUSH1 0x01 14FB 60 PUSH1 0xa0 14FD 1B SHL 14FE 03 SUB 14FF 82 DUP3 1500 16 AND 1501 90 SWAP1 1502 7F PUSH32 0x47d1c22a25bb3a5d4e481b9b1e6944c2eade3181a0a20b495ed61d35b5323f24 1523 90 SWAP1 1524 60 PUSH1 0x00 1526 90 SWAP1 1527 A2 LOG2 1528 50 POP 1529 56 *JUMP 152A 5B JUMPDEST 152B 60 PUSH1 0x40 152D 51 MLOAD 152E 63 PUSH4 0xf23a6e61 1533 60 PUSH1 0xe0 1535 1B SHL 1536 80 DUP1 1537 82 DUP3 1538 52 MSTORE 1539 90 SWAP1 153A 60 PUSH1 0x01 153C 60 PUSH1 0x01 153E 60 PUSH1 0xa0 1540 1B SHL 1541 03 SUB 1542 86 DUP7 1543 16 AND 1544 90 SWAP1 1545 63 PUSH4 0xf23a6e61 154A 90 SWAP1 154B 61 PUSH2 0x1560 154E 90 SWAP1 154F 8A DUP11 1550 90 SWAP1 1551 8A DUP11 1552 90 SWAP1 1553 89 DUP10 1554 90 SWAP1 1555 89 DUP10 1556 90 SWAP1 1557 89 DUP10 1558 90 SWAP1 1559 60 PUSH1 0x04 155B 01 ADD 155C 61 PUSH2 0x29b4 155F 56 *JUMP 1560 5B JUMPDEST 1561 60 PUSH1 0x20 1563 60 PUSH1 0x40 1565 51 MLOAD 1566 80 DUP1 1567 83 DUP4 1568 03 SUB 1569 81 DUP2 156A 60 PUSH1 0x00 156C 87 DUP8 156D 80 DUP1 156E 3B EXTCODESIZE 156F 15 ISZERO 1570 80 DUP1 1571 15 ISZERO 1572 61 PUSH2 0x157a 1575 57 *JUMPI 1576 60 PUSH1 0x00 1578 80 DUP1 1579 FD *REVERT 157A 5B JUMPDEST 157B 50 POP 157C 5A GAS 157D F1 CALL 157E 15 ISZERO 157F 80 DUP1 1580 15 ISZERO 1581 61 PUSH2 0x158e 1584 57 *JUMPI 1585 3D RETURNDATASIZE 1586 60 PUSH1 0x00 1588 80 DUP1 1589 3E RETURNDATACOPY 158A 3D RETURNDATASIZE 158B 60 PUSH1 0x00 158D FD *REVERT 158E 5B JUMPDEST 158F 50 POP 1590 50 POP 1591 50 POP 1592 50 POP 1593 60 PUSH1 0x40 1595 51 MLOAD 1596 3D RETURNDATASIZE 1597 60 PUSH1 0x1f 1599 19 NOT 159A 60 PUSH1 0x1f 159C 82 DUP3 159D 01 ADD 159E 16 AND 159F 82 DUP3 15A0 01 ADD 15A1 80 DUP1 15A2 60 PUSH1 0x40 15A4 52 MSTORE 15A5 50 POP 15A6 61 PUSH2 0x15b2 15A9 91 SWAP2 15AA 90 SWAP1 15AB 81 DUP2 15AC 01 ADD 15AD 90 SWAP1 15AE 61 PUSH2 0x20f0 15B1 56 *JUMP 15B2 5B JUMPDEST 15B3 60 PUSH1 0x01 15B5 60 PUSH1 0x01 15B7 60 PUSH1 0xe0 15B9 1B SHL 15BA 03 SUB 15BB 19 NOT 15BC 16 AND 15BD 14 EQ 15BE 61 PUSH2 0x100b 15C1 57 *JUMPI 15C2 60 PUSH1 0x40 15C4 51 MLOAD 15C5 62 PUSH3 0x461bcd 15C9 60 PUSH1 0xe5 15CB 1B SHL 15CC 81 DUP2 15CD 52 MSTORE 15CE 60 PUSH1 0x04 15D0 01 ADD 15D1 61 PUSH2 0x04e6 15D4 90 SWAP1 15D5 61 PUSH2 0x2b9b 15D8 56 *JUMP 15D9 5B JUMPDEST 15DA 60 PUSH1 0x01 15DC 60 PUSH1 0x01 15DE 60 PUSH1 0xa0 15E0 1B SHL 15E1 03 SUB 15E2 81 DUP2 15E3 16 AND 15E4 61 PUSH2 0x15ff 15E7 57 *JUMPI 15E8 60 PUSH1 0x40 15EA 51 MLOAD 15EB 62 PUSH3 0x461bcd 15EF 60 PUSH1 0xe5 15F1 1B SHL 15F2 81 DUP2 15F3 52 MSTORE 15F4 60 PUSH1 0x04 15F6 01 ADD 15F7 61 PUSH2 0x04e6 15FA 90 SWAP1 15FB 61 PUSH2 0x2acb 15FE 56 *JUMP 15FF 5B JUMPDEST 1600 60 PUSH1 0x01 1602 54 SLOAD 1603 60 PUSH1 0x40 1605 51 MLOAD 1606 60 PUSH1 0x01 1608 60 PUSH1 0x01 160A 60 PUSH1 0xa0 160C 1B SHL 160D 03 SUB 160E 80 DUP1 160F 84 DUP5 1610 16 AND 1611 92 SWAP3 1612 16 AND 1613 90 SWAP1 1614 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1635 90 SWAP1 1636 60 PUSH1 0x00 1638 90 SWAP1 1639 A3 LOG3 163A 60 PUSH1 0x01 163C 80 DUP1 163D 54 SLOAD 163E 60 PUSH1 0x01 1640 60 PUSH1 0x01 1642 60 PUSH1 0xa0 1644 1B SHL 1645 03 SUB 1646 19 NOT 1647 16 AND 1648 60 PUSH1 0x01 164A 60 PUSH1 0x01 164C 60 PUSH1 0xa0 164E 1B SHL 164F 03 SUB 1650 92 SWAP3 1651 90 SWAP1 1652 92 SWAP3 1653 16 AND 1654 91 SWAP2 1655 90 SWAP1 1656 91 SWAP2 1657 17 OR 1658 90 SWAP1 1659 55 SSTORE 165A 56 *JUMP label_165B: // Incoming call from 0x1148, returns to 0x1149 // Inputs[2] // { // @165F stack[-2] // @1660 stack[-1] // } 165B 5B JUMPDEST 165C 61 PUSH2 0x1665 165F 82 DUP3 1660 82 DUP3 1661 61 PUSH2 0x13c5 1664 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @165C stack[0] = 0x1665 // @165F stack[1] = stack[-2] // @1660 stack[2] = stack[-1] // } // Block ends with call to 0x13c5, returns to 0x1665 label_1665: // Incoming return from call to 0x13C5 at 0x1664 // Inputs[1] { @1669 stack[-1] } 1665 5B JUMPDEST 1666 61 PUSH2 0x1681 1669 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1681, if stack[-1] label_166A: // Incoming jump from 0x1669, if not stack[-1] // Inputs[1] { @166C memory[0x40:0x60] } 166A 60 PUSH1 0x40 166C 51 MLOAD 166D 62 PUSH3 0x461bcd 1671 60 PUSH1 0xe5 1673 1B SHL 1674 81 DUP2 1675 52 MSTORE 1676 60 PUSH1 0x04 1678 01 ADD 1679 61 PUSH2 0x04e6 167C 90 SWAP1 167D 61 PUSH2 0x2afb 1680 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1675 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @167C stack[0] = 0x04e6 // @167C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2afb label_1681: // Incoming jump from 0x1669, if stack[-1] // Inputs[5] // { // @168A stack[-1] // @1692 stack[-2] // @1699 memory[0x00:0x40] // @169B storage[keccak256(memory[0x00:0x40])] // @16A2 stack[-3] // } 1681 5B JUMPDEST 1682 60 PUSH1 0x01 1684 60 PUSH1 0x01 1686 60 PUSH1 0xa0 1688 1B SHL 1689 03 SUB 168A 16 AND 168B 60 PUSH1 0x00 168D 90 SWAP1 168E 81 DUP2 168F 52 MSTORE 1690 60 PUSH1 0x20 1692 91 SWAP2 1693 90 SWAP1 1694 91 SWAP2 1695 52 MSTORE 1696 60 PUSH1 0x40 1698 90 SWAP1 1699 20 SHA3 169A 80 DUP1 169B 54 SLOAD 169C 60 PUSH1 0xff 169E 19 NOT 169F 16 AND 16A0 90 SWAP1 16A1 55 SSTORE 16A2 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @168F memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1695 memory[0x20:0x40] = stack[-2] // @16A1 storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] 16A3 5B JUMPDEST 16A4 60 PUSH1 0x60 16A6 80 DUP1 16A7 83 DUP4 16A8 90 SWAP1 16A9 50 POP 16AA 60 PUSH1 0x60 16AC 83 DUP4 16AD 90 SWAP1 16AE 50 POP 16AF 60 PUSH1 0x60 16B1 81 DUP2 16B2 51 MLOAD 16B3 83 DUP4 16B4 51 MLOAD 16B5 01 ADD 16B6 60 PUSH1 0x40 16B8 51 MLOAD 16B9 90 SWAP1 16BA 80 DUP1 16BB 82 DUP3 16BC 52 MSTORE 16BD 80 DUP1 16BE 60 PUSH1 0x1f 16C0 01 ADD 16C1 60 PUSH1 0x1f 16C3 19 NOT 16C4 16 AND 16C5 60 PUSH1 0x20 16C7 01 ADD 16C8 82 DUP3 16C9 01 ADD 16CA 60 PUSH1 0x40 16CC 52 MSTORE 16CD 80 DUP1 16CE 15 ISZERO 16CF 61 PUSH2 0x16df 16D2 57 *JUMPI 16D3 60 PUSH1 0x20 16D5 82 DUP3 16D6 01 ADD 16D7 81 DUP2 16D8 80 DUP1 16D9 38 CODESIZE 16DA 83 DUP4 16DB 39 CODECOPY 16DC 01 ADD 16DD 90 SWAP1 16DE 50 POP 16DF 5B JUMPDEST 16E0 50 POP 16E1 90 SWAP1 16E2 50 POP 16E3 60 PUSH1 0x00 16E5 80 DUP1 16E6 5B JUMPDEST 16E7 84 DUP5 16E8 51 MLOAD 16E9 81 DUP2 16EA 10 LT 16EB 15 ISZERO 16EC 61 PUSH2 0x1737 16EF 57 *JUMPI 16F0 84 DUP5 16F1 81 DUP2 16F2 81 DUP2 16F3 51 MLOAD 16F4 81 DUP2 16F5 10 LT 16F6 61 PUSH2 0x16fb 16F9 57 *JUMPI 16FA FE *ASSERT 16FB 5B JUMPDEST 16FC 60 PUSH1 0x20 16FE 01 ADD 16FF 01 ADD 1700 51 MLOAD 1701 60 PUSH1 0xf8 1703 1C SHR 1704 60 PUSH1 0xf8 1706 1B SHL 1707 83 DUP4 1708 83 DUP4 1709 80 DUP1 170A 60 PUSH1 0x01 170C 01 ADD 170D 94 SWAP5 170E 50 POP 170F 81 DUP2 1710 51 MLOAD 1711 81 DUP2 1712 10 LT 1713 61 PUSH2 0x1718 1716 57 *JUMPI 1717 FE *ASSERT 1718 5B JUMPDEST 1719 60 PUSH1 0x20 171B 01 ADD 171C 01 ADD 171D 90 SWAP1 171E 60 PUSH1 0x01 1720 60 PUSH1 0x01 1722 60 PUSH1 0xf8 1724 1B SHL 1725 03 SUB 1726 19 NOT 1727 16 AND 1728 90 SWAP1 1729 81 DUP2 172A 60 PUSH1 0x00 172C 1A BYTE 172D 90 SWAP1 172E 53 MSTORE8 172F 50 POP 1730 60 PUSH1 0x01 1732 01 ADD 1733 61 PUSH2 0x16e6 1736 56 *JUMP 1737 5B JUMPDEST 1738 50 POP 1739 60 PUSH1 0x00 173B 5B JUMPDEST 173C 83 DUP4 173D 51 MLOAD 173E 81 DUP2 173F 10 LT 1740 15 ISZERO 1741 61 PUSH2 0x178c 1744 57 *JUMPI 1745 83 DUP4 1746 81 DUP2 1747 81 DUP2 1748 51 MLOAD 1749 81 DUP2 174A 10 LT 174B 61 PUSH2 0x1750 174E 57 *JUMPI 174F FE *ASSERT 1750 5B JUMPDEST 1751 60 PUSH1 0x20 1753 01 ADD 1754 01 ADD 1755 51 MLOAD 1756 60 PUSH1 0xf8 1758 1C SHR 1759 60 PUSH1 0xf8 175B 1B SHL 175C 83 DUP4 175D 83 DUP4 175E 80 DUP1 175F 60 PUSH1 0x01 1761 01 ADD 1762 94 SWAP5 1763 50 POP 1764 81 DUP2 1765 51 MLOAD 1766 81 DUP2 1767 10 LT 1768 61 PUSH2 0x176d 176B 57 *JUMPI 176C FE *ASSERT 176D 5B JUMPDEST 176E 60 PUSH1 0x20 1770 01 ADD 1771 01 ADD 1772 90 SWAP1 1773 60 PUSH1 0x01 1775 60 PUSH1 0x01 1777 60 PUSH1 0xf8 1779 1B SHL 177A 03 SUB 177B 19 NOT 177C 16 AND 177D 90 SWAP1 177E 81 DUP2 177F 60 PUSH1 0x00 1781 1A BYTE 1782 90 SWAP1 1783 53 MSTORE8 1784 50 POP 1785 60 PUSH1 0x01 1787 01 ADD 1788 61 PUSH2 0x173b 178B 56 *JUMP 178C 5B JUMPDEST 178D 50 POP 178E 90 SWAP1 178F 96 SWAP7 1790 95 SWAP6 1791 50 POP 1792 50 POP 1793 50 POP 1794 50 POP 1795 50 POP 1796 50 POP 1797 56 *JUMP 1798 5B JUMPDEST 1799 60 PUSH1 0x00 179B 84 DUP5 179C 81 DUP2 179D 52 MSTORE 179E 60 PUSH1 0x08 17A0 60 PUSH1 0x20 17A2 52 MSTORE 17A3 60 PUSH1 0x40 17A5 90 SWAP1 17A6 20 SHA3 17A7 54 SLOAD 17A8 60 PUSH1 0x01 17AA 60 PUSH1 0x01 17AC 60 PUSH1 0xa0 17AE 1B SHL 17AF 03 SUB 17B0 16 AND 17B1 15 ISZERO 17B2 61 PUSH2 0x17cd 17B5 57 *JUMPI 17B6 60 PUSH1 0x40 17B8 51 MLOAD 17B9 62 PUSH3 0x461bcd 17BD 60 PUSH1 0xe5 17BF 1B SHL 17C0 81 DUP2 17C1 52 MSTORE 17C2 60 PUSH1 0x04 17C4 01 ADD 17C5 61 PUSH2 0x04e6 17C8 90 SWAP1 17C9 61 PUSH2 0x2b5b 17CC 56 *JUMP 17CD 5B JUMPDEST 17CE 81 DUP2 17CF 61 PUSH2 0x17ea 17D2 57 *JUMPI 17D3 60 PUSH1 0x40 17D5 51 MLOAD 17D6 62 PUSH3 0x461bcd 17DA 60 PUSH1 0xe5 17DC 1B SHL 17DD 81 DUP2 17DE 52 MSTORE 17DF 60 PUSH1 0x04 17E1 01 ADD 17E2 61 PUSH2 0x04e6 17E5 90 SWAP1 17E6 61 PUSH2 0x2b6b 17E9 56 *JUMP 17EA 5B JUMPDEST 17EB 60 PUSH1 0x00 17ED 81 DUP2 17EE 51 MLOAD 17EF 11 GT 17F0 61 PUSH2 0x180b 17F3 57 *JUMPI 17F4 60 PUSH1 0x40 17F6 51 MLOAD 17F7 62 PUSH3 0x461bcd 17FB 60 PUSH1 0xe5 17FD 1B SHL 17FE 81 DUP2 17FF 52 MSTORE 1800 60 PUSH1 0x04 1802 01 ADD 1803 61 PUSH2 0x04e6 1806 90 SWAP1 1807 61 PUSH2 0x2bcb 180A 56 *JUMP 180B 5B JUMPDEST 180C 60 PUSH1 0x00 180E 84 DUP5 180F 81 DUP2 1810 52 MSTORE 1811 60 PUSH1 0x08 1813 60 PUSH1 0x20 1815 90 SWAP1 1816 81 DUP2 1817 52 MSTORE 1818 60 PUSH1 0x40 181A 91 SWAP2 181B 82 DUP3 181C 90 SWAP1 181D 20 SHA3 181E 80 DUP1 181F 54 SLOAD 1820 60 PUSH1 0x01 1822 60 PUSH1 0x01 1824 60 PUSH1 0xa0 1826 1B SHL 1827 03 SUB 1828 19 NOT 1829 16 AND 182A 33 CALLER 182B 17 OR 182C 90 SWAP1 182D 55 SSTORE 182E 84 DUP5 182F 51 MLOAD 1830 82 DUP3 1831 51 MLOAD 1832 81 DUP2 1833 81 DUP2 1834 52 MSTORE 1835 81 DUP2 1836 83 DUP4 1837 02 MUL 1838 81 DUP2 1839 01 ADD 183A 90 SWAP1 183B 92 SWAP3 183C 01 ADD 183D 90 SWAP1 183E 92 SWAP3 183F 52 MSTORE 1840 60 PUSH1 0x60 1842 91 SWAP2 1843 80 DUP1 1844 15 ISZERO 1845 61 PUSH2 0x1858 1848 57 *JUMPI 1849 81 DUP2 184A 60 PUSH1 0x20 184C 01 ADD 184D 60 PUSH1 0x20 184F 82 DUP3 1850 02 MUL 1851 80 DUP1 1852 38 CODESIZE 1853 83 DUP4 1854 39 CODECOPY 1855 01 ADD 1856 90 SWAP1 1857 50 POP 1858 5B JUMPDEST 1859 50 POP 185A 90 SWAP1 185B 50 POP 185C 60 PUSH1 0x60 185E 84 DUP5 185F 51 MLOAD 1860 60 PUSH1 0x40 1862 51 MLOAD 1863 90 SWAP1 1864 80 DUP1 1865 82 DUP3 1866 52 MSTORE 1867 80 DUP1 1868 60 PUSH1 0x20 186A 02 MUL 186B 60 PUSH1 0x20 186D 01 ADD 186E 82 DUP3 186F 01 ADD 1870 60 PUSH1 0x40 1872 52 MSTORE 1873 80 DUP1 1874 15 ISZERO 1875 61 PUSH2 0x1888 1878 57 *JUMPI 1879 81 DUP2 187A 60 PUSH1 0x20 187C 01 ADD 187D 60 PUSH1 0x20 187F 82 DUP3 1880 02 MUL 1881 80 DUP1 1882 38 CODESIZE 1883 83 DUP4 1884 39 CODECOPY 1885 01 ADD 1886 90 SWAP1 1887 50 POP 1888 5B JUMPDEST 1889 50 POP 188A 90 SWAP1 188B 50 POP 188C 60 PUSH1 0x00 188E 5B JUMPDEST 188F 85 DUP6 1890 51 MLOAD 1891 81 DUP2 1892 10 LT 1893 15 ISZERO 1894 61 PUSH2 0x19fb 1897 57 *JUMPI 1898 60 PUSH1 0x00 189A 60 PUSH1 0x01 189C 60 PUSH1 0x01 189E 60 PUSH1 0xa0 18A0 1B SHL 18A1 03 SUB 18A2 16 AND 18A3 86 DUP7 18A4 82 DUP3 18A5 81 DUP2 18A6 51 MLOAD 18A7 81 DUP2 18A8 10 LT 18A9 61 PUSH2 0x18ae 18AC 57 *JUMPI 18AD FE *ASSERT 18AE 5B JUMPDEST 18AF 60 PUSH1 0x20 18B1 02 MUL 18B2 60 PUSH1 0x20 18B4 01 ADD 18B5 01 ADD 18B6 51 MLOAD 18B7 60 PUSH1 0x00 18B9 01 ADD 18BA 51 MLOAD 18BB 60 PUSH1 0x01 18BD 60 PUSH1 0x01 18BF 60 PUSH1 0xa0 18C1 1B SHL 18C2 03 SUB 18C3 16 AND 18C4 14 EQ 18C5 15 ISZERO 18C6 61 PUSH2 0x18e1 18C9 57 *JUMPI 18CA 60 PUSH1 0x40 18CC 51 MLOAD 18CD 62 PUSH3 0x461bcd 18D1 60 PUSH1 0xe5 18D3 1B SHL 18D4 81 DUP2 18D5 52 MSTORE 18D6 60 PUSH1 0x04 18D8 01 ADD 18D9 61 PUSH2 0x04e6 18DC 90 SWAP1 18DD 61 PUSH2 0x2b8b 18E0 56 *JUMP 18E1 5B JUMPDEST 18E2 85 DUP6 18E3 81 DUP2 18E4 81 DUP2 18E5 51 MLOAD 18E6 81 DUP2 18E7 10 LT 18E8 61 PUSH2 0x18ed 18EB 57 *JUMPI 18EC FE *ASSERT 18ED 5B JUMPDEST 18EE 60 PUSH1 0x20 18F0 02 MUL 18F1 60 PUSH1 0x20 18F3 01 ADD 18F4 01 ADD 18F5 51 MLOAD 18F6 60 PUSH1 0x20 18F8 01 ADD 18F9 51 MLOAD 18FA 60 PUSH1 0x00 18FC 14 EQ 18FD 15 ISZERO 18FE 61 PUSH2 0x1919 1901 57 *JUMPI 1902 60 PUSH1 0x40 1904 51 MLOAD 1905 62 PUSH3 0x461bcd 1909 60 PUSH1 0xe5 190B 1B SHL 190C 81 DUP2 190D 52 MSTORE 190E 60 PUSH1 0x04 1910 01 ADD 1911 61 PUSH2 0x04e6 1914 90 SWAP1 1915 61 PUSH2 0x2aab 1918 56 *JUMP 1919 5B JUMPDEST 191A 60 PUSH1 0x00 191C 87 DUP8 191D 81 DUP2 191E 52 MSTORE 191F 60 PUSH1 0x09 1921 60 PUSH1 0x20 1923 52 MSTORE 1924 60 PUSH1 0x40 1926 90 SWAP1 1927 20 SHA3 1928 86 DUP7 1929 51 MLOAD 192A 87 DUP8 192B 90 SWAP1 192C 83 DUP4 192D 90 SWAP1 192E 81 DUP2 192F 10 LT 1930 61 PUSH2 0x1935 1933 57 *JUMPI 1934 FE *ASSERT 1935 5B JUMPDEST 1936 60 PUSH1 0x20 1938 90 SWAP1 1939 81 DUP2 193A 02 MUL 193B 91 SWAP2 193C 90 SWAP1 193D 91 SWAP2 193E 01 ADD 193F 81 DUP2 1940 01 ADD 1941 51 MLOAD 1942 82 DUP3 1943 54 SLOAD 1944 60 PUSH1 0x01 1946 80 DUP1 1947 82 DUP3 1948 01 ADD 1949 85 DUP6 194A 55 SSTORE 194B 60 PUSH1 0x00 194D 94 SWAP5 194E 85 DUP6 194F 52 MSTORE 1950 93 SWAP4 1951 83 DUP4 1952 90 SWAP1 1953 20 SHA3 1954 82 DUP3 1955 51 MLOAD 1956 60 PUSH1 0x02 1958 90 SWAP1 1959 92 SWAP3 195A 02 MUL 195B 01 ADD 195C 80 DUP1 195D 54 SLOAD 195E 60 PUSH1 0x01 1960 60 PUSH1 0x01 1962 60 PUSH1 0xa0 1964 1B SHL 1965 03 SUB 1966 19 NOT 1967 16 AND 1968 60 PUSH1 0x01 196A 60 PUSH1 0x01 196C 60 PUSH1 0xa0 196E 1B SHL 196F 03 SUB 1970 90 SWAP1 1971 92 SWAP3 1972 16 AND 1973 91 SWAP2 1974 90 SWAP1 1975 91 SWAP2 1976 17 OR 1977 81 DUP2 1978 55 SSTORE 1979 91 SWAP2 197A 01 ADD 197B 51 MLOAD 197C 91 SWAP2 197D 01 ADD 197E 55 SSTORE 197F 85 DUP6 1980 51 MLOAD 1981 86 DUP7 1982 90 SWAP1 1983 82 DUP3 1984 90 SWAP1 1985 81 DUP2 1986 10 LT 1987 61 PUSH2 0x198c 198A 57 *JUMPI 198B FE *ASSERT 198C 5B JUMPDEST 198D 60 PUSH1 0x20 198F 02 MUL 1990 60 PUSH1 0x20 1992 01 ADD 1993 01 ADD 1994 51 MLOAD 1995 60 PUSH1 0x00 1997 01 ADD 1998 51 MLOAD 1999 83 DUP4 199A 82 DUP3 199B 81 DUP2 199C 51 MLOAD 199D 81 DUP2 199E 10 LT 199F 61 PUSH2 0x19a4 19A2 57 *JUMPI 19A3 FE *ASSERT 19A4 5B JUMPDEST 19A5 60 PUSH1 0x20 19A7 02 MUL 19A8 60 PUSH1 0x20 19AA 01 ADD 19AB 01 ADD 19AC 90 SWAP1 19AD 60 PUSH1 0x01 19AF 60 PUSH1 0x01 19B1 60 PUSH1 0xa0 19B3 1B SHL 19B4 03 SUB 19B5 16 AND 19B6 90 SWAP1 19B7 81 DUP2 19B8 60 PUSH1 0x01 19BA 60 PUSH1 0x01 19BC 60 PUSH1 0xa0 19BE 1B SHL 19BF 03 SUB 19C0 16 AND 19C1 81 DUP2 19C2 52 MSTORE 19C3 50 POP 19C4 50 POP 19C5 85 DUP6 19C6 81 DUP2 19C7 81 DUP2 19C8 51 MLOAD 19C9 81 DUP2 19CA 10 LT 19CB 61 PUSH2 0x19d0 19CE 57 *JUMPI 19CF FE *ASSERT 19D0 5B JUMPDEST 19D1 60 PUSH1 0x20 19D3 02 MUL 19D4 60 PUSH1 0x20 19D6 01 ADD 19D7 01 ADD 19D8 51 MLOAD 19D9 60 PUSH1 0x20 19DB 01 ADD 19DC 51 MLOAD 19DD 82 DUP3 19DE 82 DUP3 19DF 81 DUP2 19E0 51 MLOAD 19E1 81 DUP2 19E2 10 LT 19E3 61 PUSH2 0x19e8 19E6 57 *JUMPI 19E7 FE *ASSERT 19E8 5B JUMPDEST 19E9 60 PUSH1 0x20 19EB 90 SWAP1 19EC 81 DUP2 19ED 02 MUL 19EE 91 SWAP2 19EF 90 SWAP1 19F0 91 SWAP2 19F1 01 ADD 19F2 01 ADD 19F3 52 MSTORE 19F4 60 PUSH1 0x01 19F6 01 ADD 19F7 61 PUSH2 0x188e 19FA 56 *JUMP 19FB 5B JUMPDEST 19FC 50 POP 19FD 84 DUP5 19FE 51 MLOAD 19FF 15 ISZERO 1A00 61 PUSH2 0x1a3f 1A03 57 *JUMPI 1A04 7F PUSH32 0x99aba1d63749cfd5ad1afda7c4663840924d54eb5f005bbbeadedc6ec13674b2 1A25 86 DUP7 1A26 83 DUP4 1A27 83 DUP4 1A28 60 PUSH1 0x40 1A2A 51 MLOAD 1A2B 61 PUSH2 0x1a36 1A2E 93 SWAP4 1A2F 92 SWAP3 1A30 91 SWAP2 1A31 90 SWAP1 1A32 61 PUSH2 0x2be9 1A35 56 *JUMP 1A36 5B JUMPDEST 1A37 60 PUSH1 0x40 1A39 51 MLOAD 1A3A 80 DUP1 1A3B 91 SWAP2 1A3C 03 SUB 1A3D 90 SWAP1 1A3E A1 LOG1 1A3F 5B JUMPDEST 1A40 60 PUSH1 0x00 1A42 86 DUP7 1A43 81 DUP2 1A44 52 MSTORE 1A45 60 PUSH1 0x06 1A47 60 PUSH1 0x20 1A49 90 SWAP1 1A4A 81 DUP2 1A4B 52 MSTORE 1A4C 60 PUSH1 0x40 1A4E 80 DUP1 1A4F 83 DUP4 1A50 20 SHA3 1A51 33 CALLER 1A52 84 DUP5 1A53 52 MSTORE 1A54 90 SWAP1 1A55 91 SWAP2 1A56 52 MSTORE 1A57 90 SWAP1 1A58 20 SHA3 1A59 84 DUP5 1A5A 90 SWAP1 1A5B 55 SSTORE 1A5C 61 PUSH2 0x1a65 1A5F 86 DUP7 1A60 84 DUP5 1A61 61 PUSH2 0x1b32 1A64 56 *JUMP 1A65 5B JUMPDEST 1A66 60 PUSH1 0x40 1A68 51 MLOAD 1A69 33 CALLER 1A6A 90 SWAP1 1A6B 60 PUSH1 0x00 1A6D 90 SWAP1 1A6E 82 DUP3 1A6F 90 SWAP1 1A70 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 1A91 90 SWAP1 1A92 61 PUSH2 0x1a9e 1A95 90 SWAP1 1A96 8B DUP12 1A97 90 SWAP1 1A98 8A DUP11 1A99 90 SWAP1 1A9A 61 PUSH2 0x2c1d 1A9D 56 *JUMP 1A9E 5B JUMPDEST 1A9F 60 PUSH1 0x40 1AA1 51 MLOAD 1AA2 80 DUP1 1AA3 91 SWAP2 1AA4 03 SUB 1AA5 90 SWAP1 1AA6 A4 LOG4 1AA7 85 DUP6 1AA8 7F PUSH32 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b 1AC9 84 DUP5 1ACA 60 PUSH1 0x40 1ACC 51 MLOAD 1ACD 61 PUSH2 0x1ad6 1AD0 91 SWAP2 1AD1 90 SWAP1 1AD2 61 PUSH2 0x2a9a 1AD5 56 *JUMP 1AD6 5B JUMPDEST 1AD7 60 PUSH1 0x40 1AD9 51 MLOAD 1ADA 80 DUP1 1ADB 91 SWAP2 1ADC 03 SUB 1ADD 90 SWAP1 1ADE A2 LOG2 1ADF 50 POP 1AE0 50 POP 1AE1 50 POP 1AE2 50 POP 1AE3 50 POP 1AE4 50 POP 1AE5 56 *JUMP 1AE6 5B JUMPDEST 1AE7 61 PUSH2 0x1af0 1AEA 82 DUP3 1AEB 82 DUP3 1AEC 61 PUSH2 0x13c5 1AEF 56 *JUMP 1AF0 5B JUMPDEST 1AF1 15 ISZERO 1AF2 61 PUSH2 0x1b0d 1AF5 57 *JUMPI 1AF6 60 PUSH1 0x40 1AF8 51 MLOAD 1AF9 62 PUSH3 0x461bcd 1AFD 60 PUSH1 0xe5 1AFF 1B SHL 1B00 81 DUP2 1B01 52 MSTORE 1B02 60 PUSH1 0x04 1B04 01 ADD 1B05 61 PUSH2 0x04e6 1B08 90 SWAP1 1B09 61 PUSH2 0x2abb 1B0C 56 *JUMP 1B0D 5B JUMPDEST 1B0E 60 PUSH1 0x01 1B10 60 PUSH1 0x01 1B12 60 PUSH1 0xa0 1B14 1B SHL 1B15 03 SUB 1B16 16 AND 1B17 60 PUSH1 0x00 1B19 90 SWAP1 1B1A 81 DUP2 1B1B 52 MSTORE 1B1C 60 PUSH1 0x20 1B1E 91 SWAP2 1B1F 90 SWAP1 1B20 91 SWAP2 1B21 52 MSTORE 1B22 60 PUSH1 0x40 1B24 90 SWAP1 1B25 20 SHA3 1B26 80 DUP1 1B27 54 SLOAD 1B28 60 PUSH1 0xff 1B2A 19 NOT 1B2B 16 AND 1B2C 60 PUSH1 0x01 1B2E 17 OR 1B2F 90 SWAP1 1B30 55 SSTORE 1B31 56 *JUMP 1B32 5B JUMPDEST 1B33 60 PUSH1 0x00 1B35 82 DUP3 1B36 81 DUP2 1B37 52 MSTORE 1B38 60 PUSH1 0x08 1B3A 60 PUSH1 0x20 1B3C 52 MSTORE 1B3D 60 PUSH1 0x40 1B3F 90 SWAP1 1B40 20 SHA3 1B41 54 SLOAD 1B42 60 PUSH1 0x01 1B44 60 PUSH1 0x01 1B46 60 PUSH1 0xa0 1B48 1B SHL 1B49 03 SUB 1B4A 16 AND 1B4B 61 PUSH2 0x1b66 1B4E 57 *JUMPI 1B4F 60 PUSH1 0x40 1B51 51 MLOAD 1B52 62 PUSH3 0x461bcd 1B56 60 PUSH1 0xe5 1B58 1B SHL 1B59 81 DUP2 1B5A 52 MSTORE 1B5B 60 PUSH1 0x04 1B5D 01 ADD 1B5E 61 PUSH2 0x04e6 1B61 90 SWAP1 1B62 61 PUSH2 0x2adb 1B65 56 *JUMP 1B66 5B JUMPDEST 1B67 61 PUSH2 0x1424 1B6A 82 DUP3 1B6B 82 DUP3 1B6C 60 PUSH1 0x00 1B6E 82 DUP3 1B6F 81 DUP2 1B70 52 MSTORE 1B71 60 PUSH1 0x04 1B73 60 PUSH1 0x20 1B75 90 SWAP1 1B76 81 DUP2 1B77 52 MSTORE 1B78 60 PUSH1 0x40 1B7A 90 SWAP1 1B7B 91 SWAP2 1B7C 20 SHA3 1B7D 82 DUP3 1B7E 51 MLOAD 1B7F 61 PUSH2 0x1b8a 1B82 92 SWAP3 1B83 84 DUP5 1B84 01 ADD 1B85 90 SWAP1 1B86 61 PUSH2 0x1b8f 1B89 56 *JUMP 1B8A 5B JUMPDEST 1B8B 50 POP 1B8C 50 POP 1B8D 50 POP 1B8E 56 *JUMP label_1B8F: // Incoming jump from 0x143A // Incoming jump from 0x1423 // Inputs[5] // { // @1B90 stack[-3] // @1B92 storage[stack[-3]] // @1BAC memory[0x00:0x20] // @1BB7 stack[-2] // @1BB8 stack[-1] // } 1B8F 5B JUMPDEST 1B90 82 DUP3 1B91 80 DUP1 1B92 54 SLOAD 1B93 60 PUSH1 0x01 1B95 81 DUP2 1B96 60 PUSH1 0x01 1B98 16 AND 1B99 15 ISZERO 1B9A 61 PUSH2 0x0100 1B9D 02 MUL 1B9E 03 SUB 1B9F 16 AND 1BA0 60 PUSH1 0x02 1BA2 90 SWAP1 1BA3 04 DIV 1BA4 90 SWAP1 1BA5 60 PUSH1 0x00 1BA7 52 MSTORE 1BA8 60 PUSH1 0x20 1BAA 60 PUSH1 0x00 1BAC 20 SHA3 1BAD 90 SWAP1 1BAE 60 PUSH1 0x1f 1BB0 01 ADD 1BB1 60 PUSH1 0x20 1BB3 90 SWAP1 1BB4 04 DIV 1BB5 81 DUP2 1BB6 01 ADD 1BB7 92 SWAP3 1BB8 82 DUP3 1BB9 60 PUSH1 0x1f 1BBB 10 LT 1BBC 61 PUSH2 0x1bd0 1BBF 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1BA7 memory[0x00:0x20] = stack[-3] // @1BAD stack[0] = keccak256(memory[0x00:0x20]) // @1BB7 stack[1] = stack[-2] // @1BB7 stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x1bd0, if 0x1f < stack[-1] label_1BC0: // Incoming jump from 0x1BBF, if not 0x1f < stack[-1] // Inputs[4] // { // @1BC0 stack[-1] // @1BC1 memory[stack[-1]:stack[-1] + 0x20] // @1BC6 stack[-3] // @1BCA stack[-5] // } 1BC0 80 DUP1 1BC1 51 MLOAD 1BC2 60 PUSH1 0xff 1BC4 19 NOT 1BC5 16 AND 1BC6 83 DUP4 1BC7 80 DUP1 1BC8 01 ADD 1BC9 17 OR 1BCA 85 DUP6 1BCB 55 SSTORE 1BCC 61 PUSH2 0x1bfd 1BCF 56 *JUMP // Stack delta = +0 // Outputs[1] { @1BCB storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x1bfd label_1BD0: // Incoming jump from 0x1BBF, if 0x1f < stack[-1] // Inputs[2] // { // @1BD1 stack[-3] // @1BD7 stack[-5] // } 1BD0 5B JUMPDEST 1BD1 82 DUP3 1BD2 80 DUP1 1BD3 01 ADD 1BD4 60 PUSH1 0x01 1BD6 01 ADD 1BD7 85 DUP6 1BD8 55 SSTORE 1BD9 82 DUP3 1BDA 15 ISZERO 1BDB 61 PUSH2 0x1bfd 1BDE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1BD8 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1bfd, if !stack[-3] label_1BDF: // Incoming jump from 0x1BDE, if not !stack[-3] // Inputs[2] // { // @1BDF stack[-3] // @1BDF stack[-1] // } 1BDF 91 SWAP2 1BE0 82 DUP3 1BE1 01 ADD 1BE2 5B JUMPDEST 1BE3 82 DUP3 1BE4 81 DUP2 1BE5 11 GT 1BE6 15 ISZERO 1BE7 61 PUSH2 0x1bfd 1BEA 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1BDF stack[-3] = stack[-1] // @1BE1 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1bfd, if !(stack[-1] + stack[-3] > stack[-1]) label_1BEB: // Incoming jump from 0x1BEA, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x1BEA, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @1BEB stack[-3] // @1BEC memory[stack[-3]:stack[-3] + 0x20] // @1BED stack[-2] // @1BEF stack[-1] // } 1BEB 82 DUP3 1BEC 51 MLOAD 1BED 82 DUP3 1BEE 55 SSTORE 1BEF 91 SWAP2 1BF0 60 PUSH1 0x20 1BF2 01 ADD 1BF3 91 SWAP2 1BF4 90 SWAP1 1BF5 60 PUSH1 0x01 1BF7 01 ADD 1BF8 90 SWAP1 1BF9 61 PUSH2 0x1be2 1BFC 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1BEE storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1BF3 stack[-3] = 0x20 + stack[-3] // @1BF8 stack[-2] = 0x01 + stack[-2] // @1BF8 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1be2 label_1BFD: // Incoming jump from 0x1BEA, if !(stack[-1] > stack[-3]) // Incoming jump from 0x1BDE, if !stack[-3] // Incoming jump from 0x1BEA, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1BCF // Inputs[2] // { // @1C02 stack[-4] // @1C03 stack[-3] // } 1BFD 5B JUMPDEST 1BFE 50 POP 1BFF 61 PUSH2 0x1c09 1C02 92 SWAP3 1C03 91 SWAP2 1C04 50 POP 1C05 61 PUSH2 0x1c0d 1C08 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1C02 stack[-4] = 0x1c09 // @1C03 stack[-3] = stack[-4] // } // Block ends with call to 0x1c0d, returns to 0x1C09 label_1C09: // Incoming call from 0x1C1B, returns to 0x0A9A, if !(stack[-2] > stack[-1]) // Incoming jump from 0x1C1B, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x1C0D at 0x1C08 // Inputs[2] // { // @1C0B stack[-2] // @1C0B stack[-3] // } 1C09 5B JUMPDEST 1C0A 50 POP 1C0B 90 SWAP1 1C0C 56 *JUMP // Stack delta = -2 // Outputs[1] { @1C0B stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1C0D: // Incoming call from 0x1C08, returns to 0x1C09 // Inputs[2] // { // @1C11 stack[-2] // @1C12 stack[-1] // } 1C0D 5B JUMPDEST 1C0E 61 PUSH2 0x0a9a 1C11 91 SWAP2 1C12 90 SWAP1 1C13 5B JUMPDEST 1C14 80 DUP1 1C15 82 DUP3 1C16 11 GT 1C17 15 ISZERO 1C18 61 PUSH2 0x1c09 1C1B 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1C11 stack[-2] = 0x0a9a // @1C12 stack[-1] = stack[-2] // @1C12 stack[0] = stack[-1] // } // Block ends with conditional call to 0x1c09, returns to 0x0A9A, if !(stack[-2] > stack[-1]) label_1C1C: // Incoming jump from 0x1C1B, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1C1B, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1C1E stack[-1] } 1C1C 60 PUSH1 0x00 1C1E 81 DUP2 1C1F 55 SSTORE 1C20 60 PUSH1 0x01 1C22 01 ADD 1C23 61 PUSH2 0x1c13 1C26 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1C1F storage[stack[-1]] = 0x00 // @1C22 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1c13 label_1C27: // Incoming jump from 0x1E45 // Incoming jump from 0x1FD5 // Incoming jump from 0x2005 // Incoming jump from 0x1E26 // Incoming jump from 0x1F4C // Incoming jump from 0x2037 // Incoming jump from 0x1E88 // Inputs[2] // { // @1C28 stack[-1] // @1C29 msg.data[stack[-1]:stack[-1] + 0x20] // } 1C27 5B JUMPDEST 1C28 80 DUP1 1C29 35 CALLDATALOAD 1C2A 61 PUSH2 0x040f 1C2D 81 DUP2 1C2E 61 PUSH2 0x2d42 1C31 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C29 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1C2A stack[1] = 0x040f // @1C2D stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2d42 label_1C32: // Incoming call from 0x20C5, returns to 0x20C6 // Incoming call from 0x209B, returns to 0x209C // Inputs[2] // { // @1C36 stack[-2] // @1C39 stack[-1] // } 1C32 5B JUMPDEST 1C33 60 PUSH1 0x00 1C35 80 DUP1 1C36 83 DUP4 1C37 60 PUSH1 0x1f 1C39 84 DUP5 1C3A 01 ADD 1C3B 12 SLT 1C3C 61 PUSH2 0x1c44 1C3F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C33 stack[0] = 0x00 // @1C35 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1c44, if stack[-1] + 0x1f i< stack[-2] label_1C40: // Incoming jump from 0x1C3F, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1C43 memory[0x00:0x00] } 1C40 60 PUSH1 0x00 1C42 80 DUP1 1C43 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C43 revert(memory[0x00:0x00]); } // Block terminates label_1C44: // Incoming jump from 0x1C3F, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1C46 stack[-3] // @1C47 msg.data[stack[-3]:stack[-3] + 0x20] // } 1C44 5B JUMPDEST 1C45 50 POP 1C46 81 DUP2 1C47 35 CALLDATALOAD 1C48 60 PUSH1 0x01 1C4A 60 PUSH1 0x01 1C4C 60 PUSH1 0x40 1C4E 1B SHL 1C4F 03 SUB 1C50 81 DUP2 1C51 11 GT 1C52 15 ISZERO 1C53 61 PUSH2 0x1c5b 1C56 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1C47 stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x1c5b, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_1C57: // Incoming jump from 0x1C56, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @1C5A memory[0x00:0x00] } 1C57 60 PUSH1 0x00 1C59 80 DUP1 1C5A FD *REVERT // Stack delta = +0 // Outputs[1] { @1C5A revert(memory[0x00:0x00]); } // Block terminates label_1C5B: // Incoming jump from 0x1C56, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[4] // { // @1C5E stack[-3] // @1C60 stack[-2] // @1C62 stack[-4] // @1C65 stack[-1] // } 1C5B 5B JUMPDEST 1C5C 60 PUSH1 0x20 1C5E 83 DUP4 1C5F 01 ADD 1C60 91 SWAP2 1C61 50 POP 1C62 83 DUP4 1C63 60 PUSH1 0x20 1C65 82 DUP3 1C66 02 MUL 1C67 83 DUP4 1C68 01 ADD 1C69 11 GT 1C6A 15 ISZERO 1C6B 61 PUSH2 0x1c73 1C6E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1C60 stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x1c73, if !(stack[-3] + 0x20 + stack[-1] * 0x20 > stack[-4]) label_1C6F: // Incoming jump from 0x1C6E, if not !(stack[-3] + 0x20 + stack[-1] * 0x20 > stack[-4]) // Inputs[1] { @1C72 memory[0x00:0x00] } 1C6F 60 PUSH1 0x00 1C71 80 DUP1 1C72 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C72 revert(memory[0x00:0x00]); } // Block terminates label_1C73: // Incoming jump from 0x1C6E, if !(stack[-3] + 0x20 + stack[-1] * 0x20 > stack[-4]) // Inputs[5] // { // @1C74 stack[-1] // @1C74 stack[-4] // @1C76 stack[-5] // @1C76 stack[-2] // @1C77 stack[-3] // } 1C73 5B JUMPDEST 1C74 92 SWAP3 1C75 50 POP 1C76 92 SWAP3 1C77 90 SWAP1 1C78 50 POP 1C79 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1C74 stack[-4] = stack[-1] // @1C76 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] 1C7A 5B JUMPDEST 1C7B 60 PUSH1 0x00 1C7D 82 DUP3 1C7E 60 PUSH1 0x1f 1C80 83 DUP4 1C81 01 ADD 1C82 12 SLT 1C83 61 PUSH2 0x1c8b 1C86 57 *JUMPI 1C87 60 PUSH1 0x00 1C89 80 DUP1 1C8A FD *REVERT 1C8B 5B JUMPDEST 1C8C 81 DUP2 1C8D 35 CALLDATALOAD 1C8E 61 PUSH2 0x1c9e 1C91 61 PUSH2 0x1c99 1C94 82 DUP3 1C95 61 PUSH2 0x2c51 1C98 56 *JUMP label_1C99: // Incoming return from call to 0x2C71 at 0x1D86 1C99 5B JUMPDEST 1C9A 61 PUSH2 0x2c2b 1C9D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2c2b 1C9E 5B JUMPDEST 1C9F 91 SWAP2 1CA0 50 POP 1CA1 81 DUP2 1CA2 81 DUP2 1CA3 83 DUP4 1CA4 52 MSTORE 1CA5 60 PUSH1 0x20 1CA7 84 DUP5 1CA8 01 ADD 1CA9 93 SWAP4 1CAA 50 POP 1CAB 60 PUSH1 0x20 1CAD 81 DUP2 1CAE 01 ADD 1CAF 90 SWAP1 1CB0 50 POP 1CB1 83 DUP4 1CB2 85 DUP6 1CB3 60 PUSH1 0x40 1CB5 84 DUP5 1CB6 02 MUL 1CB7 82 DUP3 1CB8 01 ADD 1CB9 11 GT 1CBA 15 ISZERO 1CBB 61 PUSH2 0x1cc3 1CBE 57 *JUMPI 1CBF 60 PUSH1 0x00 1CC1 80 DUP1 1CC2 FD *REVERT 1CC3 5B JUMPDEST 1CC4 60 PUSH1 0x00 1CC6 5B JUMPDEST 1CC7 83 DUP4 1CC8 81 DUP2 1CC9 10 LT 1CCA 15 ISZERO 1CCB 61 PUSH2 0x1cf1 1CCE 57 *JUMPI 1CCF 81 DUP2 1CD0 61 PUSH2 0x1cd9 1CD3 88 DUP9 1CD4 82 DUP3 1CD5 61 PUSH2 0x1db7 1CD8 56 *JUMP 1CD9 5B JUMPDEST 1CDA 84 DUP5 1CDB 52 MSTORE 1CDC 50 POP 1CDD 60 PUSH1 0x20 1CDF 90 SWAP1 1CE0 92 SWAP3 1CE1 01 ADD 1CE2 91 SWAP2 1CE3 60 PUSH1 0x40 1CE5 91 SWAP2 1CE6 90 SWAP1 1CE7 91 SWAP2 1CE8 01 ADD 1CE9 90 SWAP1 1CEA 60 PUSH1 0x01 1CEC 01 ADD 1CED 61 PUSH2 0x1cc6 1CF0 56 *JUMP 1CF1 5B JUMPDEST 1CF2 50 POP 1CF3 50 POP 1CF4 50 POP 1CF5 50 POP 1CF6 92 SWAP3 1CF7 91 SWAP2 1CF8 50 POP 1CF9 50 POP 1CFA 56 *JUMP 1CFB 5B JUMPDEST 1CFC 80 DUP1 1CFD 35 CALLDATALOAD 1CFE 61 PUSH2 0x040f 1D01 81 DUP2 1D02 61 PUSH2 0x2d56 1D05 56 *JUMP label_1D06: // Incoming jump from 0x21A5 // Incoming jump from 0x215F // Incoming jump from 0x217E // Inputs[2] // { // @1D07 stack[-1] // @1D08 msg.data[stack[-1]:stack[-1] + 0x20] // } 1D06 5B JUMPDEST 1D07 80 DUP1 1D08 35 CALLDATALOAD 1D09 61 PUSH2 0x040f 1D0C 81 DUP2 1D0D 61 PUSH2 0x2d5f 1D10 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D08 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1D09 stack[1] = 0x040f // @1D0C stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2d5f, returns to 0x040F label_1D11: // Incoming jump from 0x20EF // Inputs[2] // { // @1D12 stack[-1] // @1D13 msg.data[stack[-1]:stack[-1] + 0x20] // } 1D11 5B JUMPDEST 1D12 80 DUP1 1D13 35 CALLDATALOAD 1D14 61 PUSH2 0x040f 1D17 81 DUP2 1D18 61 PUSH2 0x2d68 1D1B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D13 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1D14 stack[1] = 0x040f // @1D17 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2d68, returns to 0x040F 1D1C 5B JUMPDEST 1D1D 80 DUP1 1D1E 51 MLOAD 1D1F 61 PUSH2 0x040f 1D22 81 DUP2 1D23 61 PUSH2 0x2d68 1D26 56 *JUMP 1D27 5B JUMPDEST 1D28 60 PUSH1 0x00 1D2A 80 DUP1 1D2B 83 DUP4 1D2C 60 PUSH1 0x1f 1D2E 84 DUP5 1D2F 01 ADD 1D30 12 SLT 1D31 61 PUSH2 0x1d39 1D34 57 *JUMPI 1D35 60 PUSH1 0x00 1D37 80 DUP1 1D38 FD *REVERT 1D39 5B JUMPDEST 1D3A 50 POP 1D3B 81 DUP2 1D3C 35 CALLDATALOAD 1D3D 60 PUSH1 0x01 1D3F 60 PUSH1 0x01 1D41 60 PUSH1 0x40 1D43 1B SHL 1D44 03 SUB 1D45 81 DUP2 1D46 11 GT 1D47 15 ISZERO 1D48 61 PUSH2 0x1d50 1D4B 57 *JUMPI 1D4C 60 PUSH1 0x00 1D4E 80 DUP1 1D4F FD *REVERT 1D50 5B JUMPDEST 1D51 60 PUSH1 0x20 1D53 83 DUP4 1D54 01 ADD 1D55 91 SWAP2 1D56 50 POP 1D57 83 DUP4 1D58 60 PUSH1 0x01 1D5A 82 DUP3 1D5B 02 MUL 1D5C 83 DUP4 1D5D 01 ADD 1D5E 11 GT 1D5F 15 ISZERO 1D60 61 PUSH2 0x1c73 1D63 57 *JUMPI 1D64 60 PUSH1 0x00 1D66 80 DUP1 1D67 FD *REVERT label_1D68: // Incoming call from 0x2141, returns to 0x130E // Inputs[2] // { // @1D6B stack[-2] // @1D6E stack[-1] // } 1D68 5B JUMPDEST 1D69 60 PUSH1 0x00 1D6B 82 DUP3 1D6C 60 PUSH1 0x1f 1D6E 83 DUP4 1D6F 01 ADD 1D70 12 SLT 1D71 61 PUSH2 0x1d79 1D74 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D69 stack[0] = 0x00 } // Block ends with conditional jump to 0x1d79, if stack[-1] + 0x1f i< stack[-2] label_1D75: // Incoming jump from 0x1D74, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1D78 memory[0x00:0x00] } 1D75 60 PUSH1 0x00 1D77 80 DUP1 1D78 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D78 revert(memory[0x00:0x00]); } // Block terminates label_1D79: // Incoming jump from 0x1D74, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1D7A stack[-2] // @1D7B msg.data[stack[-2]:stack[-2] + 0x20] // } 1D79 5B JUMPDEST 1D7A 81 DUP2 1D7B 35 CALLDATALOAD 1D7C 61 PUSH2 0x1d87 1D7F 61 PUSH2 0x1c99 1D82 82 DUP3 1D83 61 PUSH2 0x2c71 1D86 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D7B stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1D7C stack[1] = 0x1d87 // @1D7F stack[2] = 0x1c99 // @1D82 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2c71, returns to 0x1C99 label_1D87: // Incoming return from call to 0x1C99 at 0x1D86 // Inputs[5] // { // @1D88 stack[-1] // @1D88 stack[-3] // @1D8A stack[-2] // @1D8F stack[-4] // @1D95 stack[-5] // } 1D87 5B JUMPDEST 1D88 91 SWAP2 1D89 50 POP 1D8A 80 DUP1 1D8B 82 DUP3 1D8C 52 MSTORE 1D8D 60 PUSH1 0x20 1D8F 83 DUP4 1D90 01 ADD 1D91 60 PUSH1 0x20 1D93 83 DUP4 1D94 01 ADD 1D95 85 DUP6 1D96 83 DUP4 1D97 83 DUP4 1D98 01 ADD 1D99 11 GT 1D9A 15 ISZERO 1D9B 61 PUSH2 0x1da3 1D9E 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1D88 stack[-3] = stack[-1] // @1D8C memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @1D90 stack[-1] = stack[-4] + 0x20 // @1D94 stack[0] = stack[-1] + 0x20 // } // Block ends with conditional jump to 0x1da3, if !(stack[-4] + 0x20 + stack[-2] > stack[-5]) label_1D9F: // Incoming jump from 0x1D9E, if not !(stack[-4] + 0x20 + stack[-2] > stack[-5]) // Inputs[1] { @1DA2 memory[0x00:0x00] } 1D9F 60 PUSH1 0x00 1DA1 80 DUP1 1DA2 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DA2 revert(memory[0x00:0x00]); } // Block terminates label_1DA3: // Incoming jump from 0x1D9E, if !(stack[-4] + 0x20 + stack[-2] > stack[-5]) // Inputs[3] // { // @1DA7 stack[-3] // @1DA8 stack[-1] // @1DA9 stack[-2] // } 1DA3 5B JUMPDEST 1DA4 61 PUSH2 0x1dae 1DA7 83 DUP4 1DA8 82 DUP3 1DA9 84 DUP5 1DAA 61 PUSH2 0x2ce5 1DAD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DA4 stack[0] = 0x1dae // @1DA7 stack[1] = stack[-3] // @1DA8 stack[2] = stack[-1] // @1DA9 stack[3] = stack[-2] // } // Block ends with call to 0x2ce5, returns to 0x1DAE label_1DAE: // Incoming return from call to 0x2CE5 at 0x1DAD // Inputs[3] // { // @1DB2 stack[-7] // @1DB2 stack[-4] // @1DB3 stack[-6] // } 1DAE 5B JUMPDEST 1DAF 50 POP 1DB0 50 POP 1DB1 50 POP 1DB2 92 SWAP3 1DB3 91 SWAP2 1DB4 50 POP 1DB5 50 POP 1DB6 56 *JUMP // Stack delta = -6 // Outputs[1] { @1DB2 stack[-7] = stack[-4] } // Block ends with unconditional jump to stack[-7] 1DB7 5B JUMPDEST 1DB8 60 PUSH1 0x00 1DBA 60 PUSH1 0x40 1DBC 82 DUP3 1DBD 84 DUP5 1DBE 03 SUB 1DBF 12 SLT 1DC0 15 ISZERO 1DC1 61 PUSH2 0x1dc9 1DC4 57 *JUMPI 1DC5 60 PUSH1 0x00 1DC7 80 DUP1 1DC8 FD *REVERT 1DC9 5B JUMPDEST 1DCA 61 PUSH2 0x1dd3 1DCD 60 PUSH1 0x40 1DCF 61 PUSH2 0x2c2b 1DD2 56 *JUMP 1DD3 5B JUMPDEST 1DD4 90 SWAP1 1DD5 50 POP 1DD6 60 PUSH1 0x00 1DD8 61 PUSH2 0x1de1 1DDB 84 DUP5 1DDC 84 DUP5 1DDD 61 PUSH2 0x1c27 1DE0 56 *JUMP 1DE1 5B JUMPDEST 1DE2 82 DUP3 1DE3 52 MSTORE 1DE4 50 POP 1DE5 60 PUSH1 0x20 1DE7 61 PUSH2 0x1df2 1DEA 84 DUP5 1DEB 84 DUP5 1DEC 83 DUP4 1DED 01 ADD 1DEE 61 PUSH2 0x1d06 1DF1 56 *JUMP 1DF2 5B JUMPDEST 1DF3 60 PUSH1 0x20 1DF5 83 DUP4 1DF6 01 ADD 1DF7 52 MSTORE 1DF8 50 POP 1DF9 92 SWAP3 1DFA 91 SWAP2 1DFB 50 POP 1DFC 50 POP 1DFD 56 *JUMP 1DFE 5B JUMPDEST 1DFF 80 DUP1 1E00 35 CALLDATALOAD 1E01 61 PUSH2 0x040f 1E04 81 DUP2 1E05 61 PUSH2 0x2d71 1E08 56 *JUMP label_1E09: // Incoming jump from 0x03AC // Incoming jump from 0x0233 // Incoming jump from 0x02CA // Incoming jump from 0x03D2 // Incoming jump from 0x097E // Inputs[2] // { // @1E0E stack[-1] // @1E0F stack[-2] // } 1E09 5B JUMPDEST 1E0A 60 PUSH1 0x00 1E0C 60 PUSH1 0x20 1E0E 82 DUP3 1E0F 84 DUP5 1E10 03 SUB 1E11 12 SLT 1E12 15 ISZERO 1E13 61 PUSH2 0x1e1b 1E16 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E0A stack[0] = 0x00 } // Block ends with conditional jump to 0x1e1b, if !(stack[-2] - stack[-1] i< 0x20) label_1E17: // Incoming jump from 0x1E16, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1E1A memory[0x00:0x00] } 1E17 60 PUSH1 0x00 1E19 80 DUP1 1E1A FD *REVERT // Stack delta = +0 // Outputs[1] { @1E1A revert(memory[0x00:0x00]); } // Block terminates label_1E1B: // Incoming jump from 0x1E16, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E21 stack[-3] // @1E22 stack[-2] // } 1E1B 5B JUMPDEST 1E1C 60 PUSH1 0x00 1E1E 61 PUSH2 0x130e 1E21 84 DUP5 1E22 84 DUP5 1E23 61 PUSH2 0x1c27 1E26 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E1C stack[0] = 0x00 // @1E1E stack[1] = 0x130e // @1E21 stack[2] = stack[-3] // @1E22 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1c27 label_1E27: // Incoming jump from 0x0399 // Inputs[2] // { // @1E2D stack[-1] // @1E2E stack[-2] // } 1E27 5B JUMPDEST 1E28 60 PUSH1 0x00 1E2A 80 DUP1 1E2B 60 PUSH1 0x40 1E2D 83 DUP4 1E2E 85 DUP6 1E2F 03 SUB 1E30 12 SLT 1E31 15 ISZERO 1E32 61 PUSH2 0x1e3a 1E35 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E28 stack[0] = 0x00 // @1E2A stack[1] = 0x00 // } // Block ends with conditional jump to 0x1e3a, if !(stack[-2] - stack[-1] i< 0x40) label_1E36: // Incoming jump from 0x1E35, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1E39 memory[0x00:0x00] } 1E36 60 PUSH1 0x00 1E38 80 DUP1 1E39 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E39 revert(memory[0x00:0x00]); } // Block terminates label_1E3A: // Incoming jump from 0x1E35, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1E40 stack[-4] // @1E41 stack[-3] // } 1E3A 5B JUMPDEST 1E3B 60 PUSH1 0x00 1E3D 61 PUSH2 0x1e46 1E40 85 DUP6 1E41 85 DUP6 1E42 61 PUSH2 0x1c27 1E45 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E3B stack[0] = 0x00 // @1E3D stack[1] = 0x1e46 // @1E40 stack[2] = stack[-4] // @1E41 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1c27 1E46 5B JUMPDEST 1E47 92 SWAP3 1E48 50 POP 1E49 50 POP 1E4A 60 PUSH1 0x20 1E4C 61 PUSH2 0x1e57 1E4F 85 DUP6 1E50 82 DUP3 1E51 86 DUP7 1E52 01 ADD 1E53 61 PUSH2 0x1c27 1E56 56 *JUMP 1E57 5B JUMPDEST 1E58 91 SWAP2 1E59 50 POP 1E5A 50 POP 1E5B 92 SWAP3 1E5C 50 POP 1E5D 92 SWAP3 1E5E 90 SWAP1 1E5F 50 POP 1E60 56 *JUMP label_1E61: // Incoming jump from 0x027B // Inputs[2] // { // @1E70 stack[-1] // @1E71 stack[-2] // } 1E61 5B JUMPDEST 1E62 60 PUSH1 0x00 1E64 80 DUP1 1E65 60 PUSH1 0x00 1E67 80 DUP1 1E68 60 PUSH1 0x00 1E6A 80 DUP1 1E6B 60 PUSH1 0x00 1E6D 80 DUP1 1E6E 60 PUSH1 0xa0 1E70 89 DUP10 1E71 8B DUP12 1E72 03 SUB 1E73 12 SLT 1E74 15 ISZERO 1E75 61 PUSH2 0x1e7d 1E78 57 *JUMPI // Stack delta = +8 // Outputs[8] // { // @1E62 stack[0] = 0x00 // @1E64 stack[1] = 0x00 // @1E65 stack[2] = 0x00 // @1E67 stack[3] = 0x00 // @1E68 stack[4] = 0x00 // @1E6A stack[5] = 0x00 // @1E6B stack[6] = 0x00 // @1E6D stack[7] = 0x00 // } // Block ends with conditional jump to 0x1e7d, if !(stack[-2] - stack[-1] i< 0xa0) label_1E79: // Incoming jump from 0x1E78, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @1E7C memory[0x00:0x00] } 1E79 60 PUSH1 0x00 1E7B 80 DUP1 1E7C FD *REVERT // Stack delta = +0 // Outputs[1] { @1E7C revert(memory[0x00:0x00]); } // Block terminates label_1E7D: // Incoming jump from 0x1E78, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @1E83 stack[-10] // @1E84 stack[-9] // } 1E7D 5B JUMPDEST 1E7E 60 PUSH1 0x00 1E80 61 PUSH2 0x1e89 1E83 8B DUP12 1E84 8B DUP12 1E85 61 PUSH2 0x1c27 1E88 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E7E stack[0] = 0x00 // @1E80 stack[1] = 0x1e89 // @1E83 stack[2] = stack[-10] // @1E84 stack[3] = stack[-9] // } // Block ends with unconditional jump to 0x1c27 1E89 5B JUMPDEST 1E8A 98 SWAP9 1E8B 50 POP 1E8C 50 POP 1E8D 60 PUSH1 0x20 1E8F 61 PUSH2 0x1e9a 1E92 8B DUP12 1E93 82 DUP3 1E94 8C DUP13 1E95 01 ADD 1E96 61 PUSH2 0x1c27 1E99 56 *JUMP 1E9A 5B JUMPDEST 1E9B 97 SWAP8 1E9C 50 POP 1E9D 50 POP 1E9E 60 PUSH1 0x40 1EA0 89 DUP10 1EA1 01 ADD 1EA2 35 CALLDATALOAD 1EA3 60 PUSH1 0x01 1EA5 60 PUSH1 0x01 1EA7 60 PUSH1 0x40 1EA9 1B SHL 1EAA 03 SUB 1EAB 81 DUP2 1EAC 11 GT 1EAD 15 ISZERO 1EAE 61 PUSH2 0x1eb6 1EB1 57 *JUMPI 1EB2 60 PUSH1 0x00 1EB4 80 DUP1 1EB5 FD *REVERT 1EB6 5B JUMPDEST 1EB7 61 PUSH2 0x1ec2 1EBA 8B DUP12 1EBB 82 DUP3 1EBC 8C DUP13 1EBD 01 ADD 1EBE 61 PUSH2 0x1c32 1EC1 56 *JUMP 1EC2 5B JUMPDEST 1EC3 96 SWAP7 1EC4 50 POP 1EC5 96 SWAP7 1EC6 50 POP 1EC7 50 POP 1EC8 60 PUSH1 0x60 1ECA 89 DUP10 1ECB 01 ADD 1ECC 35 CALLDATALOAD 1ECD 60 PUSH1 0x01 1ECF 60 PUSH1 0x01 1ED1 60 PUSH1 0x40 1ED3 1B SHL 1ED4 03 SUB 1ED5 81 DUP2 1ED6 11 GT 1ED7 15 ISZERO 1ED8 61 PUSH2 0x1ee0 1EDB 57 *JUMPI 1EDC 60 PUSH1 0x00 1EDE 80 DUP1 1EDF FD *REVERT 1EE0 5B JUMPDEST 1EE1 61 PUSH2 0x1eec 1EE4 8B DUP12 1EE5 82 DUP3 1EE6 8C DUP13 1EE7 01 ADD 1EE8 61 PUSH2 0x1c32 1EEB 56 *JUMP 1EEC 5B JUMPDEST 1EED 94 SWAP5 1EEE 50 POP 1EEF 94 SWAP5 1EF0 50 POP 1EF1 50 POP 1EF2 60 PUSH1 0x80 1EF4 89 DUP10 1EF5 01 ADD 1EF6 35 CALLDATALOAD 1EF7 60 PUSH1 0x01 1EF9 60 PUSH1 0x01 1EFB 60 PUSH1 0x40 1EFD 1B SHL 1EFE 03 SUB 1EFF 81 DUP2 1F00 11 GT 1F01 15 ISZERO 1F02 61 PUSH2 0x1f0a 1F05 57 *JUMPI 1F06 60 PUSH1 0x00 1F08 80 DUP1 1F09 FD *REVERT 1F0A 5B JUMPDEST 1F0B 61 PUSH2 0x1f16 1F0E 8B DUP12 1F0F 82 DUP3 1F10 8C DUP13 1F11 01 ADD 1F12 61 PUSH2 0x1d27 1F15 56 *JUMP 1F16 5B JUMPDEST 1F17 92 SWAP3 1F18 50 POP 1F19 92 SWAP3 1F1A 50 POP 1F1B 50 POP 1F1C 92 SWAP3 1F1D 95 SWAP6 1F1E 98 SWAP9 1F1F 50 POP 1F20 92 SWAP3 1F21 95 SWAP6 1F22 98 SWAP9 1F23 90 SWAP1 1F24 93 SWAP4 1F25 96 SWAP7 1F26 50 POP 1F27 56 *JUMP label_1F28: // Incoming jump from 0x03BF // Inputs[2] // { // @1F34 stack[-1] // @1F35 stack[-2] // } 1F28 5B JUMPDEST 1F29 60 PUSH1 0x00 1F2B 80 DUP1 1F2C 60 PUSH1 0x00 1F2E 80 DUP1 1F2F 60 PUSH1 0x00 1F31 80 DUP1 1F32 60 PUSH1 0xa0 1F34 87 DUP8 1F35 89 DUP10 1F36 03 SUB 1F37 12 SLT 1F38 15 ISZERO 1F39 61 PUSH2 0x1f41 1F3C 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @1F29 stack[0] = 0x00 // @1F2B stack[1] = 0x00 // @1F2C stack[2] = 0x00 // @1F2E stack[3] = 0x00 // @1F2F stack[4] = 0x00 // @1F31 stack[5] = 0x00 // } // Block ends with conditional jump to 0x1f41, if !(stack[-2] - stack[-1] i< 0xa0) label_1F3D: // Incoming jump from 0x1F3C, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @1F40 memory[0x00:0x00] } 1F3D 60 PUSH1 0x00 1F3F 80 DUP1 1F40 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F40 revert(memory[0x00:0x00]); } // Block terminates label_1F41: // Incoming jump from 0x1F3C, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @1F47 stack[-8] // @1F48 stack[-7] // } 1F41 5B JUMPDEST 1F42 60 PUSH1 0x00 1F44 61 PUSH2 0x1f4d 1F47 89 DUP10 1F48 89 DUP10 1F49 61 PUSH2 0x1c27 1F4C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F42 stack[0] = 0x00 // @1F44 stack[1] = 0x1f4d // @1F47 stack[2] = stack[-8] // @1F48 stack[3] = stack[-7] // } // Block ends with unconditional jump to 0x1c27 1F4D 5B JUMPDEST 1F4E 96 SWAP7 1F4F 50 POP 1F50 50 POP 1F51 60 PUSH1 0x20 1F53 61 PUSH2 0x1f5e 1F56 89 DUP10 1F57 82 DUP3 1F58 8A DUP11 1F59 01 ADD 1F5A 61 PUSH2 0x1c27 1F5D 56 *JUMP 1F5E 5B JUMPDEST 1F5F 95 SWAP6 1F60 50 POP 1F61 50 POP 1F62 60 PUSH1 0x40 1F64 61 PUSH2 0x1f6f 1F67 89 DUP10 1F68 82 DUP3 1F69 8A DUP11 1F6A 01 ADD 1F6B 61 PUSH2 0x1d06 1F6E 56 *JUMP 1F6F 5B JUMPDEST 1F70 94 SWAP5 1F71 50 POP 1F72 50 POP 1F73 60 PUSH1 0x60 1F75 61 PUSH2 0x1f80 1F78 89 DUP10 1F79 82 DUP3 1F7A 8A DUP11 1F7B 01 ADD 1F7C 61 PUSH2 0x1d06 1F7F 56 *JUMP 1F80 5B JUMPDEST 1F81 93 SWAP4 1F82 50 POP 1F83 50 POP 1F84 60 PUSH1 0x80 1F86 87 DUP8 1F87 01 ADD 1F88 35 CALLDATALOAD 1F89 60 PUSH1 0x01 1F8B 60 PUSH1 0x01 1F8D 60 PUSH1 0x40 1F8F 1B SHL 1F90 03 SUB 1F91 81 DUP2 1F92 11 GT 1F93 15 ISZERO 1F94 61 PUSH2 0x1f9c 1F97 57 *JUMPI 1F98 60 PUSH1 0x00 1F9A 80 DUP1 1F9B FD *REVERT 1F9C 5B JUMPDEST 1F9D 61 PUSH2 0x1fa8 1FA0 89 DUP10 1FA1 82 DUP3 1FA2 8A DUP11 1FA3 01 ADD 1FA4 61 PUSH2 0x1d27 1FA7 56 *JUMP 1FA8 5B JUMPDEST 1FA9 92 SWAP3 1FAA 50 POP 1FAB 92 SWAP3 1FAC 50 POP 1FAD 50 POP 1FAE 92 SWAP3 1FAF 95 SWAP6 1FB0 50 POP 1FB1 92 SWAP3 1FB2 95 SWAP6 1FB3 50 POP 1FB4 92 SWAP3 1FB5 95 SWAP6 1FB6 56 *JUMP label_1FB7: // Incoming jump from 0x0328 // Inputs[2] // { // @1FBD stack[-1] // @1FBE stack[-2] // } 1FB7 5B JUMPDEST 1FB8 60 PUSH1 0x00 1FBA 80 DUP1 1FBB 60 PUSH1 0x40 1FBD 83 DUP4 1FBE 85 DUP6 1FBF 03 SUB 1FC0 12 SLT 1FC1 15 ISZERO 1FC2 61 PUSH2 0x1fca 1FC5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1FB8 stack[0] = 0x00 // @1FBA stack[1] = 0x00 // } // Block ends with conditional jump to 0x1fca, if !(stack[-2] - stack[-1] i< 0x40) label_1FC6: // Incoming jump from 0x1FC5, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1FC9 memory[0x00:0x00] } 1FC6 60 PUSH1 0x00 1FC8 80 DUP1 1FC9 FD *REVERT // Stack delta = +0 // Outputs[1] { @1FC9 revert(memory[0x00:0x00]); } // Block terminates label_1FCA: // Incoming jump from 0x1FC5, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1FD0 stack[-4] // @1FD1 stack[-3] // } 1FCA 5B JUMPDEST 1FCB 60 PUSH1 0x00 1FCD 61 PUSH2 0x1fd6 1FD0 85 DUP6 1FD1 85 DUP6 1FD2 61 PUSH2 0x1c27 1FD5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1FCB stack[0] = 0x00 // @1FCD stack[1] = 0x1fd6 // @1FD0 stack[2] = stack[-4] // @1FD1 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1c27 1FD6 5B JUMPDEST 1FD7 92 SWAP3 1FD8 50 POP 1FD9 50 POP 1FDA 60 PUSH1 0x20 1FDC 61 PUSH2 0x1e57 1FDF 85 DUP6 1FE0 82 DUP3 1FE1 86 DUP7 1FE2 01 ADD 1FE3 61 PUSH2 0x1cfb 1FE6 56 *JUMP label_1FE7: // Incoming jump from 0x01D5 // Inputs[2] // { // @1FED stack[-1] // @1FEE stack[-2] // } 1FE7 5B JUMPDEST 1FE8 60 PUSH1 0x00 1FEA 80 DUP1 1FEB 60 PUSH1 0x40 1FED 83 DUP4 1FEE 85 DUP6 1FEF 03 SUB 1FF0 12 SLT 1FF1 15 ISZERO 1FF2 61 PUSH2 0x1ffa 1FF5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1FE8 stack[0] = 0x00 // @1FEA stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ffa, if !(stack[-2] - stack[-1] i< 0x40) label_1FF6: // Incoming jump from 0x1FF5, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1FF9 memory[0x00:0x00] } 1FF6 60 PUSH1 0x00 1FF8 80 DUP1 1FF9 FD *REVERT // Stack delta = +0 // Outputs[1] { @1FF9 revert(memory[0x00:0x00]); } // Block terminates label_1FFA: // Incoming jump from 0x1FF5, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2000 stack[-4] // @2001 stack[-3] // } 1FFA 5B JUMPDEST 1FFB 60 PUSH1 0x00 1FFD 61 PUSH2 0x2006 2000 85 DUP6 2001 85 DUP6 2002 61 PUSH2 0x1c27 2005 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1FFB stack[0] = 0x00 // @1FFD stack[1] = 0x2006 // @2000 stack[2] = stack[-4] // @2001 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1c27 2006 5B JUMPDEST 2007 92 SWAP3 2008 50 POP 2009 50 POP 200A 60 PUSH1 0x20 200C 61 PUSH2 0x1e57 200F 85 DUP6 2010 82 DUP3 2011 86 DUP7 2012 01 ADD 2013 61 PUSH2 0x1d06 2016 56 *JUMP label_2017: // Incoming jump from 0x03E5 // Inputs[2] // { // @201F stack[-1] // @2020 stack[-2] // } 2017 5B JUMPDEST 2018 60 PUSH1 0x00 201A 80 DUP1 201B 60 PUSH1 0x00 201D 60 PUSH1 0x60 201F 84 DUP5 2020 86 DUP7 2021 03 SUB 2022 12 SLT 2023 15 ISZERO 2024 61 PUSH2 0x202c 2027 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2018 stack[0] = 0x00 // @201A stack[1] = 0x00 // @201B stack[2] = 0x00 // } // Block ends with conditional jump to 0x202c, if !(stack[-2] - stack[-1] i< 0x60) label_2028: // Incoming jump from 0x2027, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @202B memory[0x00:0x00] } 2028 60 PUSH1 0x00 202A 80 DUP1 202B FD *REVERT // Stack delta = +0 // Outputs[1] { @202B revert(memory[0x00:0x00]); } // Block terminates label_202C: // Incoming jump from 0x2027, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @2032 stack[-5] // @2033 stack[-4] // } 202C 5B JUMPDEST 202D 60 PUSH1 0x00 202F 61 PUSH2 0x2038 2032 86 DUP7 2033 86 DUP7 2034 61 PUSH2 0x1c27 2037 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @202D stack[0] = 0x00 // @202F stack[1] = 0x2038 // @2032 stack[2] = stack[-5] // @2033 stack[3] = stack[-4] // } // Block ends with unconditional jump to 0x1c27 2038 5B JUMPDEST 2039 93 SWAP4 203A 50 POP 203B 50 POP 203C 60 PUSH1 0x20 203E 61 PUSH2 0x2049 2041 86 DUP7 2042 82 DUP3 2043 87 DUP8 2044 01 ADD 2045 61 PUSH2 0x1d06 2048 56 *JUMP 2049 5B JUMPDEST 204A 92 SWAP3 204B 50 POP 204C 50 POP 204D 60 PUSH1 0x40 204F 61 PUSH2 0x205a 2052 86 DUP7 2053 82 DUP3 2054 87 DUP8 2055 01 ADD 2056 61 PUSH2 0x1d06 2059 56 *JUMP 205A 5B JUMPDEST 205B 91 SWAP2 205C 50 POP 205D 50 POP 205E 92 SWAP3 205F 50 POP 2060 92 SWAP3 2061 50 POP 2062 92 SWAP3 2063 56 *JUMP label_2064: // Incoming call from 0x028E, returns to 0x028F // Inputs[2] // { // @206D stack[-1] // @206E stack[-2] // } 2064 5B JUMPDEST 2065 60 PUSH1 0x00 2067 80 DUP1 2068 60 PUSH1 0x00 206A 80 DUP1 206B 60 PUSH1 0x40 206D 85 DUP6 206E 87 DUP8 206F 03 SUB 2070 12 SLT 2071 15 ISZERO 2072 61 PUSH2 0x207a 2075 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2065 stack[0] = 0x00 // @2067 stack[1] = 0x00 // @2068 stack[2] = 0x00 // @206A stack[3] = 0x00 // } // Block ends with conditional jump to 0x207a, if !(stack[-2] - stack[-1] i< 0x40) label_2076: // Incoming jump from 0x2075, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2079 memory[0x00:0x00] } 2076 60 PUSH1 0x00 2078 80 DUP1 2079 FD *REVERT // Stack delta = +0 // Outputs[1] { @2079 revert(memory[0x00:0x00]); } // Block terminates label_207A: // Incoming jump from 0x2075, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @207B stack[-5] // @207C msg.data[stack[-5]:stack[-5] + 0x20] // } 207A 5B JUMPDEST 207B 84 DUP5 207C 35 CALLDATALOAD 207D 60 PUSH1 0x01 207F 60 PUSH1 0x01 2081 60 PUSH1 0x40 2083 1B SHL 2084 03 SUB 2085 81 DUP2 2086 11 GT 2087 15 ISZERO 2088 61 PUSH2 0x2090 208B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @207C stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] } // Block ends with conditional jump to 0x2090, if !(msg.data[stack[-5]:stack[-5] + 0x20] > (0x01 << 0x40) - 0x01) label_208C: // Incoming jump from 0x208B, if not !(msg.data[stack[-5]:stack[-5] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @208F memory[0x00:0x00] } 208C 60 PUSH1 0x00 208E 80 DUP1 208F FD *REVERT // Stack delta = +0 // Outputs[1] { @208F revert(memory[0x00:0x00]); } // Block terminates label_2090: // Incoming jump from 0x208B, if !(msg.data[stack[-5]:stack[-5] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2094 stack[-7] // @2095 stack[-1] // @2096 stack[-6] // } 2090 5B JUMPDEST 2091 61 PUSH2 0x209c 2094 87 DUP8 2095 82 DUP3 2096 88 DUP9 2097 01 ADD 2098 61 PUSH2 0x1c32 209B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2091 stack[0] = 0x209c // @2094 stack[1] = stack[-7] // @2097 stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x1c32, returns to 0x209C label_209C: // Incoming return from call to 0x1C32 at 0x209B // Inputs[6] // { // @209D stack[-1] // @209D stack[-6] // @209F stack[-7] // @209F stack[-2] // @20A4 stack[-8] // @20A6 msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // } 209C 5B JUMPDEST 209D 94 SWAP5 209E 50 POP 209F 94 SWAP5 20A0 50 POP 20A1 50 POP 20A2 60 PUSH1 0x20 20A4 85 DUP6 20A5 01 ADD 20A6 35 CALLDATALOAD 20A7 60 PUSH1 0x01 20A9 60 PUSH1 0x01 20AB 60 PUSH1 0x40 20AD 1B SHL 20AE 03 SUB 20AF 81 DUP2 20B0 11 GT 20B1 15 ISZERO 20B2 61 PUSH2 0x20ba 20B5 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @209D stack[-6] = stack[-1] // @209F stack[-7] = stack[-2] // @20A6 stack[-3] = msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x20ba, if !(msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) label_20B6: // Incoming jump from 0x20B5, if not !(msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @20B9 memory[0x00:0x00] } 20B6 60 PUSH1 0x00 20B8 80 DUP1 20B9 FD *REVERT // Stack delta = +0 // Outputs[1] { @20B9 revert(memory[0x00:0x00]); } // Block terminates label_20BA: // Incoming jump from 0x20B5, if !(msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @20BE stack[-7] // @20BF stack[-1] // @20C0 stack[-6] // } 20BA 5B JUMPDEST 20BB 61 PUSH2 0x20c6 20BE 87 DUP8 20BF 82 DUP3 20C0 88 DUP9 20C1 01 ADD 20C2 61 PUSH2 0x1c32 20C5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @20BB stack[0] = 0x20c6 // @20BE stack[1] = stack[-7] // @20C1 stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x1c32, returns to 0x20C6 label_20C6: // Incoming return from call to 0x1C32 at 0x20C5 // Inputs[7] // { // @20C7 stack[-7] // @20C7 stack[-1] // @20C8 stack[-10] // @20C9 stack[-6] // @20CA stack[-9] // @20CC stack[-8] // @20CC stack[-2] // } 20C6 5B JUMPDEST 20C7 95 SWAP6 20C8 98 SWAP9 20C9 94 SWAP5 20CA 97 SWAP8 20CB 50 POP 20CC 95 SWAP6 20CD 50 POP 20CE 50 POP 20CF 50 POP 20D0 50 POP 20D1 56 *JUMP // Stack delta = -6 // Outputs[4] // { // @20C7 stack[-7] = stack[-1] // @20C8 stack[-10] = stack[-7] // @20CA stack[-9] = stack[-6] // @20CC stack[-8] = stack[-2] // } // Block ends with unconditional jump to stack[-10] label_20D2: // Incoming jump from 0x01FE // Inputs[2] // { // @20D7 stack[-1] // @20D8 stack[-2] // } 20D2 5B JUMPDEST 20D3 60 PUSH1 0x00 20D5 60 PUSH1 0x20 20D7 82 DUP3 20D8 84 DUP5 20D9 03 SUB 20DA 12 SLT 20DB 15 ISZERO 20DC 61 PUSH2 0x20e4 20DF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20D3 stack[0] = 0x00 } // Block ends with conditional jump to 0x20e4, if !(stack[-2] - stack[-1] i< 0x20) label_20E0: // Incoming jump from 0x20DF, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @20E3 memory[0x00:0x00] } 20E0 60 PUSH1 0x00 20E2 80 DUP1 20E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @20E3 revert(memory[0x00:0x00]); } // Block terminates label_20E4: // Incoming jump from 0x20DF, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @20EA stack[-3] // @20EB stack[-2] // } 20E4 5B JUMPDEST 20E5 60 PUSH1 0x00 20E7 61 PUSH2 0x130e 20EA 84 DUP5 20EB 84 DUP5 20EC 61 PUSH2 0x1d11 20EF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @20E5 stack[0] = 0x00 // @20E7 stack[1] = 0x130e // @20EA stack[2] = stack[-3] // @20EB stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1d11 20F0 5B JUMPDEST 20F1 60 PUSH1 0x00 20F3 60 PUSH1 0x20 20F5 82 DUP3 20F6 84 DUP5 20F7 03 SUB 20F8 12 SLT 20F9 15 ISZERO 20FA 61 PUSH2 0x2102 20FD 57 *JUMPI 20FE 60 PUSH1 0x00 2100 80 DUP1 2101 FD *REVERT 2102 5B JUMPDEST 2103 60 PUSH1 0x00 2105 61 PUSH2 0x130e 2108 84 DUP5 2109 84 DUP5 210A 61 PUSH2 0x1d1c 210D 56 *JUMP label_210E: // Incoming call from 0x02FA, returns to 0x02FB // Incoming call from 0x0315, returns to 0x0316 // Inputs[2] // { // @2113 stack[-1] // @2114 stack[-2] // } 210E 5B JUMPDEST 210F 60 PUSH1 0x00 2111 60 PUSH1 0x20 2113 82 DUP3 2114 84 DUP5 2115 03 SUB 2116 12 SLT 2117 15 ISZERO 2118 61 PUSH2 0x2120 211B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @210F stack[0] = 0x00 } // Block ends with conditional jump to 0x2120, if !(stack[-2] - stack[-1] i< 0x20) label_211C: // Incoming jump from 0x211B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @211F memory[0x00:0x00] } 211C 60 PUSH1 0x00 211E 80 DUP1 211F FD *REVERT // Stack delta = +0 // Outputs[1] { @211F revert(memory[0x00:0x00]); } // Block terminates label_2120: // Incoming jump from 0x211B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2121 stack[-2] // @2122 msg.data[stack[-2]:stack[-2] + 0x20] // } 2120 5B JUMPDEST 2121 81 DUP2 2122 35 CALLDATALOAD 2123 60 PUSH1 0x01 2125 60 PUSH1 0x01 2127 60 PUSH1 0x40 2129 1B SHL 212A 03 SUB 212B 81 DUP2 212C 11 GT 212D 15 ISZERO 212E 61 PUSH2 0x2136 2131 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2122 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2136, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_2132: // Incoming jump from 0x2131, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2135 memory[0x00:0x00] } 2132 60 PUSH1 0x00 2134 80 DUP1 2135 FD *REVERT // Stack delta = +0 // Outputs[1] { @2135 revert(memory[0x00:0x00]); } // Block terminates label_2136: // Incoming jump from 0x2131, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @213A stack[-4] // @213B stack[-1] // @213C stack[-3] // } 2136 5B JUMPDEST 2137 61 PUSH2 0x130e 213A 84 DUP5 213B 82 DUP3 213C 85 DUP6 213D 01 ADD 213E 61 PUSH2 0x1d68 2141 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2137 stack[0] = 0x130e // @213A stack[1] = stack[-4] // @213D stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x1d68, returns to 0x130E label_2142: // Incoming jump from 0x0376 // Incoming jump from 0x033B // Incoming jump from 0x025B // Incoming jump from 0x0248 // Inputs[2] // { // @2147 stack[-1] // @2148 stack[-2] // } 2142 5B JUMPDEST 2143 60 PUSH1 0x00 2145 60 PUSH1 0x20 2147 82 DUP3 2148 84 DUP5 2149 03 SUB 214A 12 SLT 214B 15 ISZERO 214C 61 PUSH2 0x2154 214F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2143 stack[0] = 0x00 } // Block ends with conditional jump to 0x2154, if !(stack[-2] - stack[-1] i< 0x20) label_2150: // Incoming jump from 0x214F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2153 memory[0x00:0x00] } 2150 60 PUSH1 0x00 2152 80 DUP1 2153 FD *REVERT // Stack delta = +0 // Outputs[1] { @2153 revert(memory[0x00:0x00]); } // Block terminates label_2154: // Incoming jump from 0x214F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @215A stack[-3] // @215B stack[-2] // } 2154 5B JUMPDEST 2155 60 PUSH1 0x00 2157 61 PUSH2 0x130e 215A 84 DUP5 215B 84 DUP5 215C 61 PUSH2 0x1d06 215F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2155 stack[0] = 0x00 // @2157 stack[1] = 0x130e // @215A stack[2] = stack[-3] // @215B stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1d06 label_2160: // Incoming jump from 0x02A1 // Inputs[2] // { // @2166 stack[-1] // @2167 stack[-2] // } 2160 5B JUMPDEST 2161 60 PUSH1 0x00 2163 80 DUP1 2164 60 PUSH1 0x40 2166 83 DUP4 2167 85 DUP6 2168 03 SUB 2169 12 SLT 216A 15 ISZERO 216B 61 PUSH2 0x2173 216E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2161 stack[0] = 0x00 // @2163 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2173, if !(stack[-2] - stack[-1] i< 0x40) label_216F: // Incoming jump from 0x216E, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2172 memory[0x00:0x00] } 216F 60 PUSH1 0x00 2171 80 DUP1 2172 FD *REVERT // Stack delta = +0 // Outputs[1] { @2172 revert(memory[0x00:0x00]); } // Block terminates label_2173: // Incoming jump from 0x216E, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2179 stack[-4] // @217A stack[-3] // } 2173 5B JUMPDEST 2174 60 PUSH1 0x00 2176 61 PUSH2 0x2006 2179 85 DUP6 217A 85 DUP6 217B 61 PUSH2 0x1d06 217E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2174 stack[0] = 0x00 // @2176 stack[1] = 0x2006 // @2179 stack[2] = stack[-4] // @217A stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1d06 label_217F: // Incoming jump from 0x0363 // Inputs[2] // { // @218D stack[-1] // @218E stack[-2] // } 217F 5B JUMPDEST 2180 60 PUSH1 0x00 2182 80 DUP1 2183 60 PUSH1 0x00 2185 80 DUP1 2186 60 PUSH1 0x00 2188 80 DUP1 2189 60 PUSH1 0x00 218B 60 PUSH1 0xe0 218D 88 DUP9 218E 8A DUP11 218F 03 SUB 2190 12 SLT 2191 15 ISZERO 2192 61 PUSH2 0x219a 2195 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @2180 stack[0] = 0x00 // @2182 stack[1] = 0x00 // @2183 stack[2] = 0x00 // @2185 stack[3] = 0x00 // @2186 stack[4] = 0x00 // @2188 stack[5] = 0x00 // @2189 stack[6] = 0x00 // } // Block ends with conditional jump to 0x219a, if !(stack[-2] - stack[-1] i< 0xe0) label_2196: // Incoming jump from 0x2195, if not !(stack[-2] - stack[-1] i< 0xe0) // Inputs[1] { @2199 memory[0x00:0x00] } 2196 60 PUSH1 0x00 2198 80 DUP1 2199 FD *REVERT // Stack delta = +0 // Outputs[1] { @2199 revert(memory[0x00:0x00]); } // Block terminates label_219A: // Incoming jump from 0x2195, if !(stack[-2] - stack[-1] i< 0xe0) // Inputs[2] // { // @21A0 stack[-9] // @21A1 stack[-8] // } 219A 5B JUMPDEST 219B 60 PUSH1 0x00 219D 61 PUSH2 0x21a6 21A0 8A DUP11 21A1 8A DUP11 21A2 61 PUSH2 0x1d06 21A5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @219B stack[0] = 0x00 // @219D stack[1] = 0x21a6 // @21A0 stack[2] = stack[-9] // @21A1 stack[3] = stack[-8] // } // Block ends with unconditional jump to 0x1d06 21A6 5B JUMPDEST 21A7 97 SWAP8 21A8 50 POP 21A9 50 POP 21AA 60 PUSH1 0x20 21AC 61 PUSH2 0x21b7 21AF 8A DUP11 21B0 82 DUP3 21B1 8B DUP12 21B2 01 ADD 21B3 61 PUSH2 0x1dfe 21B6 56 *JUMP 21B7 5B JUMPDEST 21B8 96 SWAP7 21B9 50 POP 21BA 50 POP 21BB 60 PUSH1 0x40 21BD 61 PUSH2 0x21c8 21C0 8A DUP11 21C1 82 DUP3 21C2 8B DUP12 21C3 01 ADD 21C4 61 PUSH2 0x1d06 21C7 56 *JUMP 21C8 5B JUMPDEST 21C9 95 SWAP6 21CA 50 POP 21CB 50 POP 21CC 60 PUSH1 0x60 21CE 61 PUSH2 0x21d9 21D1 8A DUP11 21D2 82 DUP3 21D3 8B DUP12 21D4 01 ADD 21D5 61 PUSH2 0x1d06 21D8 56 *JUMP 21D9 5B JUMPDEST 21DA 94 SWAP5 21DB 50 POP 21DC 50 POP 21DD 60 PUSH1 0x80 21DF 88 DUP9 21E0 01 ADD 21E1 35 CALLDATALOAD 21E2 60 PUSH1 0x01 21E4 60 PUSH1 0x01 21E6 60 PUSH1 0x40 21E8 1B SHL 21E9 03 SUB 21EA 81 DUP2 21EB 11 GT 21EC 15 ISZERO 21ED 61 PUSH2 0x21f5 21F0 57 *JUMPI 21F1 60 PUSH1 0x00 21F3 80 DUP1 21F4 FD *REVERT 21F5 5B JUMPDEST 21F6 61 PUSH2 0x2201 21F9 8A DUP11 21FA 82 DUP3 21FB 8B DUP12 21FC 01 ADD 21FD 61 PUSH2 0x1c7a 2200 56 *JUMP 2201 5B JUMPDEST 2202 93 SWAP4 2203 50 POP 2204 50 POP 2205 60 PUSH1 0xa0 2207 61 PUSH2 0x2212 220A 8A DUP11 220B 82 DUP3 220C 8B DUP12 220D 01 ADD 220E 61 PUSH2 0x1d06 2211 56 *JUMP 2212 5B JUMPDEST 2213 92 SWAP3 2214 50 POP 2215 50 POP 2216 60 PUSH1 0xc0 2218 88 DUP9 2219 01 ADD 221A 35 CALLDATALOAD 221B 60 PUSH1 0x01 221D 60 PUSH1 0x01 221F 60 PUSH1 0x40 2221 1B SHL 2222 03 SUB 2223 81 DUP2 2224 11 GT 2225 15 ISZERO 2226 61 PUSH2 0x222e 2229 57 *JUMPI 222A 60 PUSH1 0x00 222C 80 DUP1 222D FD *REVERT 222E 5B JUMPDEST 222F 61 PUSH2 0x223a 2232 8A DUP11 2233 82 DUP3 2234 8B DUP12 2235 01 ADD 2236 61 PUSH2 0x1d68 2239 56 *JUMP 223A 5B JUMPDEST 223B 91 SWAP2 223C 50 POP 223D 50 POP 223E 92 SWAP3 223F 95 SWAP6 2240 98 SWAP9 2241 91 SWAP2 2242 94 SWAP5 2243 97 SWAP8 2244 50 POP 2245 92 SWAP3 2246 95 SWAP6 2247 50 POP 2248 56 *JUMP 2249 5B JUMPDEST 224A 60 PUSH1 0x00 224C 61 PUSH2 0x2255 224F 83 DUP4 2250 83 DUP4 2251 61 PUSH2 0x2269 2254 56 *JUMP 2255 5B JUMPDEST 2256 50 POP 2257 50 POP 2258 60 PUSH1 0x20 225A 01 ADD 225B 90 SWAP1 225C 56 *JUMP label_225D: // Incoming jump from 0x238F // Inputs[2] // { // @2263 stack[-2] // @2264 stack[-1] // } 225D 5B JUMPDEST 225E 60 PUSH1 0x00 2260 61 PUSH2 0x2255 2263 83 DUP4 2264 83 DUP4 2265 61 PUSH2 0x23af 2268 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @225E stack[0] = 0x00 // @2260 stack[1] = 0x2255 // @2263 stack[2] = stack[-2] // @2264 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x23af label_2269: // Incoming call from 0x2931, returns to 0x040F // Inputs[1] { @226D stack[-1] } 2269 5B JUMPDEST 226A 61 PUSH2 0x2272 226D 81 DUP2 226E 61 PUSH2 0x2cab 2271 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @226A stack[0] = 0x2272 // @226D stack[1] = stack[-1] // } // Block ends with call to 0x2cab, returns to 0x2272 label_2272: // Incoming return from call to 0x0A9A at 0x23B7 // Incoming return from call to 0x2CB6 at 0x23AE // Incoming return from call to 0x2CAB at 0x2271 // Inputs[3] // { // @2273 stack[-3] // @2274 stack[-1] // @2277 stack[-4] // } 2272 5B JUMPDEST 2273 82 DUP3 2274 52 MSTORE 2275 50 POP 2276 50 POP 2277 56 *JUMP // Stack delta = -4 // Outputs[1] { @2274 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] 2278 5B JUMPDEST 2279 60 PUSH1 0x00 227B 61 PUSH2 0x2283 227E 82 DUP3 227F 61 PUSH2 0x2c9e 2282 56 *JUMP 2283 5B JUMPDEST 2284 61 PUSH2 0x228d 2287 81 DUP2 2288 85 DUP6 2289 61 PUSH2 0x2ca2 228C 56 *JUMP 228D 5B JUMPDEST 228E 93 SWAP4 228F 50 POP 2290 61 PUSH2 0x2298 2293 83 DUP4 2294 61 PUSH2 0x2c98 2297 56 *JUMP 2298 5B JUMPDEST 2299 80 DUP1 229A 60 PUSH1 0x00 229C 5B JUMPDEST 229D 83 DUP4 229E 81 DUP2 229F 10 LT 22A0 15 ISZERO 22A1 61 PUSH2 0x22c6 22A4 57 *JUMPI 22A5 81 DUP2 22A6 51 MLOAD 22A7 61 PUSH2 0x22b0 22AA 88 DUP9 22AB 82 DUP3 22AC 61 PUSH2 0x2249 22AF 56 *JUMP 22B0 5B JUMPDEST 22B1 97 SWAP8 22B2 50 POP 22B3 61 PUSH2 0x22bb 22B6 83 DUP4 22B7 61 PUSH2 0x2c98 22BA 56 *JUMP 22BB 5B JUMPDEST 22BC 92 SWAP3 22BD 50 POP 22BE 50 POP 22BF 60 PUSH1 0x01 22C1 01 ADD 22C2 61 PUSH2 0x229c 22C5 56 *JUMP label_22C6: // Incoming jump from 0x2384, if !(0x00 < stack[-2]) // Inputs[3] // { // @22C8 stack[-7] // @22C8 stack[-2] // @22C9 stack[-8] // } 22C6 5B JUMPDEST 22C7 50 POP 22C8 94 SWAP5 22C9 95 SWAP6 22CA 94 SWAP5 22CB 50 POP 22CC 50 POP 22CD 50 POP 22CE 50 POP 22CF 50 POP 22D0 56 *JUMP // Stack delta = -7 // Outputs[1] { @22C9 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] 22D1 5B JUMPDEST 22D2 60 PUSH1 0x00 22D4 61 PUSH2 0x22dc 22D7 82 DUP3 22D8 61 PUSH2 0x2c9e 22DB 56 *JUMP 22DC 5B JUMPDEST 22DD 61 PUSH2 0x22e6 22E0 81 DUP2 22E1 85 DUP6 22E2 61 PUSH2 0x2ca2 22E5 56 *JUMP 22E6 5B JUMPDEST 22E7 93 SWAP4 22E8 50 POP 22E9 61 PUSH2 0x22f1 22EC 83 DUP4 22ED 61 PUSH2 0x2c98 22F0 56 *JUMP 22F1 5B JUMPDEST 22F2 80 DUP1 22F3 60 PUSH1 0x00 22F5 5B JUMPDEST 22F6 83 DUP4 22F7 81 DUP2 22F8 10 LT 22F9 15 ISZERO 22FA 61 PUSH2 0x22c6 22FD 57 *JUMPI 22FE 81 DUP2 22FF 51 MLOAD 2300 61 PUSH2 0x2309 2303 88 DUP9 2304 82 DUP3 2305 61 PUSH2 0x2249 2308 56 *JUMP 2309 5B JUMPDEST 230A 97 SWAP8 230B 50 POP 230C 61 PUSH2 0x2314 230F 83 DUP4 2310 61 PUSH2 0x2c98 2313 56 *JUMP 2314 5B JUMPDEST 2315 92 SWAP3 2316 50 POP 2317 50 POP 2318 60 PUSH1 0x01 231A 01 ADD 231B 61 PUSH2 0x22f5 231E 56 *JUMP 231F 5B JUMPDEST 2320 60 PUSH1 0x00 2322 61 PUSH2 0x232b 2325 83 DUP4 2326 85 DUP6 2327 61 PUSH2 0x2ca2 232A 56 *JUMP 232B 5B JUMPDEST 232C 93 SWAP4 232D 50 POP 232E 60 PUSH1 0x01 2330 60 PUSH1 0x01 2332 60 PUSH1 0xfb 2334 1B SHL 2335 03 SUB 2336 83 DUP4 2337 11 GT 2338 15 ISZERO 2339 61 PUSH2 0x2341 233C 57 *JUMPI 233D 60 PUSH1 0x00 233F 80 DUP1 2340 FD *REVERT 2341 5B JUMPDEST 2342 60 PUSH1 0x20 2344 83 DUP4 2345 02 MUL 2346 92 SWAP3 2347 50 POP 2348 61 PUSH2 0x2352 234B 83 DUP4 234C 85 DUP6 234D 84 DUP5 234E 61 PUSH2 0x2ce5 2351 56 *JUMP 2352 5B JUMPDEST 2353 50 POP 2354 50 POP 2355 01 ADD 2356 90 SWAP1 2357 56 *JUMP label_2358: // Incoming call from 0x2A4D, returns to 0x294D // Inputs[1] { @235E stack[-1] } 2358 5B JUMPDEST 2359 60 PUSH1 0x00 235B 61 PUSH2 0x2363 235E 82 DUP3 235F 61 PUSH2 0x2c9e 2362 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2359 stack[0] = 0x00 // @235B stack[1] = 0x2363 // @235E stack[2] = stack[-1] // } // Block ends with call to 0x2c9e, returns to 0x2363 label_2363: // Incoming return from call to 0x2C9E at 0x2362 // Inputs[2] // { // @2367 stack[-1] // @2368 stack[-4] // } 2363 5B JUMPDEST 2364 61 PUSH2 0x236d 2367 81 DUP2 2368 85 DUP6 2369 61 PUSH2 0x2ca2 236C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2364 stack[0] = 0x236d // @2367 stack[1] = stack[-1] // @2368 stack[2] = stack[-4] // } // Block ends with call to 0x2ca2, returns to 0x236D label_236D: // Incoming return from call to 0x2CA2 at 0x236C // Inputs[3] // { // @236E stack[-5] // @236E stack[-1] // @2373 stack[-4] // } 236D 5B JUMPDEST 236E 93 SWAP4 236F 50 POP 2370 61 PUSH2 0x2378 2373 83 DUP4 2374 61 PUSH2 0x2c98 2377 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @236E stack[-5] = stack[-1] // @2370 stack[-1] = 0x2378 // @2373 stack[0] = stack[-4] // } // Block ends with call to 0x2c98, returns to 0x2378 label_2378: // Incoming return from call to 0x2C98 at 0x2377 // Inputs[2] // { // @2379 stack[-1] // @237D stack[-2] // } 2378 5B JUMPDEST 2379 80 DUP1 237A 60 PUSH1 0x00 237C 5B JUMPDEST 237D 83 DUP4 237E 81 DUP2 237F 10 LT 2380 15 ISZERO 2381 61 PUSH2 0x22c6 2384 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2379 stack[0] = stack[-1] // @237A stack[1] = 0x00 // } // Block ends with conditional jump to 0x22c6, if !(0x00 < stack[-2]) label_2385: // Incoming jump from 0x2384, if not !(0x00 < stack[-2]) // Inputs[3] // { // @2385 stack[-2] // @2386 memory[stack[-2]:stack[-2] + 0x20] // @238A stack[-7] // } 2385 81 DUP2 2386 51 MLOAD 2387 61 PUSH2 0x2390 238A 88 DUP9 238B 82 DUP3 238C 61 PUSH2 0x225d 238F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2386 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2387 stack[1] = 0x2390 // @238A stack[2] = stack[-7] // @238B stack[3] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x225d 2390 5B JUMPDEST 2391 97 SWAP8 2392 50 POP 2393 61 PUSH2 0x239b 2396 83 DUP4 2397 61 PUSH2 0x2c98 239A 56 *JUMP 239B 5B JUMPDEST 239C 92 SWAP3 239D 50 POP 239E 50 POP 239F 60 PUSH1 0x01 23A1 01 ADD 23A2 61 PUSH2 0x237c 23A5 56 *JUMP label_23A6: // Incoming jump from 0x2A5B // Inputs[1] { @23AA stack[-1] } 23A6 5B JUMPDEST 23A7 61 PUSH2 0x2272 23AA 81 DUP2 23AB 61 PUSH2 0x2cb6 23AE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23A7 stack[0] = 0x2272 // @23AA stack[1] = stack[-1] // } // Block ends with call to 0x2cb6, returns to 0x2272 label_23AF: // Incoming jump from 0x2268 // Inputs[1] { @23B3 stack[-1] } 23AF 5B JUMPDEST 23B0 61 PUSH2 0x2272 23B3 81 DUP2 23B4 61 PUSH2 0x0a9a 23B7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23B0 stack[0] = 0x2272 // @23B3 stack[1] = stack[-1] // } // Block ends with call to 0x0a9a, returns to 0x2272 label_23B8: // Incoming call from 0x2AAA, returns to 0x294D // Inputs[1] { @23BE stack[-1] } 23B8 5B JUMPDEST 23B9 60 PUSH1 0x00 23BB 61 PUSH2 0x23c3 23BE 82 DUP3 23BF 61 PUSH2 0x2c9e 23C2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @23B9 stack[0] = 0x00 // @23BB stack[1] = 0x23c3 // @23BE stack[2] = stack[-1] // } // Block ends with call to 0x2c9e, returns to 0x23C3 label_23C3: // Incoming return from call to 0x2C9E at 0x23C2 // Inputs[2] // { // @23C7 stack[-1] // @23C8 stack[-4] // } 23C3 5B JUMPDEST 23C4 61 PUSH2 0x23cd 23C7 81 DUP2 23C8 85 DUP6 23C9 61 PUSH2 0x2ca2 23CC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @23C4 stack[0] = 0x23cd // @23C7 stack[1] = stack[-1] // @23C8 stack[2] = stack[-4] // } // Block ends with call to 0x2ca2, returns to 0x23CD label_23CD: // Incoming return from call to 0x2CA2 at 0x23CC // Inputs[4] // { // @23CE stack[-1] // @23CE stack[-5] // @23D3 stack[-2] // @23D7 stack[-4] // } 23CD 5B JUMPDEST 23CE 93 SWAP4 23CF 50 POP 23D0 61 PUSH2 0x23dd 23D3 81 DUP2 23D4 85 DUP6 23D5 60 PUSH1 0x20 23D7 86 DUP7 23D8 01 ADD 23D9 61 PUSH2 0x2cf1 23DC 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @23CE stack[-5] = stack[-1] // @23D0 stack[-1] = 0x23dd // @23D3 stack[0] = stack[-2] // @23D4 stack[1] = stack[-1] // @23D8 stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x2cf1, returns to 0x23DD label_23DD: // Incoming return from call to 0x2CF1 at 0x23DC // Inputs[1] { @23E1 stack[-1] } 23DD 5B JUMPDEST 23DE 61 PUSH2 0x23e6 23E1 81 DUP2 23E2 61 PUSH2 0x2d32 23E5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23DE stack[0] = 0x23e6 // @23E1 stack[1] = stack[-1] // } // Block ends with call to 0x2d32, returns to 0x23E6 label_23E6: // Incoming return from call to 0x2D32 at 0x23E5 // Inputs[4] // { // @23E7 stack[-1] // @23E7 stack[-2] // @23E8 stack[-5] // @23EA stack[-6] // } 23E6 5B JUMPDEST 23E7 90 SWAP1 23E8 93 SWAP4 23E9 01 ADD 23EA 93 SWAP4 23EB 92 SWAP3 23EC 50 POP 23ED 50 POP 23EE 50 POP 23EF 56 *JUMP // Stack delta = -5 // Outputs[1] { @23EA stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] 23F0 5B JUMPDEST 23F1 61 PUSH2 0x2272 23F4 61 PUSH2 0x23fc 23F7 82 DUP3 23F8 61 PUSH2 0x2cda 23FB 56 *JUMP 23FC 5B JUMPDEST 23FD 61 PUSH2 0x2d21 2400 56 *JUMP 2401 5B JUMPDEST 2402 60 PUSH1 0x00 2404 61 PUSH2 0x240e 2407 60 PUSH1 0x1c 2409 83 DUP4 240A 61 PUSH2 0x2ca2 240D 56 *JUMP 240E 5B JUMPDEST 240F 7F PUSH32 0x4665652076616c75652073686f756c6420626520706f73697469766500000000 2430 81 DUP2 2431 52 MSTORE 2432 60 PUSH1 0x20 2434 01 ADD 2435 92 SWAP3 2436 91 SWAP2 2437 50 POP 2438 50 POP 2439 56 *JUMP 243A 5B JUMPDEST 243B 60 PUSH1 0x00 243D 61 PUSH2 0x2447 2440 60 PUSH1 0x1f 2442 83 DUP4 2443 61 PUSH2 0x2ca2 2446 56 *JUMP 2447 5B JUMPDEST 2448 7F PUSH32 0x526f6c65733a206163636f756e7420616c72656164792068617320726f6c6500 2469 81 DUP2 246A 52 MSTORE 246B 60 PUSH1 0x20 246D 01 ADD 246E 92 SWAP3 246F 91 SWAP2 2470 50 POP 2471 50 POP 2472 56 *JUMP 2473 5B JUMPDEST 2474 60 PUSH1 0x00 2476 61 PUSH2 0x2480 2479 60 PUSH1 0x26 247B 83 DUP4 247C 61 PUSH2 0x2ca2 247F 56 *JUMP 2480 5B JUMPDEST 2481 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 24A2 81 DUP2 24A3 52 MSTORE 24A4 65 PUSH6 0x646472657373 24AB 60 PUSH1 0xd0 24AD 1B SHL 24AE 60 PUSH1 0x20 24B0 82 DUP3 24B1 01 ADD 24B2 52 MSTORE 24B3 60 PUSH1 0x40 24B5 01 ADD 24B6 92 SWAP3 24B7 91 SWAP2 24B8 50 POP 24B9 50 POP 24BA 56 *JUMP 24BB 5B JUMPDEST 24BC 60 PUSH1 0x00 24BE 61 PUSH2 0x24c8 24C1 60 PUSH1 0x20 24C3 83 DUP4 24C4 61 PUSH2 0x2ca2 24C7 56 *JUMP 24C8 5B JUMPDEST 24C9 7F PUSH32 0x5f736574546f6b656e5552493a20546f6b656e2073686f756c64206578697374 24EA 81 DUP2 24EB 52 MSTORE 24EC 60 PUSH1 0x20 24EE 01 ADD 24EF 92 SWAP3 24F0 91 SWAP2 24F1 50 POP 24F2 50 POP 24F3 56 *JUMP 24F4 5B JUMPDEST 24F5 60 PUSH1 0x00 24F7 61 PUSH2 0x2501 24FA 60 PUSH1 0x25 24FC 83 DUP4 24FD 61 PUSH2 0x2ca2 2500 56 *JUMP 2501 5B JUMPDEST 2502 7F PUSH32 0x64657374696e6174696f6e2061646472657373206d757374206265206e6f6e2d 2523 81 DUP2 2524 52 MSTORE 2525 64 PUSH5 0x3d32b93797 252B 60 PUSH1 0xd9 252D 1B SHL 252E 60 PUSH1 0x20 2530 82 DUP3 2531 01 ADD 2532 52 MSTORE 2533 60 PUSH1 0x40 2535 01 ADD 2536 92 SWAP3 2537 91 SWAP2 2538 50 POP 2539 50 POP 253A 56 *JUMP label_253B: // Incoming call from 0x2B0A, returns to 0x040F // Inputs[1] { @2543 stack[-1] } 253B 5B JUMPDEST 253C 60 PUSH1 0x00 253E 61 PUSH2 0x2548 2541 60 PUSH1 0x21 2543 83 DUP4 2544 61 PUSH2 0x2ca2 2547 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @253C stack[0] = 0x00 // @253E stack[1] = 0x2548 // @2541 stack[2] = 0x21 // @2543 stack[3] = stack[-1] // } // Block ends with call to 0x2ca2, returns to 0x2548 label_2548: // Incoming return from call to 0x2CA2 at 0x2547 // Inputs[3] // { // @256A stack[-1] // @2579 stack[-4] // @257A stack[-3] // } 2548 5B JUMPDEST 2549 7F PUSH32 0x526f6c65733a206163636f756e7420646f6573206e6f74206861766520726f6c 256A 81 DUP2 256B 52 MSTORE 256C 60 PUSH1 0x65 256E 60 PUSH1 0xf8 2570 1B SHL 2571 60 PUSH1 0x20 2573 82 DUP3 2574 01 ADD 2575 52 MSTORE 2576 60 PUSH1 0x40 2578 01 ADD 2579 92 SWAP3 257A 91 SWAP2 257B 50 POP 257C 50 POP 257D 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @256B memory[stack[-1]:stack[-1] + 0x20] = 0x526f6c65733a206163636f756e7420646f6573206e6f74206861766520726f6c // @2575 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x65 << 0xf8 // @2579 stack[-4] = 0x40 + stack[-1] // } // Block ends with unconditional jump to stack[-4] 257E 5B JUMPDEST 257F 60 PUSH1 0x00 2581 61 PUSH2 0x258b 2584 60 PUSH1 0x2b 2586 83 DUP4 2587 61 PUSH2 0x2ca2 258A 56 *JUMP 258B 5B JUMPDEST 258C 7F PUSH32 0x4e656564206f70657261746f7220617070726f76616c20666f72203372642070 25AD 81 DUP2 25AE 52 MSTORE 25AF 6A PUSH11 0x30b93a3c90313ab9373997 25BB 60 PUSH1 0xa9 25BD 1B SHL 25BE 60 PUSH1 0x20 25C0 82 DUP3 25C1 01 ADD 25C2 52 MSTORE 25C3 60 PUSH1 0x40 25C5 01 ADD 25C6 92 SWAP3 25C7 91 SWAP2 25C8 50 POP 25C9 50 POP 25CA 56 *JUMP 25CB 5B JUMPDEST 25CC 60 PUSH1 0x00 25CE 61 PUSH2 0x25d8 25D1 60 PUSH1 0x2f 25D3 83 DUP4 25D4 61 PUSH2 0x2ca2 25D7 56 *JUMP 25D8 5B JUMPDEST 25D9 7F PUSH32 0x4e656564206f70657261746f7220617070726f76616c20666f72203372642070 25FA 81 DUP2 25FB 52 MSTORE 25FC 6E PUSH15 0x30b93a3c903a3930b739b332b93997 260C 60 PUSH1 0x89 260E 1B SHL 260F 60 PUSH1 0x20 2611 82 DUP3 2612 01 ADD 2613 52 MSTORE 2614 60 PUSH1 0x40 2616 01 ADD 2617 92 SWAP3 2618 91 SWAP2 2619 50 POP 261A 50 POP 261B 56 *JUMP 261C 5B JUMPDEST 261D 60 PUSH1 0x00 261F 61 PUSH2 0x2629 2622 60 PUSH1 0x3e 2624 83 DUP4 2625 61 PUSH2 0x2ca2 2628 56 *JUMP 2629 5B JUMPDEST 262A 7F PUSH32 0x636f6e74726163742072657475726e656420616e20756e6b6e6f776e2076616c 264B 81 DUP2 264C 52 MSTORE 264D 7F PUSH32 0x75652066726f6d206f6e45524331313535426174636852656365697665640000 266E 60 PUSH1 0x20 2670 82 DUP3 2671 01 ADD 2672 52 MSTORE 2673 60 PUSH1 0x40 2675 01 ADD 2676 92 SWAP3 2677 91 SWAP2 2678 50 POP 2679 50 POP 267A 56 *JUMP label_267B: // Incoming call from 0x2B4A, returns to 0x040F // Inputs[1] { @2683 stack[-1] } 267B 5B JUMPDEST 267C 60 PUSH1 0x00 267E 61 PUSH2 0x2688 2681 60 PUSH1 0x20 2683 83 DUP4 2684 61 PUSH2 0x2ca2 2687 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @267C stack[0] = 0x00 // @267E stack[1] = 0x2688 // @2681 stack[2] = 0x20 // @2683 stack[3] = stack[-1] // } // Block ends with call to 0x2ca2, returns to 0x2688 label_2688: // Incoming return from call to 0x2CA2 at 0x2687 // Inputs[3] // { // @26AA stack[-1] // @26AF stack[-4] // @26B0 stack[-3] // } 2688 5B JUMPDEST 2689 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 26AA 81 DUP2 26AB 52 MSTORE 26AC 60 PUSH1 0x20 26AE 01 ADD 26AF 92 SWAP3 26B0 91 SWAP2 26B1 50 POP 26B2 50 POP 26B3 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @26AB memory[stack[-1]:stack[-1] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @26AF stack[-4] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-4] label_26B4: // Incoming call from 0x2B5A, returns to 0x040F // Inputs[1] { @26BC stack[-1] } 26B4 5B JUMPDEST 26B5 60 PUSH1 0x00 26B7 61 PUSH2 0x26c1 26BA 60 PUSH1 0x22 26BC 83 DUP4 26BD 61 PUSH2 0x2ca2 26C0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @26B5 stack[0] = 0x00 // @26B7 stack[1] = 0x26c1 // @26BA stack[2] = 0x22 // @26BC stack[3] = stack[-1] // } // Block ends with call to 0x2ca2, returns to 0x26C1 label_26C1: // Incoming return from call to 0x2CA2 at 0x26C0 // Inputs[3] // { // @26E3 stack[-1] // @26F3 stack[-4] // @26F4 stack[-3] // } 26C1 5B JUMPDEST 26C2 7F PUSH32 0x526f6c65733a206163636f756e7420697320746865207a65726f206164647265 26E3 81 DUP2 26E4 52 MSTORE 26E5 61 PUSH2 0x7373 26E8 60 PUSH1 0xf0 26EA 1B SHL 26EB 60 PUSH1 0x20 26ED 82 DUP3 26EE 01 ADD 26EF 52 MSTORE 26F0 60 PUSH1 0x40 26F2 01 ADD 26F3 92 SWAP3 26F4 91 SWAP2 26F5 50 POP 26F6 50 POP 26F7 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @26E4 memory[stack[-1]:stack[-1] + 0x20] = 0x526f6c65733a206163636f756e7420697320746865207a65726f206164647265 // @26EF memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x7373 << 0xf0 // @26F3 stack[-4] = 0x40 + stack[-1] // } // Block ends with unconditional jump to stack[-4] 26F8 5B JUMPDEST 26F9 60 PUSH1 0x00 26FB 61 PUSH2 0x2705 26FE 60 PUSH1 0x17 2700 83 DUP4 2701 61 PUSH2 0x2ca2 2704 56 *JUMP 2705 5B JUMPDEST 2706 7F PUSH32 0x546f6b656e20697320616c7265616479206d696e746564000000000000000000 2727 81 DUP2 2728 52 MSTORE 2729 60 PUSH1 0x20 272B 01 ADD 272C 92 SWAP3 272D 91 SWAP2 272E 50 POP 272F 50 POP 2730 56 *JUMP 2731 5B JUMPDEST 2732 60 PUSH1 0x00 2734 61 PUSH2 0x273e 2737 60 PUSH1 0x19 2739 83 DUP4 273A 61 PUSH2 0x2ca2 273D 56 *JUMP 273E 5B JUMPDEST 273F 7F PUSH32 0x537570706c792073686f756c6420626520706f73697469766500000000000000 2760 81 DUP2 2761 52 MSTORE 2762 60 PUSH1 0x20 2764 01 ADD 2765 92 SWAP3 2766 91 SWAP2 2767 50 POP 2768 50 POP 2769 56 *JUMP 276A 5B JUMPDEST 276B 60 PUSH1 0x00 276D 61 PUSH2 0x2777 2770 60 PUSH1 0x29 2772 83 DUP4 2773 61 PUSH2 0x2ca2 2776 56 *JUMP 2777 5B JUMPDEST 2778 7F PUSH32 0x5f69647320616e64205f76616c756573206172726179206c656e676874206d75 2799 81 DUP2 279A 52 MSTORE 279B 68 PUSH9 0x39ba1036b0ba31b417 27A5 60 PUSH1 0xb9 27A7 1B SHL 27A8 60 PUSH1 0x20 27AA 82 DUP3 27AB 01 ADD 27AC 52 MSTORE 27AD 60 PUSH1 0x40 27AF 01 ADD 27B0 92 SWAP3 27B1 91 SWAP2 27B2 50 POP 27B3 50 POP 27B4 56 *JUMP 27B5 5B JUMPDEST 27B6 60 PUSH1 0x00 27B8 61 PUSH2 0x27c2 27BB 60 PUSH1 0x1b 27BD 83 DUP4 27BE 61 PUSH2 0x2ca2 27C1 56 *JUMP 27C2 5B JUMPDEST 27C3 7F PUSH32 0x526563697069656e742073686f756c642062652070726573656e740000000000 27E4 81 DUP2 27E5 52 MSTORE 27E6 60 PUSH1 0x20 27E8 01 ADD 27E9 92 SWAP3 27EA 91 SWAP2 27EB 50 POP 27EC 50 POP 27ED 56 *JUMP 27EE 5B JUMPDEST 27EF 60 PUSH1 0x00 27F1 61 PUSH2 0x27fb 27F4 60 PUSH1 0x39 27F6 83 DUP4 27F7 61 PUSH2 0x2ca2 27FA 56 *JUMP 27FB 5B JUMPDEST 27FC 7F PUSH32 0x636f6e74726163742072657475726e656420616e20756e6b6e6f776e2076616c 281D 81 DUP2 281E 52 MSTORE 281F 7F PUSH32 0x75652066726f6d206f6e45524331313535526563656976656400000000000000 2840 60 PUSH1 0x20 2842 82 DUP3 2843 01 ADD 2844 52 MSTORE 2845 60 PUSH1 0x40 2847 01 ADD 2848 92 SWAP3 2849 91 SWAP2 284A 50 POP 284B 50 POP 284C 56 *JUMP 284D 5B JUMPDEST 284E 60 PUSH1 0x00 2850 61 PUSH2 0x285a 2853 60 PUSH1 0x15 2855 83 DUP4 2856 61 PUSH2 0x2ca2 2859 56 *JUMP 285A 5B JUMPDEST 285B 74 PUSH21 0x2fba379036bab9ba103132903737b716bd32b93797 2871 60 PUSH1 0x59 2873 1B SHL 2874 81 DUP2 2875 52 MSTORE 2876 60 PUSH1 0x20 2878 01 ADD 2879 92 SWAP3 287A 91 SWAP2 287B 50 POP 287C 50 POP 287D 56 *JUMP 287E 5B JUMPDEST 287F 60 PUSH1 0x00 2881 61 PUSH2 0x288b 2884 60 PUSH1 0x1a 2886 83 DUP4 2887 61 PUSH2 0x2ca2 288A 56 *JUMP 288B 5B JUMPDEST 288C 7F PUSH32 0x7369676e65722073686f756c64207369676e20746f6b656e4964000000000000 28AD 81 DUP2 28AE 52 MSTORE 28AF 60 PUSH1 0x20 28B1 01 ADD 28B2 92 SWAP3 28B3 91 SWAP2 28B4 50 POP 28B5 50 POP 28B6 56 *JUMP 28B7 5B JUMPDEST 28B8 60 PUSH1 0x00 28BA 61 PUSH2 0x28c4 28BD 60 PUSH1 0x11 28BF 83 DUP4 28C0 61 PUSH2 0x2ca2 28C3 56 *JUMP 28C4 5B JUMPDEST 28C5 70 PUSH17 0x1d5c9a481cda1bdd5b19081899481cd95d 28D7 60 PUSH1 0x7a 28D9 1B SHL 28DA 81 DUP2 28DB 52 MSTORE 28DC 60 PUSH1 0x20 28DE 01 ADD 28DF 92 SWAP3 28E0 91 SWAP2 28E1 50 POP 28E2 50 POP 28E3 56 *JUMP 28E4 5B JUMPDEST 28E5 61 PUSH2 0x2272 28E8 61 PUSH2 0x28f0 28EB 82 DUP3 28EC 61 PUSH2 0x0a9a 28EF 56 *JUMP 28F0 5B JUMPDEST 28F1 61 PUSH2 0x0a9a 28F4 56 *JUMP 28F5 5B JUMPDEST 28F6 61 PUSH2 0x2272 28F9 81 DUP2 28FA 61 PUSH2 0x2cd4 28FD 56 *JUMP 28FE 5B JUMPDEST 28FF 60 PUSH1 0x00 2901 61 PUSH2 0x290a 2904 82 DUP3 2905 85 DUP6 2906 61 PUSH2 0x23f0 2909 56 *JUMP 290A 5B JUMPDEST 290B 60 PUSH1 0x14 290D 82 DUP3 290E 01 ADD 290F 91 SWAP2 2910 50 POP 2911 61 PUSH2 0x291a 2914 82 DUP3 2915 84 DUP5 2916 61 PUSH2 0x28e4 2919 56 *JUMP 291A 5B JUMPDEST 291B 50 POP 291C 60 PUSH1 0x20 291E 01 ADD 291F 92 SWAP3 2920 91 SWAP2 2921 50 POP 2922 50 POP 2923 56 *JUMP label_2924: // Incoming jump from 0x02E4 // Inputs[2] // { // @2927 stack[-1] // @292D stack[-2] // } 2924 5B JUMPDEST 2925 60 PUSH1 0x20 2927 81 DUP2 2928 01 ADD 2929 61 PUSH2 0x040f 292C 82 DUP3 292D 84 DUP5 292E 61 PUSH2 0x2269 2931 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2928 stack[0] = stack[-1] + 0x20 // @2929 stack[1] = 0x040f // @292C stack[2] = stack[-1] // @292D stack[3] = stack[-2] // } // Block ends with call to 0x2269, returns to 0x040F 2932 5B JUMPDEST 2933 60 PUSH1 0x40 2935 81 DUP2 2936 01 ADD 2937 61 PUSH2 0x2940 293A 82 DUP3 293B 85 DUP6 293C 61 PUSH2 0x2269 293F 56 *JUMP 2940 5B JUMPDEST 2941 61 PUSH2 0x294d 2944 60 PUSH1 0x20 2946 83 DUP4 2947 01 ADD 2948 84 DUP5 2949 61 PUSH2 0x23af 294C 56 *JUMP label_294D: // Incoming return from call to 0x23B8 at 0x2AAA // Incoming return from call to 0x2358 at 0x2A4D // Inputs[3] // { // @294E stack[-1] // @294E stack[-5] // @294F stack[-4] // } 294D 5B JUMPDEST 294E 93 SWAP4 294F 92 SWAP3 2950 50 POP 2951 50 POP 2952 50 POP 2953 56 *JUMP // Stack delta = -4 // Outputs[1] { @294E stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] 2954 5B JUMPDEST 2955 60 PUSH1 0xa0 2957 81 DUP2 2958 01 ADD 2959 61 PUSH2 0x2962 295C 82 DUP3 295D 88 DUP9 295E 61 PUSH2 0x2269 2961 56 *JUMP 2962 5B JUMPDEST 2963 61 PUSH2 0x296f 2966 60 PUSH1 0x20 2968 83 DUP4 2969 01 ADD 296A 87 DUP8 296B 61 PUSH2 0x2269 296E 56 *JUMP 296F 5B JUMPDEST 2970 81 DUP2 2971 81 DUP2 2972 03 SUB 2973 60 PUSH1 0x40 2975 83 DUP4 2976 01 ADD 2977 52 MSTORE 2978 61 PUSH2 0x2981 297B 81 DUP2 297C 86 DUP7 297D 61 PUSH2 0x2358 2980 56 *JUMP 2981 5B JUMPDEST 2982 90 SWAP1 2983 50 POP 2984 81 DUP2 2985 81 DUP2 2986 03 SUB 2987 60 PUSH1 0x60 2989 83 DUP4 298A 01 ADD 298B 52 MSTORE 298C 61 PUSH2 0x2995 298F 81 DUP2 2990 85 DUP6 2991 61 PUSH2 0x2358 2994 56 *JUMP 2995 5B JUMPDEST 2996 90 SWAP1 2997 50 POP 2998 81 DUP2 2999 81 DUP2 299A 03 SUB 299B 60 PUSH1 0x80 299D 83 DUP4 299E 01 ADD 299F 52 MSTORE 29A0 61 PUSH2 0x29a9 29A3 81 DUP2 29A4 84 DUP5 29A5 61 PUSH2 0x23b8 29A8 56 *JUMP 29A9 5B JUMPDEST 29AA 97 SWAP8 29AB 96 SWAP7 29AC 50 POP 29AD 50 POP 29AE 50 POP 29AF 50 POP 29B0 50 POP 29B1 50 POP 29B2 50 POP 29B3 56 *JUMP 29B4 5B JUMPDEST 29B5 60 PUSH1 0xa0 29B7 81 DUP2 29B8 01 ADD 29B9 61 PUSH2 0x29c2 29BC 82 DUP3 29BD 88 DUP9 29BE 61 PUSH2 0x2269 29C1 56 *JUMP 29C2 5B JUMPDEST 29C3 61 PUSH2 0x29cf 29C6 60 PUSH1 0x20 29C8 83 DUP4 29C9 01 ADD 29CA 87 DUP8 29CB 61 PUSH2 0x2269 29CE 56 *JUMP 29CF 5B JUMPDEST 29D0 61 PUSH2 0x29dc 29D3 60 PUSH1 0x40 29D5 83 DUP4 29D6 01 ADD 29D7 86 DUP7 29D8 61 PUSH2 0x23af 29DB 56 *JUMP 29DC 5B JUMPDEST 29DD 61 PUSH2 0x29e9 29E0 60 PUSH1 0x60 29E2 83 DUP4 29E3 01 ADD 29E4 85 DUP6 29E5 61 PUSH2 0x23af 29E8 56 *JUMP 29E9 5B JUMPDEST 29EA 81 DUP2 29EB 81 DUP2 29EC 03 SUB 29ED 60 PUSH1 0x80 29EF 83 DUP4 29F0 01 ADD 29F1 52 MSTORE 29F2 61 PUSH2 0x29a9 29F5 81 DUP2 29F6 84 DUP5 29F7 61 PUSH2 0x23b8 29FA 56 *JUMP 29FB 5B JUMPDEST 29FC 60 PUSH1 0x20 29FE 80 DUP1 29FF 82 DUP3 2A00 52 MSTORE 2A01 81 DUP2 2A02 01 ADD 2A03 61 PUSH2 0x294d 2A06 81 DUP2 2A07 84 DUP5 2A08 61 PUSH2 0x22d1 2A0B 56 *JUMP 2A0C 5B JUMPDEST 2A0D 60 PUSH1 0x40 2A0F 80 DUP1 2A10 82 DUP3 2A11 52 MSTORE 2A12 81 DUP2 2A13 01 ADD 2A14 61 PUSH2 0x2a1e 2A17 81 DUP2 2A18 86 DUP7 2A19 88 DUP9 2A1A 61 PUSH2 0x231f 2A1D 56 *JUMP 2A1E 5B JUMPDEST 2A1F 90 SWAP1 2A20 50 POP 2A21 81 DUP2 2A22 81 DUP2 2A23 03 SUB 2A24 60 PUSH1 0x20 2A26 83 DUP4 2A27 01 ADD 2A28 52 MSTORE 2A29 61 PUSH2 0x2a33 2A2C 81 DUP2 2A2D 84 DUP5 2A2E 86 DUP7 2A2F 61 PUSH2 0x231f 2A32 56 *JUMP 2A33 5B JUMPDEST 2A34 96 SWAP7 2A35 95 SWAP6 2A36 50 POP 2A37 50 POP 2A38 50 POP 2A39 50 POP 2A3A 50 POP 2A3B 50 POP 2A3C 56 *JUMP label_2A3D: // Incoming jump from 0x026D // Inputs[2] // { // @2A41 stack[-1] // @2A49 stack[-2] // } 2A3D 5B JUMPDEST 2A3E 60 PUSH1 0x20 2A40 80 DUP1 2A41 82 DUP3 2A42 52 MSTORE 2A43 81 DUP2 2A44 01 ADD 2A45 61 PUSH2 0x294d 2A48 81 DUP2 2A49 84 DUP5 2A4A 61 PUSH2 0x2358 2A4D 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2A42 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2A44 stack[0] = stack[-1] + 0x20 // @2A45 stack[1] = 0x294d // @2A48 stack[2] = stack[-1] + 0x20 // @2A49 stack[3] = stack[-2] // } // Block ends with call to 0x2358, returns to 0x294D label_2A4E: // Incoming jump from 0x0210 // Inputs[2] // { // @2A51 stack[-1] // @2A57 stack[-2] // } 2A4E 5B JUMPDEST 2A4F 60 PUSH1 0x20 2A51 81 DUP2 2A52 01 ADD 2A53 61 PUSH2 0x040f 2A56 82 DUP3 2A57 84 DUP5 2A58 61 PUSH2 0x23a6 2A5B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2A52 stack[0] = stack[-1] + 0x20 // @2A53 stack[1] = 0x040f // @2A56 stack[2] = stack[-1] // @2A57 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x23a6 2A5C 5B JUMPDEST 2A5D 60 PUSH1 0x80 2A5F 81 DUP2 2A60 01 ADD 2A61 61 PUSH2 0x2a6a 2A64 82 DUP3 2A65 87 DUP8 2A66 61 PUSH2 0x23af 2A69 56 *JUMP 2A6A 5B JUMPDEST 2A6B 61 PUSH2 0x2a77 2A6E 60 PUSH1 0x20 2A70 83 DUP4 2A71 01 ADD 2A72 86 DUP7 2A73 61 PUSH2 0x28f5 2A76 56 *JUMP 2A77 5B JUMPDEST 2A78 61 PUSH2 0x2a84 2A7B 60 PUSH1 0x40 2A7D 83 DUP4 2A7E 01 ADD 2A7F 85 DUP6 2A80 61 PUSH2 0x23af 2A83 56 *JUMP 2A84 5B JUMPDEST 2A85 61 PUSH2 0x2a91 2A88 60 PUSH1 0x60 2A8A 83 DUP4 2A8B 01 ADD 2A8C 84 DUP5 2A8D 61 PUSH2 0x23af 2A90 56 *JUMP 2A91 5B JUMPDEST 2A92 95 SWAP6 2A93 94 SWAP5 2A94 50 POP 2A95 50 POP 2A96 50 POP 2A97 50 POP 2A98 50 POP 2A99 56 *JUMP label_2A9A: // Incoming call from 0x0225, returns to 0x01E8 // Inputs[2] // { // @2A9E stack[-1] // @2AA6 stack[-2] // } 2A9A 5B JUMPDEST 2A9B 60 PUSH1 0x20 2A9D 80 DUP1 2A9E 82 DUP3 2A9F 52 MSTORE 2AA0 81 DUP2 2AA1 01 ADD 2AA2 61 PUSH2 0x294d 2AA5 81 DUP2 2AA6 84 DUP5 2AA7 61 PUSH2 0x23b8 2AAA 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2A9F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2AA1 stack[0] = stack[-1] + 0x20 // @2AA2 stack[1] = 0x294d // @2AA5 stack[2] = stack[-1] + 0x20 // @2AA6 stack[3] = stack[-2] // } // Block ends with call to 0x23b8, returns to 0x294D 2AAB 5B JUMPDEST 2AAC 60 PUSH1 0x20 2AAE 80 DUP1 2AAF 82 DUP3 2AB0 52 MSTORE 2AB1 81 DUP2 2AB2 01 ADD 2AB3 61 PUSH2 0x040f 2AB6 81 DUP2 2AB7 61 PUSH2 0x2401 2ABA 56 *JUMP 2ABB 5B JUMPDEST 2ABC 60 PUSH1 0x20 2ABE 80 DUP1 2ABF 82 DUP3 2AC0 52 MSTORE 2AC1 81 DUP2 2AC2 01 ADD 2AC3 61 PUSH2 0x040f 2AC6 81 DUP2 2AC7 61 PUSH2 0x243a 2ACA 56 *JUMP 2ACB 5B JUMPDEST 2ACC 60 PUSH1 0x20 2ACE 80 DUP1 2ACF 82 DUP3 2AD0 52 MSTORE 2AD1 81 DUP2 2AD2 01 ADD 2AD3 61 PUSH2 0x040f 2AD6 81 DUP2 2AD7 61 PUSH2 0x2473 2ADA 56 *JUMP 2ADB 5B JUMPDEST 2ADC 60 PUSH1 0x20 2ADE 80 DUP1 2ADF 82 DUP3 2AE0 52 MSTORE 2AE1 81 DUP2 2AE2 01 ADD 2AE3 61 PUSH2 0x040f 2AE6 81 DUP2 2AE7 61 PUSH2 0x24bb 2AEA 56 *JUMP 2AEB 5B JUMPDEST 2AEC 60 PUSH1 0x20 2AEE 80 DUP1 2AEF 82 DUP3 2AF0 52 MSTORE 2AF1 81 DUP2 2AF2 01 ADD 2AF3 61 PUSH2 0x040f 2AF6 81 DUP2 2AF7 61 PUSH2 0x24f4 2AFA 56 *JUMP label_2AFB: // Incoming jump from 0x1680 // Inputs[1] { @2AFF stack[-1] } 2AFB 5B JUMPDEST 2AFC 60 PUSH1 0x20 2AFE 80 DUP1 2AFF 82 DUP3 2B00 52 MSTORE 2B01 81 DUP2 2B02 01 ADD 2B03 61 PUSH2 0x040f 2B06 81 DUP2 2B07 61 PUSH2 0x253b 2B0A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2B00 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2B02 stack[0] = stack[-1] + 0x20 // @2B03 stack[1] = 0x040f // @2B06 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x253b, returns to 0x040F 2B0B 5B JUMPDEST 2B0C 60 PUSH1 0x20 2B0E 80 DUP1 2B0F 82 DUP3 2B10 52 MSTORE 2B11 81 DUP2 2B12 01 ADD 2B13 61 PUSH2 0x040f 2B16 81 DUP2 2B17 61 PUSH2 0x257e 2B1A 56 *JUMP 2B1B 5B JUMPDEST 2B1C 60 PUSH1 0x20 2B1E 80 DUP1 2B1F 82 DUP3 2B20 52 MSTORE 2B21 81 DUP2 2B22 01 ADD 2B23 61 PUSH2 0x040f 2B26 81 DUP2 2B27 61 PUSH2 0x25cb 2B2A 56 *JUMP 2B2B 5B JUMPDEST 2B2C 60 PUSH1 0x20 2B2E 80 DUP1 2B2F 82 DUP3 2B30 52 MSTORE 2B31 81 DUP2 2B32 01 ADD 2B33 61 PUSH2 0x040f 2B36 81 DUP2 2B37 61 PUSH2 0x261c 2B3A 56 *JUMP label_2B3B: // Incoming jump from 0x0A2F // Incoming jump from 0x0AE6 // Incoming jump from 0x0B6E // Inputs[1] { @2B3F stack[-1] } 2B3B 5B JUMPDEST 2B3C 60 PUSH1 0x20 2B3E 80 DUP1 2B3F 82 DUP3 2B40 52 MSTORE 2B41 81 DUP2 2B42 01 ADD 2B43 61 PUSH2 0x040f 2B46 81 DUP2 2B47 61 PUSH2 0x267b 2B4A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2B40 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2B42 stack[0] = stack[-1] + 0x20 // @2B43 stack[1] = 0x040f // @2B46 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x267b, returns to 0x040F label_2B4B: // Incoming jump from 0x13EC // Inputs[1] { @2B4F stack[-1] } 2B4B 5B JUMPDEST 2B4C 60 PUSH1 0x20 2B4E 80 DUP1 2B4F 82 DUP3 2B50 52 MSTORE 2B51 81 DUP2 2B52 01 ADD 2B53 61 PUSH2 0x040f 2B56 81 DUP2 2B57 61 PUSH2 0x26b4 2B5A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2B50 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2B52 stack[0] = stack[-1] + 0x20 // @2B53 stack[1] = 0x040f // @2B56 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x26b4, returns to 0x040F 2B5B 5B JUMPDEST 2B5C 60 PUSH1 0x20 2B5E 80 DUP1 2B5F 82 DUP3 2B60 52 MSTORE 2B61 81 DUP2 2B62 01 ADD 2B63 61 PUSH2 0x040f 2B66 81 DUP2 2B67 61 PUSH2 0x26f8 2B6A 56 *JUMP 2B6B 5B JUMPDEST 2B6C 60 PUSH1 0x20 2B6E 80 DUP1 2B6F 82 DUP3 2B70 52 MSTORE 2B71 81 DUP2 2B72 01 ADD 2B73 61 PUSH2 0x040f 2B76 81 DUP2 2B77 61 PUSH2 0x2731 2B7A 56 *JUMP 2B7B 5B JUMPDEST 2B7C 60 PUSH1 0x20 2B7E 80 DUP1 2B7F 82 DUP3 2B80 52 MSTORE 2B81 81 DUP2 2B82 01 ADD 2B83 61 PUSH2 0x040f 2B86 81 DUP2 2B87 61 PUSH2 0x276a 2B8A 56 *JUMP 2B8B 5B JUMPDEST 2B8C 60 PUSH1 0x20 2B8E 80 DUP1 2B8F 82 DUP3 2B90 52 MSTORE 2B91 81 DUP2 2B92 01 ADD 2B93 61 PUSH2 0x040f 2B96 81 DUP2 2B97 61 PUSH2 0x27b5 2B9A 56 *JUMP 2B9B 5B JUMPDEST 2B9C 60 PUSH1 0x20 2B9E 80 DUP1 2B9F 82 DUP3 2BA0 52 MSTORE 2BA1 81 DUP2 2BA2 01 ADD 2BA3 61 PUSH2 0x040f 2BA6 81 DUP2 2BA7 61 PUSH2 0x27ee 2BAA 56 *JUMP 2BAB 5B JUMPDEST 2BAC 60 PUSH1 0x20 2BAE 80 DUP1 2BAF 82 DUP3 2BB0 52 MSTORE 2BB1 81 DUP2 2BB2 01 ADD 2BB3 61 PUSH2 0x040f 2BB6 81 DUP2 2BB7 61 PUSH2 0x284d 2BBA 56 *JUMP 2BBB 5B JUMPDEST 2BBC 60 PUSH1 0x20 2BBE 80 DUP1 2BBF 82 DUP3 2BC0 52 MSTORE 2BC1 81 DUP2 2BC2 01 ADD 2BC3 61 PUSH2 0x040f 2BC6 81 DUP2 2BC7 61 PUSH2 0x287e 2BCA 56 *JUMP 2BCB 5B JUMPDEST 2BCC 60 PUSH1 0x20 2BCE 80 DUP1 2BCF 82 DUP3 2BD0 52 MSTORE 2BD1 81 DUP2 2BD2 01 ADD 2BD3 61 PUSH2 0x040f 2BD6 81 DUP2 2BD7 61 PUSH2 0x28b7 2BDA 56 *JUMP 2BDB 5B JUMPDEST 2BDC 60 PUSH1 0x20 2BDE 81 DUP2 2BDF 01 ADD 2BE0 61 PUSH2 0x040f 2BE3 82 DUP3 2BE4 84 DUP5 2BE5 61 PUSH2 0x23af 2BE8 56 *JUMP 2BE9 5B JUMPDEST 2BEA 60 PUSH1 0x60 2BEC 81 DUP2 2BED 01 ADD 2BEE 61 PUSH2 0x2bf7 2BF1 82 DUP3 2BF2 86 DUP7 2BF3 61 PUSH2 0x23af 2BF6 56 *JUMP 2BF7 5B JUMPDEST 2BF8 81 DUP2 2BF9 81 DUP2 2BFA 03 SUB 2BFB 60 PUSH1 0x20 2BFD 83 DUP4 2BFE 01 ADD 2BFF 52 MSTORE 2C00 61 PUSH2 0x2c09 2C03 81 DUP2 2C04 85 DUP6 2C05 61 PUSH2 0x2278 2C08 56 *JUMP 2C09 5B JUMPDEST 2C0A 90 SWAP1 2C0B 50 POP 2C0C 81 DUP2 2C0D 81 DUP2 2C0E 03 SUB 2C0F 60 PUSH1 0x40 2C11 83 DUP4 2C12 01 ADD 2C13 52 MSTORE 2C14 61 PUSH2 0x2a91 2C17 81 DUP2 2C18 84 DUP5 2C19 61 PUSH2 0x2358 2C1C 56 *JUMP 2C1D 5B JUMPDEST 2C1E 60 PUSH1 0x40 2C20 81 DUP2 2C21 01 ADD 2C22 61 PUSH2 0x2940 2C25 82 DUP3 2C26 85 DUP6 2C27 61 PUSH2 0x23af 2C2A 56 *JUMP label_2C2B: // Incoming jump from 0x1C9D // Inputs[2] // { // @2C2E memory[0x40:0x60] // @2C2F stack[-1] // } 2C2B 5B JUMPDEST 2C2C 60 PUSH1 0x40 2C2E 51 MLOAD 2C2F 81 DUP2 2C30 81 DUP2 2C31 01 ADD 2C32 60 PUSH1 0x01 2C34 60 PUSH1 0x01 2C36 60 PUSH1 0x40 2C38 1B SHL 2C39 03 SUB 2C3A 81 DUP2 2C3B 11 GT 2C3C 82 DUP3 2C3D 82 DUP3 2C3E 10 LT 2C3F 17 OR 2C40 15 ISZERO 2C41 61 PUSH2 0x2c49 2C44 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2C2E stack[0] = memory[0x40:0x60] // @2C31 stack[1] = memory[0x40:0x60] + stack[-1] // } // Block ends with conditional jump to 0x2c49, if !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > (0x01 << 0x40) - 0x01)) label_2C45: // Incoming jump from 0x2C44, if not !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > (0x01 << 0x40) - 0x01)) // Inputs[1] { @2C48 memory[0x00:0x00] } 2C45 60 PUSH1 0x00 2C47 80 DUP1 2C48 FD *REVERT // Stack delta = +0 // Outputs[1] { @2C48 revert(memory[0x00:0x00]); } // Block terminates label_2C49: // Incoming jump from 0x2C44, if !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > (0x01 << 0x40) - 0x01)) // Inputs[4] // { // @2C4C stack[-1] // @2C4D stack[-2] // @2C4D stack[-4] // @2C4E stack[-3] // } 2C49 5B JUMPDEST 2C4A 60 PUSH1 0x40 2C4C 52 MSTORE 2C4D 91 SWAP2 2C4E 90 SWAP1 2C4F 50 POP 2C50 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2C4C memory[0x40:0x60] = stack[-1] // @2C4D stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] 2C51 5B JUMPDEST 2C52 60 PUSH1 0x00 2C54 60 PUSH1 0x01 2C56 60 PUSH1 0x01 2C58 60 PUSH1 0x40 2C5A 1B SHL 2C5B 03 SUB 2C5C 82 DUP3 2C5D 11 GT 2C5E 15 ISZERO 2C5F 61 PUSH2 0x2c67 2C62 57 *JUMPI 2C63 60 PUSH1 0x00 2C65 80 DUP1 2C66 FD *REVERT 2C67 5B JUMPDEST 2C68 50 POP 2C69 60 PUSH1 0x20 2C6B 90 SWAP1 2C6C 81 DUP2 2C6D 02 MUL 2C6E 01 ADD 2C6F 90 SWAP1 2C70 56 *JUMP label_2C71: // Incoming call from 0x1D86, returns to 0x1C99 // Inputs[1] { @2C7C stack[-1] } 2C71 5B JUMPDEST 2C72 60 PUSH1 0x00 2C74 60 PUSH1 0x01 2C76 60 PUSH1 0x01 2C78 60 PUSH1 0x40 2C7A 1B SHL 2C7B 03 SUB 2C7C 82 DUP3 2C7D 11 GT 2C7E 15 ISZERO 2C7F 61 PUSH2 0x2c87 2C82 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2C72 stack[0] = 0x00 } // Block ends with conditional jump to 0x2c87, if !(stack[-1] > (0x01 << 0x40) - 0x01) label_2C83: // Incoming jump from 0x2C82, if not !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2C86 memory[0x00:0x00] } 2C83 60 PUSH1 0x00 2C85 80 DUP1 2C86 FD *REVERT // Stack delta = +0 // Outputs[1] { @2C86 revert(memory[0x00:0x00]); } // Block terminates label_2C87: // Incoming jump from 0x2C82, if !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @2C8D stack[-2] // @2C96 stack[-3] // } 2C87 5B JUMPDEST 2C88 50 POP 2C89 60 PUSH1 0x20 2C8B 60 PUSH1 0x1f 2C8D 91 SWAP2 2C8E 90 SWAP1 2C8F 91 SWAP2 2C90 01 ADD 2C91 60 PUSH1 0x1f 2C93 19 NOT 2C94 16 AND 2C95 01 ADD 2C96 90 SWAP1 2C97 56 *JUMP // Stack delta = -2 // Outputs[1] { @2C96 stack[-3] = (~0x1f & 0x1f + stack[-2]) + 0x20 } // Block ends with unconditional jump to stack[-3] label_2C98: // Incoming call from 0x2377, returns to 0x2378 // Inputs[2] // { // @2C9B stack[-1] // @2C9C stack[-2] // } 2C98 5B JUMPDEST 2C99 60 PUSH1 0x20 2C9B 01 ADD 2C9C 90 SWAP1 2C9D 56 *JUMP // Stack delta = -1 // Outputs[1] { @2C9C stack[-2] = 0x20 + stack[-1] } // Block ends with unconditional jump to stack[-2] label_2C9E: // Incoming call from 0x2362, returns to 0x2363 // Incoming call from 0x23C2, returns to 0x23C3 // Inputs[3] // { // @2C9F memory[stack[-1]:stack[-1] + 0x20] // @2C9F stack[-1] // @2CA0 stack[-2] // } 2C9E 5B JUMPDEST 2C9F 51 MLOAD 2CA0 90 SWAP1 2CA1 56 *JUMP // Stack delta = -1 // Outputs[1] { @2CA0 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_2CA2: // Incoming call from 0x2687, returns to 0x2688 // Incoming call from 0x23CC, returns to 0x23CD // Incoming call from 0x26C0, returns to 0x26C1 // Incoming call from 0x236C, returns to 0x236D // Incoming call from 0x2547, returns to 0x2548 // Inputs[3] // { // @2CA3 stack[-2] // @2CA3 stack[-1] // @2CA9 stack[-3] // } 2CA2 5B JUMPDEST 2CA3 90 SWAP1 2CA4 81 DUP2 2CA5 52 MSTORE 2CA6 60 PUSH1 0x20 2CA8 01 ADD 2CA9 90 SWAP1 2CAA 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2CA5 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @2CA9 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_2CAB: // Incoming call from 0x2D4A, returns to 0x2D4B // Incoming call from 0x2271, returns to 0x2272 // Inputs[1] { @2CB1 stack[-1] } 2CAB 5B JUMPDEST 2CAC 60 PUSH1 0x00 2CAE 61 PUSH2 0x040f 2CB1 82 DUP3 2CB2 61 PUSH2 0x2cc8 2CB5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2CAC stack[0] = 0x00 // @2CAE stack[1] = 0x040f // @2CB1 stack[2] = stack[-1] // } // Block ends with call to 0x2cc8, returns to 0x040F label_2CB6: // Incoming call from 0x23AE, returns to 0x2272 // Inputs[2] // { // @2CB7 stack[-1] // @2CB9 stack[-2] // } 2CB6 5B JUMPDEST 2CB7 15 ISZERO 2CB8 15 ISZERO 2CB9 90 SWAP1 2CBA 56 *JUMP // Stack delta = -1 // Outputs[1] { @2CB9 stack[-2] = !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_2CBB: // Incoming call from 0x2D70, returns to 0x2D4B // Inputs[2] // { // @2CC5 stack[-1] // @2CC6 stack[-2] // } 2CBB 5B JUMPDEST 2CBC 60 PUSH1 0x01 2CBE 60 PUSH1 0x01 2CC0 60 PUSH1 0xe0 2CC2 1B SHL 2CC3 03 SUB 2CC4 19 NOT 2CC5 16 AND 2CC6 90 SWAP1 2CC7 56 *JUMP // Stack delta = -1 // Outputs[1] { @2CC6 stack[-2] = ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block ends with unconditional jump to stack[-2] label_2CC8: // Incoming call from 0x2CB5, returns to 0x040F // Inputs[2] // { // @2CD1 stack[-1] // @2CD2 stack[-2] // } 2CC8 5B JUMPDEST 2CC9 60 PUSH1 0x01 2CCB 60 PUSH1 0x01 2CCD 60 PUSH1 0xa0 2CCF 1B SHL 2CD0 03 SUB 2CD1 16 AND 2CD2 90 SWAP1 2CD3 56 *JUMP // Stack delta = -1 // Outputs[1] { @2CD2 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] } // Block ends with unconditional jump to stack[-2] 2CD4 5B JUMPDEST 2CD5 60 PUSH1 0xff 2CD7 16 AND 2CD8 90 SWAP1 2CD9 56 *JUMP 2CDA 5B JUMPDEST 2CDB 60 PUSH1 0x00 2CDD 61 PUSH2 0x040f 2CE0 82 DUP3 2CE1 61 PUSH2 0x2cab 2CE4 56 *JUMP label_2CE5: // Incoming call from 0x1DAD, returns to 0x1DAE // Inputs[5] // { // @2CE6 stack[-3] // @2CE7 stack[-1] // @2CE8 stack[-2] // @2CE9 msg.data[stack[-1]:stack[-1] + stack[-3]] // @2CF0 stack[-4] // } 2CE5 5B JUMPDEST 2CE6 82 DUP3 2CE7 81 DUP2 2CE8 83 DUP4 2CE9 37 CALLDATACOPY 2CEA 50 POP 2CEB 60 PUSH1 0x00 2CED 91 SWAP2 2CEE 01 ADD 2CEF 52 MSTORE 2CF0 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2CE9 memory[stack[-2]:stack[-2] + stack[-3]] = msg.data[stack[-1]:stack[-1] + stack[-3]] // @2CEF memory[stack[-3] + stack[-2]:stack[-3] + stack[-2] + 0x20] = 0x00 // } // Block ends with unconditional jump to stack[-4] label_2CF1: // Incoming call from 0x23DC, returns to 0x23DD // Inputs[1] { @2CF5 stack[-3] } 2CF1 5B JUMPDEST 2CF2 60 PUSH1 0x00 2CF4 5B JUMPDEST 2CF5 83 DUP4 2CF6 81 DUP2 2CF7 10 LT 2CF8 15 ISZERO 2CF9 61 PUSH2 0x2d0c 2CFC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2CF2 stack[0] = 0x00 } // Block ends with conditional jump to 0x2d0c, if !(0x00 < stack[-3]) label_2CFD: // Incoming jump from 0x2CFC, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x2CFC, if not !(0x00 < stack[-3]) // Inputs[4] // { // @2CFD stack[-2] // @2CFE stack[-1] // @2D00 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2D01 stack[-3] // } 2CFD 81 DUP2 2CFE 81 DUP2 2CFF 01 ADD 2D00 51 MLOAD 2D01 83 DUP4 2D02 82 DUP3 2D03 01 ADD 2D04 52 MSTORE 2D05 60 PUSH1 0x20 2D07 01 ADD 2D08 61 PUSH2 0x2cf4 2D0B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2D04 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2D07 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2cf4 label_2D0C: // Incoming jump from 0x2CFC, if !(stack[-1] < stack[-4]) // Incoming jump from 0x2CFC, if !(0x00 < stack[-3]) // Inputs[2] // { // @2D0D stack[-4] // @2D0E stack[-1] // } 2D0C 5B JUMPDEST 2D0D 83 DUP4 2D0E 81 DUP2 2D0F 11 GT 2D10 15 ISZERO 2D11 61 PUSH2 0x2d1b 2D14 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2d1b, if !(stack[-1] > stack[-4]) label_2D15: // Incoming jump from 0x2D14, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @2D17 stack[-4] // @2D18 stack[-3] // @2D20 stack[-5] // } 2D15 60 PUSH1 0x00 2D17 84 DUP5 2D18 84 DUP5 2D19 01 ADD 2D1A 52 MSTORE 2D1B 5B JUMPDEST 2D1C 50 POP 2D1D 50 POP 2D1E 50 POP 2D1F 50 POP 2D20 56 *JUMP // Stack delta = -5 // Outputs[1] { @2D1A memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] 2D21 5B JUMPDEST 2D22 60 PUSH1 0x00 2D24 61 PUSH2 0x040f 2D27 82 DUP3 2D28 60 PUSH1 0x00 2D2A 61 PUSH2 0x040f 2D2D 82 DUP3 2D2E 61 PUSH2 0x2d3c 2D31 56 *JUMP label_2D32: // Incoming call from 0x23E5, returns to 0x23E6 // Inputs[2] // { // @2D35 stack[-1] // @2D3A stack[-2] // } 2D32 5B JUMPDEST 2D33 60 PUSH1 0x1f 2D35 01 ADD 2D36 60 PUSH1 0x1f 2D38 19 NOT 2D39 16 AND 2D3A 90 SWAP1 2D3B 56 *JUMP // Stack delta = -1 // Outputs[1] { @2D3A stack[-2] = ~0x1f & 0x1f + stack[-1] } // Block ends with unconditional jump to stack[-2] 2D3C 5B JUMPDEST 2D3D 60 PUSH1 0x60 2D3F 1B SHL 2D40 90 SWAP1 2D41 56 *JUMP label_2D42: // Incoming jump from 0x1C31 // Inputs[1] { @2D46 stack[-1] } 2D42 5B JUMPDEST 2D43 61 PUSH2 0x2d4b 2D46 81 DUP2 2D47 61 PUSH2 0x2cab 2D4A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2D43 stack[0] = 0x2d4b // @2D46 stack[1] = stack[-1] // } // Block ends with call to 0x2cab, returns to 0x2D4B label_2D4B: // Incoming return from call to 0x0A9A at 0x2D67 // Incoming return from call to 0x2CAB at 0x2D4A // Incoming return from call to 0x2CBB at 0x2D70 // Inputs[2] // { // @2D4C stack[-2] // @2D4D stack[-1] // } 2D4B 5B JUMPDEST 2D4C 81 DUP2 2D4D 14 EQ 2D4E 61 PUSH2 0x04f8 2D51 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x04f8, if stack[-2] == stack[-1] label_2D52: // Incoming jump from 0x2D51, if not stack[-2] == stack[-1] // Inputs[1] { @2D55 memory[0x00:0x00] } 2D52 60 PUSH1 0x00 2D54 80 DUP1 2D55 FD *REVERT // Stack delta = +0 // Outputs[1] { @2D55 revert(memory[0x00:0x00]); } // Block terminates 2D56 5B JUMPDEST 2D57 61 PUSH2 0x2d4b 2D5A 81 DUP2 2D5B 61 PUSH2 0x2cb6 2D5E 56 *JUMP label_2D5F: // Incoming call from 0x1D10, returns to 0x040F // Inputs[1] { @2D63 stack[-1] } 2D5F 5B JUMPDEST 2D60 61 PUSH2 0x2d4b 2D63 81 DUP2 2D64 61 PUSH2 0x0a9a 2D67 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2D60 stack[0] = 0x2d4b // @2D63 stack[1] = stack[-1] // } // Block ends with call to 0x0a9a, returns to 0x2D4B label_2D68: // Incoming call from 0x1D1B, returns to 0x040F // Inputs[1] { @2D6C stack[-1] } 2D68 5B JUMPDEST 2D69 61 PUSH2 0x2d4b 2D6C 81 DUP2 2D6D 61 PUSH2 0x2cbb 2D70 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2D69 stack[0] = 0x2d4b // @2D6C stack[1] = stack[-1] // } // Block ends with call to 0x2cbb, returns to 0x2D4B 2D71 5B JUMPDEST 2D72 61 PUSH2 0x2d4b 2D75 81 DUP2 2D76 61 PUSH2 0x2cd4 2D79 56 *JUMP 2D7A FE *ASSERT 2D7B A3 LOG3 2D7C 65 PUSH6 0x627a7a723158 2D83 20 SHA3 2D84 70 PUSH17 0x63bdda34a1ef9960513e4e549a839c15c1 2D96 17 OR 2D97 D6 D6 2D98 27 27 2D99 10 LT 2D9A A8 A8 2D9B 2A 2A 2D9C 3D RETURNDATASIZE 2D9D E0 E0 2D9E 3D RETURNDATASIZE 2D9F 89 DUP10 2DA0 BD BD 2DA1 2E 2E 2DA2 16 AND 2DA3 CA CA 2DA4 6C PUSH13 0x6578706572696d656e74616cf5 2DB2 64 PUSH5 0x736f6c6343 2DB8 00 *STOP 2DB9 05 SDIV 2DBA 11 GT 2DBB 00 *STOP 2DBC 40 BLOCKHASH