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 0x01d9 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01d9, 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 0x8f32d59b 0026 11 GT 0027 61 PUSH2 0x0104 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0104, if 0x8f32d59b > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x8f32d59b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xbd85b039 0031 11 GT 0032 61 PUSH2 0x00a2 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a2, if 0xbd85b039 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xbd85b039 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xe985e9c5 003C 11 GT 003D 61 PUSH2 0x0071 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xe985e9c5 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xe985e9c5 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xe985e9c5 0047 14 EQ 0048 61 PUSH2 0x10a9 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10a9, if 0xe985e9c5 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xf242432a 0052 14 EQ 0053 61 PUSH2 0x1125 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1125, 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 0x1234 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1234, 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 0xf923e8c3 0068 14 EQ 0069 61 PUSH2 0x1278 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1278, if 0xf923e8c3 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xf923e8c3 == stack[-1] 006D 61 PUSH2 0x01d9 0070 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01d9 label_0071: // Incoming jump from 0x0040, if 0xe985e9c5 > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0xbd85b039 0078 14 EQ 0079 61 PUSH2 0x0fb7 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fb7, if 0xbd85b039 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xbd85b039 == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xc311c523 0083 14 EQ 0084 61 PUSH2 0x0ff9 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ff9, if 0xc311c523 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xc311c523 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xcd7c0326 008E 14 EQ 008F 61 PUSH2 0x101b 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x101b, if 0xcd7c0326 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xcd7c0326 == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xd26ea6c0 0099 14 EQ 009A 61 PUSH2 0x1065 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1065, if 0xd26ea6c0 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xd26ea6c0 == stack[-1] 009E 61 PUSH2 0x01d9 00A1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01d9 label_00A2: // Incoming jump from 0x0035, if 0xbd85b039 > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A2 5B JUMPDEST 00A3 80 DUP1 00A4 63 PUSH4 0x9e037eea 00A9 11 GT 00AA 61 PUSH2 0x00de 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00de, if 0x9e037eea > stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x9e037eea > stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x9e037eea 00B4 14 EQ 00B5 61 PUSH2 0x0cdc 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cdc, if 0x9e037eea == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x9e037eea == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0xa22cb465 00BF 14 EQ 00C0 61 PUSH2 0x0d20 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d20, if 0xa22cb465 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0xa50aa5c3 00CA 14 EQ 00CB 61 PUSH2 0x0d70 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d70, if 0xa50aa5c3 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0xa50aa5c3 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0xb48ab8b6 00D5 14 EQ 00D6 61 PUSH2 0x0db4 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0db4, if 0xb48ab8b6 == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0xb48ab8b6 == stack[-1] 00DA 61 PUSH2 0x01d9 00DD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01d9 label_00DE: // Incoming jump from 0x00AD, if 0x9e037eea > stack[-1] // Inputs[1] { @00DF stack[-1] } 00DE 5B JUMPDEST 00DF 80 DUP1 00E0 63 PUSH4 0x8f32d59b 00E5 14 EQ 00E6 61 PUSH2 0x0be9 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0be9, if 0x8f32d59b == stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x8f32d59b == stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0x91686f53 00F0 14 EQ 00F1 61 PUSH2 0x0c0b 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c0b, if 0x91686f53 == stack[-1] label_00F5: // Incoming jump from 0x00F4, if not 0x91686f53 == stack[-1] // Inputs[1] { @00F5 stack[-1] } 00F5 80 DUP1 00F6 63 PUSH4 0x95d89b41 00FB 14 EQ 00FC 61 PUSH2 0x0c59 00FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c59, if 0x95d89b41 == stack[-1] label_0100: // Incoming jump from 0x00FF, if not 0x95d89b41 == stack[-1] 0100 61 PUSH2 0x01d9 0103 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01d9 label_0104: // Incoming jump from 0x002A, if 0x8f32d59b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0105 stack[-1] } 0104 5B JUMPDEST 0105 80 DUP1 0106 63 PUSH4 0x4e1273f4 010B 11 GT 010C 61 PUSH2 0x017c 010F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x017c, if 0x4e1273f4 > stack[-1] label_0110: // Incoming jump from 0x010F, if not 0x4e1273f4 > stack[-1] // Inputs[1] { @0110 stack[-1] } 0110 80 DUP1 0111 63 PUSH4 0x731133e9 0116 11 GT 0117 61 PUSH2 0x014b 011A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x014b, if 0x731133e9 > stack[-1] label_011B: // Incoming jump from 0x011A, if not 0x731133e9 > stack[-1] // Inputs[1] { @011B stack[-1] } 011B 80 DUP1 011C 63 PUSH4 0x731133e9 0121 14 EQ 0122 61 PUSH2 0x098f 0125 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x098f, if 0x731133e9 == stack[-1] label_0126: // Incoming jump from 0x0125, if not 0x731133e9 == stack[-1] // Inputs[1] { @0126 stack[-1] } 0126 80 DUP1 0127 63 PUSH4 0x73505d35 012C 14 EQ 012D 61 PUSH2 0x0a7e 0130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a7e, if 0x73505d35 == stack[-1] label_0131: // Incoming jump from 0x0130, if not 0x73505d35 == stack[-1] // Inputs[1] { @0131 stack[-1] } 0131 80 DUP1 0132 63 PUSH4 0x862440e2 0137 14 EQ 0138 61 PUSH2 0x0ada 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ada, if 0x862440e2 == stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x862440e2 == stack[-1] // Inputs[1] { @013C stack[-1] } 013C 80 DUP1 013D 63 PUSH4 0x8da5cb5b 0142 14 EQ 0143 61 PUSH2 0x0b9f 0146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b9f, if 0x8da5cb5b == stack[-1] label_0147: // Incoming jump from 0x0146, if not 0x8da5cb5b == stack[-1] 0147 61 PUSH2 0x01d9 014A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01d9 label_014B: // Incoming jump from 0x011A, if 0x731133e9 > stack[-1] // Inputs[1] { @014C stack[-1] } 014B 5B JUMPDEST 014C 80 DUP1 014D 63 PUSH4 0x4e1273f4 0152 14 EQ 0153 61 PUSH2 0x0730 0156 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0730, if 0x4e1273f4 == stack[-1] label_0157: // Incoming jump from 0x0156, if not 0x4e1273f4 == stack[-1] // Inputs[1] { @0157 stack[-1] } 0157 80 DUP1 0158 63 PUSH4 0x4f558e79 015D 14 EQ 015E 61 PUSH2 0x08d1 0161 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08d1, if 0x4f558e79 == stack[-1] label_0162: // Incoming jump from 0x0161, if not 0x4f558e79 == stack[-1] // Inputs[1] { @0162 stack[-1] } 0162 80 DUP1 0163 63 PUSH4 0x510b5158 0168 14 EQ 0169 61 PUSH2 0x0917 016C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0917, if 0x510b5158 == stack[-1] label_016D: // Incoming jump from 0x016C, if not 0x510b5158 == stack[-1] // Inputs[1] { @016D stack[-1] } 016D 80 DUP1 016E 63 PUSH4 0x715018a6 0173 14 EQ 0174 61 PUSH2 0x0985 0177 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0985, if 0x715018a6 == stack[-1] label_0178: // Incoming jump from 0x0177, if not 0x715018a6 == stack[-1] 0178 61 PUSH2 0x01d9 017B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01d9 label_017C: // Incoming jump from 0x010F, if 0x4e1273f4 > stack[-1] // Inputs[1] { @017D stack[-1] } 017C 5B JUMPDEST 017D 80 DUP1 017E 63 PUSH4 0x0e89341c 0183 11 GT 0184 61 PUSH2 0x01b8 0187 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b8, 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 0x0e89341c 018E 14 EQ 018F 61 PUSH2 0x0328 0192 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0328, if 0x0e89341c == stack[-1] label_0193: // Incoming jump from 0x0192, if not 0x0e89341c == stack[-1] // Inputs[1] { @0193 stack[-1] } 0193 80 DUP1 0194 63 PUSH4 0x24d88785 0199 14 EQ 019A 61 PUSH2 0x03cf 019D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03cf, if 0x24d88785 == stack[-1] label_019E: // Incoming jump from 0x019D, if not 0x24d88785 == stack[-1] // Inputs[1] { @019E stack[-1] } 019E 80 DUP1 019F 63 PUSH4 0x2eb2c2d6 01A4 14 EQ 01A5 61 PUSH2 0x048a 01A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048a, if 0x2eb2c2d6 == stack[-1] label_01A9: // Incoming jump from 0x01A8, if not 0x2eb2c2d6 == stack[-1] // Inputs[1] { @01A9 stack[-1] } 01A9 80 DUP1 01AA 63 PUSH4 0x4060b25e 01AF 14 EQ 01B0 61 PUSH2 0x06ad 01B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06ad, if 0x4060b25e == stack[-1] label_01B4: // Incoming jump from 0x01B3, if not 0x4060b25e == stack[-1] 01B4 61 PUSH2 0x01d9 01B7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01d9 label_01B8: // Incoming jump from 0x0187, if 0x0e89341c > stack[-1] // Inputs[1] { @01B9 stack[-1] } 01B8 5B JUMPDEST 01B9 80 DUP1 01BA 62 PUSH3 0xfdd58e 01BE 14 EQ 01BF 61 PUSH2 0x01de 01C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01de, if 0xfdd58e == stack[-1] label_01C3: // Incoming jump from 0x01C2, if not 0xfdd58e == stack[-1] // Inputs[1] { @01C3 stack[-1] } 01C3 80 DUP1 01C4 63 PUSH4 0x01ffc9a7 01C9 14 EQ 01CA 61 PUSH2 0x0240 01CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0240, if 0x01ffc9a7 == stack[-1] label_01CE: // Incoming jump from 0x01CD, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01CE stack[-1] } 01CE 80 DUP1 01CF 63 PUSH4 0x06fdde03 01D4 14 EQ 01D5 61 PUSH2 0x02a5 01D8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a5, if 0x06fdde03 == stack[-1] label_01D9: // Incoming jump from 0x01D8, if not 0x06fdde03 == stack[-1] // Incoming jump from 0x01B7 // Incoming jump from 0x0103 // Incoming jump from 0x0070 // Incoming jump from 0x014A // Incoming jump from 0x00DD // Incoming jump from 0x00A1 // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x017B // Inputs[1] { @01DD memory[0x00:0x00] } 01D9 5B JUMPDEST 01DA 60 PUSH1 0x00 01DC 80 DUP1 01DD FD *REVERT // Stack delta = +0 // Outputs[1] { @01DD revert(memory[0x00:0x00]); } // Block terminates label_01DE: // Incoming jump from 0x01C2, if 0xfdd58e == stack[-1] // Inputs[1] { @01E5 msg.data.length } 01DE 5B JUMPDEST 01DF 61 PUSH2 0x022a 01E2 60 PUSH1 0x04 01E4 80 DUP1 01E5 36 CALLDATASIZE 01E6 03 SUB 01E7 60 PUSH1 0x40 01E9 81 DUP2 01EA 10 LT 01EB 15 ISZERO 01EC 61 PUSH2 0x01f4 01EF 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @01DF stack[0] = 0x022a // @01E2 stack[1] = 0x04 // @01E6 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x01f4, returns to 0x022A, if !(msg.data.length - 0x04 < 0x40) label_01F0: // Incoming jump from 0x01EF, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @01F3 memory[0x00:0x00] } 01F0 60 PUSH1 0x00 01F2 80 DUP1 01F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F3 revert(memory[0x00:0x00]); } // Block terminates label_01F4: // Incoming call from 0x01EF, returns to 0x022A, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @01F5 stack[-2] // @01F6 stack[-1] // @01FA msg.data[stack[-2]:stack[-2] + 0x20] // @021A msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 01F4 5B JUMPDEST 01F5 81 DUP2 01F6 01 ADD 01F7 90 SWAP1 01F8 80 DUP1 01F9 80 DUP1 01FA 35 CALLDATALOAD 01FB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0210 16 AND 0211 90 SWAP1 0212 60 PUSH1 0x20 0214 01 ADD 0215 90 SWAP1 0216 92 SWAP3 0217 91 SWAP2 0218 90 SWAP1 0219 80 DUP1 021A 35 CALLDATALOAD 021B 90 SWAP1 021C 60 PUSH1 0x20 021E 01 ADD 021F 90 SWAP1 0220 92 SWAP3 0221 91 SWAP2 0222 90 SWAP1 0223 50 POP 0224 50 POP 0225 50 POP 0226 61 PUSH2 0x12fb 0229 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0216 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0220 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x12fb label_022A: // Incoming return from call to 0x01F4 at 0x01EF // Inputs[4] // { // @022D memory[0x40:0x60] // @022F stack[-1] // @023A memory[0x40:0x60] // @023F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 022A 5B JUMPDEST 022B 60 PUSH1 0x40 022D 51 MLOAD 022E 80 DUP1 022F 82 DUP3 0230 81 DUP2 0231 52 MSTORE 0232 60 PUSH1 0x20 0234 01 ADD 0235 91 SWAP2 0236 50 POP 0237 50 POP 0238 60 PUSH1 0x40 023A 51 MLOAD 023B 80 DUP1 023C 91 SWAP2 023D 03 SUB 023E 90 SWAP1 023F F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0231 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @023F return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0240: // Incoming jump from 0x01CD, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0247 msg.data.length } 0240 5B JUMPDEST 0241 61 PUSH2 0x028b 0244 60 PUSH1 0x04 0246 80 DUP1 0247 36 CALLDATASIZE 0248 03 SUB 0249 60 PUSH1 0x20 024B 81 DUP2 024C 10 LT 024D 15 ISZERO 024E 61 PUSH2 0x0256 0251 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0241 stack[0] = 0x028b // @0244 stack[1] = 0x04 // @0248 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0256, returns to 0x028B, if !(msg.data.length - 0x04 < 0x20) label_0252: // Incoming jump from 0x0251, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0255 memory[0x00:0x00] } 0252 60 PUSH1 0x00 0254 80 DUP1 0255 FD *REVERT // Stack delta = +0 // Outputs[1] { @0255 revert(memory[0x00:0x00]); } // Block terminates label_0256: // Incoming call from 0x0251, returns to 0x028B, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0257 stack[-2] // @0258 stack[-1] // @025C msg.data[stack[-2]:stack[-2] + 0x20] // } 0256 5B JUMPDEST 0257 81 DUP2 0258 01 ADD 0259 90 SWAP1 025A 80 DUP1 025B 80 DUP1 025C 35 CALLDATALOAD 025D 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 027A 19 NOT 027B 16 AND 027C 90 SWAP1 027D 60 PUSH1 0x20 027F 01 ADD 0280 90 SWAP1 0281 92 SWAP3 0282 91 SWAP2 0283 90 SWAP1 0284 50 POP 0285 50 POP 0286 50 POP 0287 61 PUSH2 0x1343 028A 56 *JUMP // Stack delta = -1 // Outputs[1] { @0281 stack[-2] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1343 label_028B: // Incoming return from call to 0x0256 at 0x0251 // Inputs[4] // { // @028E memory[0x40:0x60] // @0290 stack[-1] // @029F memory[0x40:0x60] // @02A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 028B 5B JUMPDEST 028C 60 PUSH1 0x40 028E 51 MLOAD 028F 80 DUP1 0290 82 DUP3 0291 15 ISZERO 0292 15 ISZERO 0293 15 ISZERO 0294 15 ISZERO 0295 81 DUP2 0296 52 MSTORE 0297 60 PUSH1 0x20 0299 01 ADD 029A 91 SWAP2 029B 50 POP 029C 50 POP 029D 60 PUSH1 0x40 029F 51 MLOAD 02A0 80 DUP1 02A1 91 SWAP2 02A2 03 SUB 02A3 90 SWAP1 02A4 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0296 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @02A4 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02A5: // Incoming jump from 0x01D8, if 0x06fdde03 == stack[-1] 02A5 5B JUMPDEST 02A6 61 PUSH2 0x02ad 02A9 61 PUSH2 0x13f4 02AC 56 *JUMP // Stack delta = +1 // Outputs[1] { @02A6 stack[0] = 0x02ad } // Block ends with call to 0x13f4, returns to 0x02AD label_02AD: // Incoming return from call to 0x13F4 at 0x02AC // Inputs[4] // { // @02B0 memory[0x40:0x60] // @02BB stack[-1] // @02BE memory[stack[-1]:stack[-1] + 0x20] // @02C7 memory[stack[-1]:stack[-1] + 0x20] // } 02AD 5B JUMPDEST 02AE 60 PUSH1 0x40 02B0 51 MLOAD 02B1 80 DUP1 02B2 80 DUP1 02B3 60 PUSH1 0x20 02B5 01 ADD 02B6 82 DUP3 02B7 81 DUP2 02B8 03 SUB 02B9 82 DUP3 02BA 52 MSTORE 02BB 83 DUP4 02BC 81 DUP2 02BD 81 DUP2 02BE 51 MLOAD 02BF 81 DUP2 02C0 52 MSTORE 02C1 60 PUSH1 0x20 02C3 01 ADD 02C4 91 SWAP2 02C5 50 POP 02C6 80 DUP1 02C7 51 MLOAD 02C8 90 SWAP1 02C9 60 PUSH1 0x20 02CB 01 ADD 02CC 90 SWAP1 02CD 80 DUP1 02CE 83 DUP4 02CF 83 DUP4 02D0 60 PUSH1 0x00 02D2 5B JUMPDEST 02D3 83 DUP4 02D4 81 DUP2 02D5 10 LT 02D6 15 ISZERO 02D7 61 PUSH2 0x02ed 02DA 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @02B0 stack[0] = memory[0x40:0x60] // @02B1 stack[1] = memory[0x40:0x60] // @02BA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @02C0 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @02C4 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @02CC stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @02CC stack[3] = 0x20 + stack[-1] // @02CD stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @02CE stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @02CF stack[7] = 0x20 + stack[-1] // @02D0 stack[8] = 0x00 // } // Block ends with conditional jump to 0x02ed, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_02DB: // Incoming jump from 0x02DA, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x02DA, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @02DB stack[-1] // @02DC stack[-2] // @02DE memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @02E0 stack[-3] // } 02DB 80 DUP1 02DC 82 DUP3 02DD 01 ADD 02DE 51 MLOAD 02DF 81 DUP2 02E0 84 DUP5 02E1 01 ADD 02E2 52 MSTORE 02E3 60 PUSH1 0x20 02E5 81 DUP2 02E6 01 ADD 02E7 90 SWAP1 02E8 50 POP 02E9 61 PUSH2 0x02d2 02EC 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02E2 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @02E7 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x02d2 label_02ED: // Incoming jump from 0x02DA, if !(stack[-1] < stack[-4]) // Incoming jump from 0x02DA, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @02F2 stack[-6] // @02F2 stack[-5] // @02F4 stack[-7] // } 02ED 5B JUMPDEST 02EE 50 POP 02EF 50 POP 02F0 50 POP 02F1 50 POP 02F2 90 SWAP1 02F3 50 POP 02F4 90 SWAP1 02F5 81 DUP2 02F6 01 ADD 02F7 90 SWAP1 02F8 60 PUSH1 0x1f 02FA 16 AND 02FB 80 DUP1 02FC 15 ISZERO 02FD 61 PUSH2 0x031a 0300 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @02F7 stack[-7] = stack[-5] + stack[-7] // @02FA stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x031a, if !(0x1f & stack[-5]) label_0301: // Incoming jump from 0x0300, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0301 stack[-1] // @0302 stack[-2] // @0305 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @031C stack[-5] // @0322 memory[0x40:0x60] // @0327 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0301 80 DUP1 0302 82 DUP3 0303 03 SUB 0304 80 DUP1 0305 51 MLOAD 0306 60 PUSH1 0x01 0308 83 DUP4 0309 60 PUSH1 0x20 030B 03 SUB 030C 61 PUSH2 0x0100 030F 0A EXP 0310 03 SUB 0311 19 NOT 0312 16 AND 0313 81 DUP2 0314 52 MSTORE 0315 60 PUSH1 0x20 0317 01 ADD 0318 91 SWAP2 0319 50 POP 031A 5B JUMPDEST 031B 50 POP 031C 92 SWAP3 031D 50 POP 031E 50 POP 031F 50 POP 0320 60 PUSH1 0x40 0322 51 MLOAD 0323 80 DUP1 0324 91 SWAP2 0325 03 SUB 0326 90 SWAP1 0327 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0314 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0327 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0328: // Incoming jump from 0x0192, if 0x0e89341c == stack[-1] // Inputs[1] { @032F msg.data.length } 0328 5B JUMPDEST 0329 61 PUSH2 0x0354 032C 60 PUSH1 0x04 032E 80 DUP1 032F 36 CALLDATASIZE 0330 03 SUB 0331 60 PUSH1 0x20 0333 81 DUP2 0334 10 LT 0335 15 ISZERO 0336 61 PUSH2 0x033e 0339 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0329 stack[0] = 0x0354 // @032C stack[1] = 0x04 // @0330 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x033e, returns to 0x0354, if !(msg.data.length - 0x04 < 0x20) label_033A: // Incoming jump from 0x0339, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @033D memory[0x00:0x00] } 033A 60 PUSH1 0x00 033C 80 DUP1 033D FD *REVERT // Stack delta = +0 // Outputs[1] { @033D revert(memory[0x00:0x00]); } // Block terminates label_033E: // Incoming call from 0x0339, returns to 0x0354, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @033F stack[-2] // @0340 stack[-1] // @0344 msg.data[stack[-2]:stack[-2] + 0x20] // } 033E 5B JUMPDEST 033F 81 DUP2 0340 01 ADD 0341 90 SWAP1 0342 80 DUP1 0343 80 DUP1 0344 35 CALLDATALOAD 0345 90 SWAP1 0346 60 PUSH1 0x20 0348 01 ADD 0349 90 SWAP1 034A 92 SWAP3 034B 91 SWAP2 034C 90 SWAP1 034D 50 POP 034E 50 POP 034F 50 POP 0350 61 PUSH2 0x1492 0353 56 *JUMP // Stack delta = -1 // Outputs[1] { @034A stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1492 label_0354: // Incoming return from call to 0x033E at 0x0339 // Inputs[4] // { // @0357 memory[0x40:0x60] // @0362 stack[-1] // @0365 memory[stack[-1]:stack[-1] + 0x20] // @036E memory[stack[-1]:stack[-1] + 0x20] // } 0354 5B JUMPDEST 0355 60 PUSH1 0x40 0357 51 MLOAD 0358 80 DUP1 0359 80 DUP1 035A 60 PUSH1 0x20 035C 01 ADD 035D 82 DUP3 035E 81 DUP2 035F 03 SUB 0360 82 DUP3 0361 52 MSTORE 0362 83 DUP4 0363 81 DUP2 0364 81 DUP2 0365 51 MLOAD 0366 81 DUP2 0367 52 MSTORE 0368 60 PUSH1 0x20 036A 01 ADD 036B 91 SWAP2 036C 50 POP 036D 80 DUP1 036E 51 MLOAD 036F 90 SWAP1 0370 60 PUSH1 0x20 0372 01 ADD 0373 90 SWAP1 0374 80 DUP1 0375 83 DUP4 0376 83 DUP4 0377 60 PUSH1 0x00 0379 5B JUMPDEST 037A 83 DUP4 037B 81 DUP2 037C 10 LT 037D 15 ISZERO 037E 61 PUSH2 0x0394 0381 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0357 stack[0] = memory[0x40:0x60] // @0358 stack[1] = memory[0x40:0x60] // @0361 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0367 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @036B stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0373 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0373 stack[3] = 0x20 + stack[-1] // @0374 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0375 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0376 stack[7] = 0x20 + stack[-1] // @0377 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0394, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0382: // Incoming jump from 0x0381, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0381, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0382 stack[-1] // @0383 stack[-2] // @0385 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0387 stack[-3] // } 0382 80 DUP1 0383 82 DUP3 0384 01 ADD 0385 51 MLOAD 0386 81 DUP2 0387 84 DUP5 0388 01 ADD 0389 52 MSTORE 038A 60 PUSH1 0x20 038C 81 DUP2 038D 01 ADD 038E 90 SWAP1 038F 50 POP 0390 61 PUSH2 0x0379 0393 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0389 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @038E stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0379 label_0394: // Incoming jump from 0x0381, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0381, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0399 stack[-6] // @0399 stack[-5] // @039B stack[-7] // } 0394 5B JUMPDEST 0395 50 POP 0396 50 POP 0397 50 POP 0398 50 POP 0399 90 SWAP1 039A 50 POP 039B 90 SWAP1 039C 81 DUP2 039D 01 ADD 039E 90 SWAP1 039F 60 PUSH1 0x1f 03A1 16 AND 03A2 80 DUP1 03A3 15 ISZERO 03A4 61 PUSH2 0x03c1 03A7 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @039E stack[-7] = stack[-5] + stack[-7] // @03A1 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x03c1, if !(0x1f & stack[-5]) label_03A8: // Incoming jump from 0x03A7, if not !(0x1f & stack[-5]) // Inputs[6] // { // @03A8 stack[-1] // @03A9 stack[-2] // @03AC memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @03C3 stack[-5] // @03C9 memory[0x40:0x60] // @03CE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 03A8 80 DUP1 03A9 82 DUP3 03AA 03 SUB 03AB 80 DUP1 03AC 51 MLOAD 03AD 60 PUSH1 0x01 03AF 83 DUP4 03B0 60 PUSH1 0x20 03B2 03 SUB 03B3 61 PUSH2 0x0100 03B6 0A EXP 03B7 03 SUB 03B8 19 NOT 03B9 16 AND 03BA 81 DUP2 03BB 52 MSTORE 03BC 60 PUSH1 0x20 03BE 01 ADD 03BF 91 SWAP2 03C0 50 POP 03C1 5B JUMPDEST 03C2 50 POP 03C3 92 SWAP3 03C4 50 POP 03C5 50 POP 03C6 50 POP 03C7 60 PUSH1 0x40 03C9 51 MLOAD 03CA 80 DUP1 03CB 91 SWAP2 03CC 03 SUB 03CD 90 SWAP1 03CE F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @03BB memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @03CE return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_03CF: // Incoming jump from 0x019D, if 0x24d88785 == stack[-1] // Inputs[1] { @03D6 msg.data.length } 03CF 5B JUMPDEST 03D0 61 PUSH2 0x0488 03D3 60 PUSH1 0x04 03D5 80 DUP1 03D6 36 CALLDATASIZE 03D7 03 SUB 03D8 60 PUSH1 0x20 03DA 81 DUP2 03DB 10 LT 03DC 15 ISZERO 03DD 61 PUSH2 0x03e5 03E0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @03D0 stack[0] = 0x0488 // @03D3 stack[1] = 0x04 // @03D7 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03e5, returns to 0x0488, if !(msg.data.length - 0x04 < 0x20) label_03E1: // Incoming jump from 0x03E0, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @03E4 memory[0x00:0x00] } 03E1 60 PUSH1 0x00 03E3 80 DUP1 03E4 FD *REVERT // Stack delta = +0 // Outputs[1] { @03E4 revert(memory[0x00:0x00]); } // Block terminates label_03E5: // Incoming call from 0x03E0, returns to 0x0488, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @03E6 stack[-2] // @03E7 stack[-1] // @03EB msg.data[stack[-2]:stack[-2] + 0x20] // } 03E5 5B JUMPDEST 03E6 81 DUP2 03E7 01 ADD 03E8 90 SWAP1 03E9 80 DUP1 03EA 80 DUP1 03EB 35 CALLDATALOAD 03EC 90 SWAP1 03ED 60 PUSH1 0x20 03EF 01 ADD 03F0 90 SWAP1 03F1 64 PUSH5 0x0100000000 03F7 81 DUP2 03F8 11 GT 03F9 15 ISZERO 03FA 61 PUSH2 0x0402 03FD 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @03E8 stack[-1] = stack[-2] // @03E8 stack[-2] = stack[-2] + stack[-1] // @03F0 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // @03F0 stack[0] = 0x20 + stack[-2] // } // Block ends with conditional jump to 0x0402, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_03FE: // Incoming jump from 0x03FD, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0401 memory[0x00:0x00] } 03FE 60 PUSH1 0x00 0400 80 DUP1 0401 FD *REVERT // Stack delta = +0 // Outputs[1] { @0401 revert(memory[0x00:0x00]); } // Block terminates label_0402: // Incoming jump from 0x03FD, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @0403 stack[-3] // @0404 stack[-1] // @0405 stack[-4] // } 0402 5B JUMPDEST 0403 82 DUP3 0404 01 ADD 0405 83 DUP4 0406 60 PUSH1 0x20 0408 82 DUP3 0409 01 ADD 040A 11 GT 040B 15 ISZERO 040C 61 PUSH2 0x0414 040F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0404 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0414, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0410: // Incoming jump from 0x040F, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0413 memory[0x00:0x00] } 0410 60 PUSH1 0x00 0412 80 DUP1 0413 FD *REVERT // Stack delta = +0 // Outputs[1] { @0413 revert(memory[0x00:0x00]); } // Block terminates label_0414: // Incoming jump from 0x040F, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0415 stack[-1] // @0416 msg.data[stack[-1]:stack[-1] + 0x20] // @041B stack[-2] // @041C stack[-4] // } 0414 5B JUMPDEST 0415 80 DUP1 0416 35 CALLDATALOAD 0417 90 SWAP1 0418 60 PUSH1 0x20 041A 01 ADD 041B 91 SWAP2 041C 84 DUP5 041D 60 PUSH1 0x01 041F 83 DUP4 0420 02 MUL 0421 84 DUP5 0422 01 ADD 0423 11 GT 0424 64 PUSH5 0x0100000000 042A 83 DUP4 042B 11 GT 042C 17 OR 042D 15 ISZERO 042E 61 PUSH2 0x0436 0431 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0417 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @041B stack[0] = stack[-2] // @041B stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0436, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0432: // Incoming jump from 0x0431, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0435 memory[0x00:0x00] } 0432 60 PUSH1 0x00 0434 80 DUP1 0435 FD *REVERT // Stack delta = +0 // Outputs[1] { @0435 revert(memory[0x00:0x00]); } // Block terminates label_0436: // Incoming jump from 0x0431, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @0437 stack[-1] // @0437 stack[-3] // @0438 stack[-2] // @0449 memory[0x40:0x60] // @0460 msg.data[stack[-3]:stack[-3] + stack[-2]] // @047C stack[-4] // @047D stack[-5] // } 0436 5B JUMPDEST 0437 91 SWAP2 0438 90 SWAP1 0439 80 DUP1 043A 80 DUP1 043B 60 PUSH1 0x1f 043D 01 ADD 043E 60 PUSH1 0x20 0440 80 DUP1 0441 91 SWAP2 0442 04 DIV 0443 02 MUL 0444 60 PUSH1 0x20 0446 01 ADD 0447 60 PUSH1 0x40 0449 51 MLOAD 044A 90 SWAP1 044B 81 DUP2 044C 01 ADD 044D 60 PUSH1 0x40 044F 52 MSTORE 0450 80 DUP1 0451 93 SWAP4 0452 92 SWAP3 0453 91 SWAP2 0454 90 SWAP1 0455 81 DUP2 0456 81 DUP2 0457 52 MSTORE 0458 60 PUSH1 0x20 045A 01 ADD 045B 83 DUP4 045C 83 DUP4 045D 80 DUP1 045E 82 DUP3 045F 84 DUP5 0460 37 CALLDATACOPY 0461 60 PUSH1 0x00 0463 81 DUP2 0464 84 DUP5 0465 01 ADD 0466 52 MSTORE 0467 60 PUSH1 0x1f 0469 19 NOT 046A 60 PUSH1 0x1f 046C 82 DUP3 046D 01 ADD 046E 16 AND 046F 90 SWAP1 0470 50 POP 0471 80 DUP1 0472 83 DUP4 0473 01 ADD 0474 92 SWAP3 0475 50 POP 0476 50 POP 0477 50 POP 0478 50 POP 0479 50 POP 047A 50 POP 047B 50 POP 047C 91 SWAP2 047D 92 SWAP3 047E 91 SWAP2 047F 92 SWAP3 0480 90 SWAP1 0481 50 POP 0482 50 POP 0483 50 POP 0484 61 PUSH2 0x15f9 0487 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @044F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0457 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0460 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0466 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @047F stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x15f9 label_0488: // Incoming return from call to 0x03E5 at 0x03E0 0488 5B JUMPDEST 0489 00 *STOP // Stack delta = +0 // Outputs[1] { @0489 stop(); } // Block terminates label_048A: // Incoming jump from 0x01A8, if 0x2eb2c2d6 == stack[-1] // Inputs[1] { @0491 msg.data.length } 048A 5B JUMPDEST 048B 61 PUSH2 0x06ab 048E 60 PUSH1 0x04 0490 80 DUP1 0491 36 CALLDATASIZE 0492 03 SUB 0493 60 PUSH1 0xa0 0495 81 DUP2 0496 10 LT 0497 15 ISZERO 0498 61 PUSH2 0x04a0 049B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @048B stack[0] = 0x06ab // @048E stack[1] = 0x04 // @0492 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04a0, returns to 0x06AB, if !(msg.data.length - 0x04 < 0xa0) label_049C: // Incoming jump from 0x049B, if not !(msg.data.length - 0x04 < 0xa0) // Inputs[1] { @049F memory[0x00:0x00] } 049C 60 PUSH1 0x00 049E 80 DUP1 049F FD *REVERT // Stack delta = +0 // Outputs[1] { @049F revert(memory[0x00:0x00]); } // Block terminates label_04A0: // Incoming call from 0x049B, returns to 0x06AB, if !(msg.data.length - 0x04 < 0xa0) // Inputs[5] // { // @04A1 stack[-2] // @04A2 stack[-1] // @04A6 msg.data[stack[-2]:stack[-2] + 0x20] // @04C6 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @04E6 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 04A0 5B JUMPDEST 04A1 81 DUP2 04A2 01 ADD 04A3 90 SWAP1 04A4 80 DUP1 04A5 80 DUP1 04A6 35 CALLDATALOAD 04A7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04BC 16 AND 04BD 90 SWAP1 04BE 60 PUSH1 0x20 04C0 01 ADD 04C1 90 SWAP1 04C2 92 SWAP3 04C3 91 SWAP2 04C4 90 SWAP1 04C5 80 DUP1 04C6 35 CALLDATALOAD 04C7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04DC 16 AND 04DD 90 SWAP1 04DE 60 PUSH1 0x20 04E0 01 ADD 04E1 90 SWAP1 04E2 92 SWAP3 04E3 91 SWAP2 04E4 90 SWAP1 04E5 80 DUP1 04E6 35 CALLDATALOAD 04E7 90 SWAP1 04E8 60 PUSH1 0x20 04EA 01 ADD 04EB 90 SWAP1 04EC 64 PUSH5 0x0100000000 04F2 81 DUP2 04F3 11 GT 04F4 15 ISZERO 04F5 61 PUSH2 0x04fd 04F8 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @04C2 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @04E2 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @04E3 stack[0] = stack[-2] + stack[-1] // @04E4 stack[1] = stack[-2] // @04EB stack[3] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // @04EB stack[2] = 0x20 + 0x20 + 0x20 + stack[-2] // } // Block ends with conditional jump to 0x04fd, if !(msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) label_04F9: // Incoming jump from 0x04F8, if not !(msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @04FC memory[0x00:0x00] } 04F9 60 PUSH1 0x00 04FB 80 DUP1 04FC FD *REVERT // Stack delta = +0 // Outputs[1] { @04FC revert(memory[0x00:0x00]); } // Block terminates label_04FD: // Incoming jump from 0x04F8, if !(msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @04FE stack[-3] // @04FF stack[-1] // @0500 stack[-4] // } 04FD 5B JUMPDEST 04FE 82 DUP3 04FF 01 ADD 0500 83 DUP4 0501 60 PUSH1 0x20 0503 82 DUP3 0504 01 ADD 0505 11 GT 0506 15 ISZERO 0507 61 PUSH2 0x050f 050A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @04FF stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x050f, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_050B: // Incoming jump from 0x050A, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @050E memory[0x00:0x00] } 050B 60 PUSH1 0x00 050D 80 DUP1 050E FD *REVERT // Stack delta = +0 // Outputs[1] { @050E revert(memory[0x00:0x00]); } // Block terminates label_050F: // Incoming jump from 0x050A, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0510 stack[-1] // @0511 msg.data[stack[-1]:stack[-1] + 0x20] // @0516 stack[-2] // @0517 stack[-4] // } 050F 5B JUMPDEST 0510 80 DUP1 0511 35 CALLDATALOAD 0512 90 SWAP1 0513 60 PUSH1 0x20 0515 01 ADD 0516 91 SWAP2 0517 84 DUP5 0518 60 PUSH1 0x20 051A 83 DUP4 051B 02 MUL 051C 84 DUP5 051D 01 ADD 051E 11 GT 051F 64 PUSH5 0x0100000000 0525 83 DUP4 0526 11 GT 0527 17 OR 0528 15 ISZERO 0529 61 PUSH2 0x0531 052C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0512 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0516 stack[0] = stack[-2] // @0516 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0531, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_052D: // Incoming jump from 0x052C, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0530 memory[0x00:0x00] } 052D 60 PUSH1 0x00 052F 80 DUP1 0530 FD *REVERT // Stack delta = +0 // Outputs[1] { @0530 revert(memory[0x00:0x00]); } // Block terminates label_0531: // Incoming jump from 0x052C, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @0532 stack[-1] // @0532 stack[-3] // @0533 stack[-2] // @053E memory[0x40:0x60] // @0558 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0574 stack[-4] // @0575 stack[-5] // @057A msg.data[stack[-1]:stack[-1] + 0x20] // } 0531 5B JUMPDEST 0532 91 SWAP2 0533 90 SWAP1 0534 80 DUP1 0535 80 DUP1 0536 60 PUSH1 0x20 0538 02 MUL 0539 60 PUSH1 0x20 053B 01 ADD 053C 60 PUSH1 0x40 053E 51 MLOAD 053F 90 SWAP1 0540 81 DUP2 0541 01 ADD 0542 60 PUSH1 0x40 0544 52 MSTORE 0545 80 DUP1 0546 93 SWAP4 0547 92 SWAP3 0548 91 SWAP2 0549 90 SWAP1 054A 81 DUP2 054B 81 DUP2 054C 52 MSTORE 054D 60 PUSH1 0x20 054F 01 ADD 0550 83 DUP4 0551 83 DUP4 0552 60 PUSH1 0x20 0554 02 MUL 0555 80 DUP1 0556 82 DUP3 0557 84 DUP5 0558 37 CALLDATACOPY 0559 60 PUSH1 0x00 055B 81 DUP2 055C 84 DUP5 055D 01 ADD 055E 52 MSTORE 055F 60 PUSH1 0x1f 0561 19 NOT 0562 60 PUSH1 0x1f 0564 82 DUP3 0565 01 ADD 0566 16 AND 0567 90 SWAP1 0568 50 POP 0569 80 DUP1 056A 83 DUP4 056B 01 ADD 056C 92 SWAP3 056D 50 POP 056E 50 POP 056F 50 POP 0570 50 POP 0571 50 POP 0572 50 POP 0573 50 POP 0574 91 SWAP2 0575 92 SWAP3 0576 91 SWAP2 0577 92 SWAP3 0578 90 SWAP1 0579 80 DUP1 057A 35 CALLDATALOAD 057B 90 SWAP1 057C 60 PUSH1 0x20 057E 01 ADD 057F 90 SWAP1 0580 64 PUSH5 0x0100000000 0586 81 DUP2 0587 11 GT 0588 15 ISZERO 0589 61 PUSH2 0x0591 058C 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0544 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @054C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0558 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @055E memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @0576 stack[-4] = stack[-5] // @0577 stack[-5] = memory[0x40:0x60] // @0578 stack[-3] = stack[-4] // @057F stack[-2] = 0x20 + stack[-1] // @057F stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0591, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_058D: // Incoming jump from 0x058C, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @0590 memory[0x00:0x00] } 058D 60 PUSH1 0x00 058F 80 DUP1 0590 FD *REVERT // Stack delta = +0 // Outputs[1] { @0590 revert(memory[0x00:0x00]); } // Block terminates label_0591: // Incoming jump from 0x058C, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @0592 stack[-3] // @0593 stack[-1] // @0594 stack[-4] // } 0591 5B JUMPDEST 0592 82 DUP3 0593 01 ADD 0594 83 DUP4 0595 60 PUSH1 0x20 0597 82 DUP3 0598 01 ADD 0599 11 GT 059A 15 ISZERO 059B 61 PUSH2 0x05a3 059E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0593 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x05a3, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_059F: // Incoming jump from 0x059E, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @05A2 memory[0x00:0x00] } 059F 60 PUSH1 0x00 05A1 80 DUP1 05A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @05A2 revert(memory[0x00:0x00]); } // Block terminates label_05A3: // Incoming jump from 0x059E, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @05A4 stack[-1] // @05A5 msg.data[stack[-1]:stack[-1] + 0x20] // @05AA stack[-2] // @05AB stack[-4] // } 05A3 5B JUMPDEST 05A4 80 DUP1 05A5 35 CALLDATALOAD 05A6 90 SWAP1 05A7 60 PUSH1 0x20 05A9 01 ADD 05AA 91 SWAP2 05AB 84 DUP5 05AC 60 PUSH1 0x20 05AE 83 DUP4 05AF 02 MUL 05B0 84 DUP5 05B1 01 ADD 05B2 11 GT 05B3 64 PUSH5 0x0100000000 05B9 83 DUP4 05BA 11 GT 05BB 17 OR 05BC 15 ISZERO 05BD 61 PUSH2 0x05c5 05C0 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @05A6 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @05AA stack[0] = stack[-2] // @05AA stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x05c5, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_05C1: // Incoming jump from 0x05C0, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @05C4 memory[0x00:0x00] } 05C1 60 PUSH1 0x00 05C3 80 DUP1 05C4 FD *REVERT // Stack delta = +0 // Outputs[1] { @05C4 revert(memory[0x00:0x00]); } // Block terminates label_05C5: // Incoming jump from 0x05C0, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @05C6 stack[-1] // @05C6 stack[-3] // @05C7 stack[-2] // @05D2 memory[0x40:0x60] // @05EC msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0608 stack[-4] // @0609 stack[-5] // @060E msg.data[stack[-1]:stack[-1] + 0x20] // } 05C5 5B JUMPDEST 05C6 91 SWAP2 05C7 90 SWAP1 05C8 80 DUP1 05C9 80 DUP1 05CA 60 PUSH1 0x20 05CC 02 MUL 05CD 60 PUSH1 0x20 05CF 01 ADD 05D0 60 PUSH1 0x40 05D2 51 MLOAD 05D3 90 SWAP1 05D4 81 DUP2 05D5 01 ADD 05D6 60 PUSH1 0x40 05D8 52 MSTORE 05D9 80 DUP1 05DA 93 SWAP4 05DB 92 SWAP3 05DC 91 SWAP2 05DD 90 SWAP1 05DE 81 DUP2 05DF 81 DUP2 05E0 52 MSTORE 05E1 60 PUSH1 0x20 05E3 01 ADD 05E4 83 DUP4 05E5 83 DUP4 05E6 60 PUSH1 0x20 05E8 02 MUL 05E9 80 DUP1 05EA 82 DUP3 05EB 84 DUP5 05EC 37 CALLDATACOPY 05ED 60 PUSH1 0x00 05EF 81 DUP2 05F0 84 DUP5 05F1 01 ADD 05F2 52 MSTORE 05F3 60 PUSH1 0x1f 05F5 19 NOT 05F6 60 PUSH1 0x1f 05F8 82 DUP3 05F9 01 ADD 05FA 16 AND 05FB 90 SWAP1 05FC 50 POP 05FD 80 DUP1 05FE 83 DUP4 05FF 01 ADD 0600 92 SWAP3 0601 50 POP 0602 50 POP 0603 50 POP 0604 50 POP 0605 50 POP 0606 50 POP 0607 50 POP 0608 91 SWAP2 0609 92 SWAP3 060A 91 SWAP2 060B 92 SWAP3 060C 90 SWAP1 060D 80 DUP1 060E 35 CALLDATALOAD 060F 90 SWAP1 0610 60 PUSH1 0x20 0612 01 ADD 0613 90 SWAP1 0614 64 PUSH5 0x0100000000 061A 81 DUP2 061B 11 GT 061C 15 ISZERO 061D 61 PUSH2 0x0625 0620 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @05D8 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @05E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @05EC memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @05F2 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @060A stack[-4] = stack[-5] // @060B stack[-5] = memory[0x40:0x60] // @060C stack[-3] = stack[-4] // @0613 stack[-2] = 0x20 + stack[-1] // @0613 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0625, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_0621: // Incoming jump from 0x0620, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @0624 memory[0x00:0x00] } 0621 60 PUSH1 0x00 0623 80 DUP1 0624 FD *REVERT // Stack delta = +0 // Outputs[1] { @0624 revert(memory[0x00:0x00]); } // Block terminates label_0625: // Incoming jump from 0x0620, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @0626 stack[-3] // @0627 stack[-1] // @0628 stack[-4] // } 0625 5B JUMPDEST 0626 82 DUP3 0627 01 ADD 0628 83 DUP4 0629 60 PUSH1 0x20 062B 82 DUP3 062C 01 ADD 062D 11 GT 062E 15 ISZERO 062F 61 PUSH2 0x0637 0632 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0627 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0637, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0633: // Incoming jump from 0x0632, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0636 memory[0x00:0x00] } 0633 60 PUSH1 0x00 0635 80 DUP1 0636 FD *REVERT // Stack delta = +0 // Outputs[1] { @0636 revert(memory[0x00:0x00]); } // Block terminates label_0637: // Incoming jump from 0x0632, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0638 stack[-1] // @0639 msg.data[stack[-1]:stack[-1] + 0x20] // @063E stack[-2] // @063F stack[-4] // } 0637 5B JUMPDEST 0638 80 DUP1 0639 35 CALLDATALOAD 063A 90 SWAP1 063B 60 PUSH1 0x20 063D 01 ADD 063E 91 SWAP2 063F 84 DUP5 0640 60 PUSH1 0x01 0642 83 DUP4 0643 02 MUL 0644 84 DUP5 0645 01 ADD 0646 11 GT 0647 64 PUSH5 0x0100000000 064D 83 DUP4 064E 11 GT 064F 17 OR 0650 15 ISZERO 0651 61 PUSH2 0x0659 0654 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @063A stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @063E stack[0] = stack[-2] // @063E stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0659, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0655: // Incoming jump from 0x0654, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0658 memory[0x00:0x00] } 0655 60 PUSH1 0x00 0657 80 DUP1 0658 FD *REVERT // Stack delta = +0 // Outputs[1] { @0658 revert(memory[0x00:0x00]); } // Block terminates label_0659: // Incoming jump from 0x0654, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @065A stack[-3] // @065A stack[-1] // @065B stack[-2] // @066C memory[0x40:0x60] // @0683 msg.data[stack[-3]:stack[-3] + stack[-2]] // @069F stack[-4] // @06A0 stack[-5] // } 0659 5B JUMPDEST 065A 91 SWAP2 065B 90 SWAP1 065C 80 DUP1 065D 80 DUP1 065E 60 PUSH1 0x1f 0660 01 ADD 0661 60 PUSH1 0x20 0663 80 DUP1 0664 91 SWAP2 0665 04 DIV 0666 02 MUL 0667 60 PUSH1 0x20 0669 01 ADD 066A 60 PUSH1 0x40 066C 51 MLOAD 066D 90 SWAP1 066E 81 DUP2 066F 01 ADD 0670 60 PUSH1 0x40 0672 52 MSTORE 0673 80 DUP1 0674 93 SWAP4 0675 92 SWAP3 0676 91 SWAP2 0677 90 SWAP1 0678 81 DUP2 0679 81 DUP2 067A 52 MSTORE 067B 60 PUSH1 0x20 067D 01 ADD 067E 83 DUP4 067F 83 DUP4 0680 80 DUP1 0681 82 DUP3 0682 84 DUP5 0683 37 CALLDATACOPY 0684 60 PUSH1 0x00 0686 81 DUP2 0687 84 DUP5 0688 01 ADD 0689 52 MSTORE 068A 60 PUSH1 0x1f 068C 19 NOT 068D 60 PUSH1 0x1f 068F 82 DUP3 0690 01 ADD 0691 16 AND 0692 90 SWAP1 0693 50 POP 0694 80 DUP1 0695 83 DUP4 0696 01 ADD 0697 92 SWAP3 0698 50 POP 0699 50 POP 069A 50 POP 069B 50 POP 069C 50 POP 069D 50 POP 069E 50 POP 069F 91 SWAP2 06A0 92 SWAP3 06A1 91 SWAP2 06A2 92 SWAP3 06A3 90 SWAP1 06A4 50 POP 06A5 50 POP 06A6 50 POP 06A7 61 PUSH2 0x1678 06AA 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0672 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @067A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0683 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0689 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @06A2 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1678 label_06AB: // Incoming return from call to 0x04A0 at 0x049B 06AB 5B JUMPDEST 06AC 00 *STOP // Stack delta = +0 // Outputs[1] { @06AC stop(); } // Block terminates label_06AD: // Incoming jump from 0x01B3, if 0x4060b25e == stack[-1] 06AD 5B JUMPDEST 06AE 61 PUSH2 0x06b5 06B1 61 PUSH2 0x17b4 06B4 56 *JUMP // Stack delta = +1 // Outputs[1] { @06AE stack[0] = 0x06b5 } // Block ends with call to 0x17b4, returns to 0x06B5 label_06B5: // Incoming return from call to 0x17B4 at 0x06B4 // Inputs[4] // { // @06B8 memory[0x40:0x60] // @06C3 stack[-1] // @06C6 memory[stack[-1]:stack[-1] + 0x20] // @06CF memory[stack[-1]:stack[-1] + 0x20] // } 06B5 5B JUMPDEST 06B6 60 PUSH1 0x40 06B8 51 MLOAD 06B9 80 DUP1 06BA 80 DUP1 06BB 60 PUSH1 0x20 06BD 01 ADD 06BE 82 DUP3 06BF 81 DUP2 06C0 03 SUB 06C1 82 DUP3 06C2 52 MSTORE 06C3 83 DUP4 06C4 81 DUP2 06C5 81 DUP2 06C6 51 MLOAD 06C7 81 DUP2 06C8 52 MSTORE 06C9 60 PUSH1 0x20 06CB 01 ADD 06CC 91 SWAP2 06CD 50 POP 06CE 80 DUP1 06CF 51 MLOAD 06D0 90 SWAP1 06D1 60 PUSH1 0x20 06D3 01 ADD 06D4 90 SWAP1 06D5 80 DUP1 06D6 83 DUP4 06D7 83 DUP4 06D8 60 PUSH1 0x00 06DA 5B JUMPDEST 06DB 83 DUP4 06DC 81 DUP2 06DD 10 LT 06DE 15 ISZERO 06DF 61 PUSH2 0x06f5 06E2 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @06B8 stack[0] = memory[0x40:0x60] // @06B9 stack[1] = memory[0x40:0x60] // @06C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @06C8 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @06CC stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @06D4 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @06D4 stack[3] = 0x20 + stack[-1] // @06D5 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @06D6 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @06D7 stack[7] = 0x20 + stack[-1] // @06D8 stack[8] = 0x00 // } // Block ends with conditional jump to 0x06f5, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_06E3: // Incoming jump from 0x06E2, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x06E2, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @06E3 stack[-1] // @06E4 stack[-2] // @06E6 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @06E8 stack[-3] // } 06E3 80 DUP1 06E4 82 DUP3 06E5 01 ADD 06E6 51 MLOAD 06E7 81 DUP2 06E8 84 DUP5 06E9 01 ADD 06EA 52 MSTORE 06EB 60 PUSH1 0x20 06ED 81 DUP2 06EE 01 ADD 06EF 90 SWAP1 06F0 50 POP 06F1 61 PUSH2 0x06da 06F4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @06EA memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @06EF stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x06da label_06F5: // Incoming jump from 0x06E2, if !(stack[-1] < stack[-4]) // Incoming jump from 0x06E2, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @06FA stack[-5] // @06FA stack[-6] // @06FC stack[-7] // } 06F5 5B JUMPDEST 06F6 50 POP 06F7 50 POP 06F8 50 POP 06F9 50 POP 06FA 90 SWAP1 06FB 50 POP 06FC 90 SWAP1 06FD 81 DUP2 06FE 01 ADD 06FF 90 SWAP1 0700 60 PUSH1 0x1f 0702 16 AND 0703 80 DUP1 0704 15 ISZERO 0705 61 PUSH2 0x0722 0708 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @06FF stack[-7] = stack[-5] + stack[-7] // @0702 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0722, if !(0x1f & stack[-5]) label_0709: // Incoming jump from 0x0708, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0709 stack[-1] // @070A stack[-2] // @070D memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0724 stack[-5] // @072A memory[0x40:0x60] // @072F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0709 80 DUP1 070A 82 DUP3 070B 03 SUB 070C 80 DUP1 070D 51 MLOAD 070E 60 PUSH1 0x01 0710 83 DUP4 0711 60 PUSH1 0x20 0713 03 SUB 0714 61 PUSH2 0x0100 0717 0A EXP 0718 03 SUB 0719 19 NOT 071A 16 AND 071B 81 DUP2 071C 52 MSTORE 071D 60 PUSH1 0x20 071F 01 ADD 0720 91 SWAP2 0721 50 POP 0722 5B JUMPDEST 0723 50 POP 0724 92 SWAP3 0725 50 POP 0726 50 POP 0727 50 POP 0728 60 PUSH1 0x40 072A 51 MLOAD 072B 80 DUP1 072C 91 SWAP2 072D 03 SUB 072E 90 SWAP1 072F F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @071C memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @072F return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0730: // Incoming jump from 0x0156, if 0x4e1273f4 == stack[-1] // Inputs[1] { @0737 msg.data.length } 0730 5B JUMPDEST 0731 61 PUSH2 0x087a 0734 60 PUSH1 0x04 0736 80 DUP1 0737 36 CALLDATASIZE 0738 03 SUB 0739 60 PUSH1 0x40 073B 81 DUP2 073C 10 LT 073D 15 ISZERO 073E 61 PUSH2 0x0746 0741 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0731 stack[0] = 0x087a // @0734 stack[1] = 0x04 // @0738 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0746, returns to 0x087A, if !(msg.data.length - 0x04 < 0x40) label_0742: // Incoming jump from 0x0741, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0745 memory[0x00:0x00] } 0742 60 PUSH1 0x00 0744 80 DUP1 0745 FD *REVERT // Stack delta = +0 // Outputs[1] { @0745 revert(memory[0x00:0x00]); } // Block terminates label_0746: // Incoming call from 0x0741, returns to 0x087A, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0747 stack[-2] // @0748 stack[-1] // @074C msg.data[stack[-2]:stack[-2] + 0x20] // } 0746 5B JUMPDEST 0747 81 DUP2 0748 01 ADD 0749 90 SWAP1 074A 80 DUP1 074B 80 DUP1 074C 35 CALLDATALOAD 074D 90 SWAP1 074E 60 PUSH1 0x20 0750 01 ADD 0751 90 SWAP1 0752 64 PUSH5 0x0100000000 0758 81 DUP2 0759 11 GT 075A 15 ISZERO 075B 61 PUSH2 0x0763 075E 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0749 stack[-1] = stack[-2] // @0749 stack[-2] = stack[-2] + stack[-1] // @0751 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // @0751 stack[0] = 0x20 + stack[-2] // } // Block ends with conditional jump to 0x0763, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_075F: // Incoming jump from 0x075E, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0762 memory[0x00:0x00] } 075F 60 PUSH1 0x00 0761 80 DUP1 0762 FD *REVERT // Stack delta = +0 // Outputs[1] { @0762 revert(memory[0x00:0x00]); } // Block terminates label_0763: // Incoming jump from 0x075E, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @0764 stack[-3] // @0765 stack[-1] // @0766 stack[-4] // } 0763 5B JUMPDEST 0764 82 DUP3 0765 01 ADD 0766 83 DUP4 0767 60 PUSH1 0x20 0769 82 DUP3 076A 01 ADD 076B 11 GT 076C 15 ISZERO 076D 61 PUSH2 0x0775 0770 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0765 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0775, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0771: // Incoming jump from 0x0770, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0774 memory[0x00:0x00] } 0771 60 PUSH1 0x00 0773 80 DUP1 0774 FD *REVERT // Stack delta = +0 // Outputs[1] { @0774 revert(memory[0x00:0x00]); } // Block terminates label_0775: // Incoming jump from 0x0770, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0776 stack[-1] // @0777 msg.data[stack[-1]:stack[-1] + 0x20] // @077C stack[-2] // @077D stack[-4] // } 0775 5B JUMPDEST 0776 80 DUP1 0777 35 CALLDATALOAD 0778 90 SWAP1 0779 60 PUSH1 0x20 077B 01 ADD 077C 91 SWAP2 077D 84 DUP5 077E 60 PUSH1 0x20 0780 83 DUP4 0781 02 MUL 0782 84 DUP5 0783 01 ADD 0784 11 GT 0785 64 PUSH5 0x0100000000 078B 83 DUP4 078C 11 GT 078D 17 OR 078E 15 ISZERO 078F 61 PUSH2 0x0797 0792 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0778 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @077C stack[0] = stack[-2] // @077C stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0797, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0793: // Incoming jump from 0x0792, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0796 memory[0x00:0x00] } 0793 60 PUSH1 0x00 0795 80 DUP1 0796 FD *REVERT // Stack delta = +0 // Outputs[1] { @0796 revert(memory[0x00:0x00]); } // Block terminates label_0797: // Incoming jump from 0x0792, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @0798 stack[-1] // @0798 stack[-3] // @0799 stack[-2] // @07A4 memory[0x40:0x60] // @07BE msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @07DA stack[-4] // @07DB stack[-5] // @07E0 msg.data[stack[-1]:stack[-1] + 0x20] // } 0797 5B JUMPDEST 0798 91 SWAP2 0799 90 SWAP1 079A 80 DUP1 079B 80 DUP1 079C 60 PUSH1 0x20 079E 02 MUL 079F 60 PUSH1 0x20 07A1 01 ADD 07A2 60 PUSH1 0x40 07A4 51 MLOAD 07A5 90 SWAP1 07A6 81 DUP2 07A7 01 ADD 07A8 60 PUSH1 0x40 07AA 52 MSTORE 07AB 80 DUP1 07AC 93 SWAP4 07AD 92 SWAP3 07AE 91 SWAP2 07AF 90 SWAP1 07B0 81 DUP2 07B1 81 DUP2 07B2 52 MSTORE 07B3 60 PUSH1 0x20 07B5 01 ADD 07B6 83 DUP4 07B7 83 DUP4 07B8 60 PUSH1 0x20 07BA 02 MUL 07BB 80 DUP1 07BC 82 DUP3 07BD 84 DUP5 07BE 37 CALLDATACOPY 07BF 60 PUSH1 0x00 07C1 81 DUP2 07C2 84 DUP5 07C3 01 ADD 07C4 52 MSTORE 07C5 60 PUSH1 0x1f 07C7 19 NOT 07C8 60 PUSH1 0x1f 07CA 82 DUP3 07CB 01 ADD 07CC 16 AND 07CD 90 SWAP1 07CE 50 POP 07CF 80 DUP1 07D0 83 DUP4 07D1 01 ADD 07D2 92 SWAP3 07D3 50 POP 07D4 50 POP 07D5 50 POP 07D6 50 POP 07D7 50 POP 07D8 50 POP 07D9 50 POP 07DA 91 SWAP2 07DB 92 SWAP3 07DC 91 SWAP2 07DD 92 SWAP3 07DE 90 SWAP1 07DF 80 DUP1 07E0 35 CALLDATALOAD 07E1 90 SWAP1 07E2 60 PUSH1 0x20 07E4 01 ADD 07E5 90 SWAP1 07E6 64 PUSH5 0x0100000000 07EC 81 DUP2 07ED 11 GT 07EE 15 ISZERO 07EF 61 PUSH2 0x07f7 07F2 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @07AA memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @07B2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @07BE memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @07C4 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @07DC stack[-4] = stack[-5] // @07DD stack[-5] = memory[0x40:0x60] // @07DE stack[-3] = stack[-4] // @07E5 stack[-2] = 0x20 + stack[-1] // @07E5 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x07f7, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_07F3: // Incoming jump from 0x07F2, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @07F6 memory[0x00:0x00] } 07F3 60 PUSH1 0x00 07F5 80 DUP1 07F6 FD *REVERT // Stack delta = +0 // Outputs[1] { @07F6 revert(memory[0x00:0x00]); } // Block terminates label_07F7: // Incoming jump from 0x07F2, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @07F8 stack[-3] // @07F9 stack[-1] // @07FA stack[-4] // } 07F7 5B JUMPDEST 07F8 82 DUP3 07F9 01 ADD 07FA 83 DUP4 07FB 60 PUSH1 0x20 07FD 82 DUP3 07FE 01 ADD 07FF 11 GT 0800 15 ISZERO 0801 61 PUSH2 0x0809 0804 57 *JUMPI // Stack delta = +0 // Outputs[1] { @07F9 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0809, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0805: // Incoming jump from 0x0804, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0808 memory[0x00:0x00] } 0805 60 PUSH1 0x00 0807 80 DUP1 0808 FD *REVERT // Stack delta = +0 // Outputs[1] { @0808 revert(memory[0x00:0x00]); } // Block terminates label_0809: // Incoming jump from 0x0804, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @080A stack[-1] // @080B msg.data[stack[-1]:stack[-1] + 0x20] // @0810 stack[-2] // @0811 stack[-4] // } 0809 5B JUMPDEST 080A 80 DUP1 080B 35 CALLDATALOAD 080C 90 SWAP1 080D 60 PUSH1 0x20 080F 01 ADD 0810 91 SWAP2 0811 84 DUP5 0812 60 PUSH1 0x20 0814 83 DUP4 0815 02 MUL 0816 84 DUP5 0817 01 ADD 0818 11 GT 0819 64 PUSH5 0x0100000000 081F 83 DUP4 0820 11 GT 0821 17 OR 0822 15 ISZERO 0823 61 PUSH2 0x082b 0826 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @080C stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0810 stack[0] = stack[-2] // @0810 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x082b, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0827: // Incoming jump from 0x0826, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @082A memory[0x00:0x00] } 0827 60 PUSH1 0x00 0829 80 DUP1 082A FD *REVERT // Stack delta = +0 // Outputs[1] { @082A revert(memory[0x00:0x00]); } // Block terminates label_082B: // Incoming jump from 0x0826, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[7] // { // @082C stack[-1] // @082C stack[-3] // @082D stack[-2] // @0838 memory[0x40:0x60] // @0852 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @086E stack[-4] // @086F stack[-5] // } 082B 5B JUMPDEST 082C 91 SWAP2 082D 90 SWAP1 082E 80 DUP1 082F 80 DUP1 0830 60 PUSH1 0x20 0832 02 MUL 0833 60 PUSH1 0x20 0835 01 ADD 0836 60 PUSH1 0x40 0838 51 MLOAD 0839 90 SWAP1 083A 81 DUP2 083B 01 ADD 083C 60 PUSH1 0x40 083E 52 MSTORE 083F 80 DUP1 0840 93 SWAP4 0841 92 SWAP3 0842 91 SWAP2 0843 90 SWAP1 0844 81 DUP2 0845 81 DUP2 0846 52 MSTORE 0847 60 PUSH1 0x20 0849 01 ADD 084A 83 DUP4 084B 83 DUP4 084C 60 PUSH1 0x20 084E 02 MUL 084F 80 DUP1 0850 82 DUP3 0851 84 DUP5 0852 37 CALLDATACOPY 0853 60 PUSH1 0x00 0855 81 DUP2 0856 84 DUP5 0857 01 ADD 0858 52 MSTORE 0859 60 PUSH1 0x1f 085B 19 NOT 085C 60 PUSH1 0x1f 085E 82 DUP3 085F 01 ADD 0860 16 AND 0861 90 SWAP1 0862 50 POP 0863 80 DUP1 0864 83 DUP4 0865 01 ADD 0866 92 SWAP3 0867 50 POP 0868 50 POP 0869 50 POP 086A 50 POP 086B 50 POP 086C 50 POP 086D 50 POP 086E 91 SWAP2 086F 92 SWAP3 0870 91 SWAP2 0871 92 SWAP3 0872 90 SWAP1 0873 50 POP 0874 50 POP 0875 50 POP 0876 61 PUSH2 0x17f1 0879 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @083E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @0846 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0852 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0858 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @0871 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x17f1 label_087A: // Incoming return from call to 0x0746 at 0x0741 // Inputs[4] // { // @087D memory[0x40:0x60] // @0888 stack[-1] // @088B memory[stack[-1]:stack[-1] + 0x20] // @0894 memory[stack[-1]:stack[-1] + 0x20] // } 087A 5B JUMPDEST 087B 60 PUSH1 0x40 087D 51 MLOAD 087E 80 DUP1 087F 80 DUP1 0880 60 PUSH1 0x20 0882 01 ADD 0883 82 DUP3 0884 81 DUP2 0885 03 SUB 0886 82 DUP3 0887 52 MSTORE 0888 83 DUP4 0889 81 DUP2 088A 81 DUP2 088B 51 MLOAD 088C 81 DUP2 088D 52 MSTORE 088E 60 PUSH1 0x20 0890 01 ADD 0891 91 SWAP2 0892 50 POP 0893 80 DUP1 0894 51 MLOAD 0895 90 SWAP1 0896 60 PUSH1 0x20 0898 01 ADD 0899 90 SWAP1 089A 60 PUSH1 0x20 089C 02 MUL 089D 80 DUP1 089E 83 DUP4 089F 83 DUP4 08A0 60 PUSH1 0x00 08A2 5B JUMPDEST 08A3 83 DUP4 08A4 81 DUP2 08A5 10 LT 08A6 15 ISZERO 08A7 61 PUSH2 0x08bd 08AA 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @087D stack[0] = memory[0x40:0x60] // @087E stack[1] = memory[0x40:0x60] // @0887 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @088D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0891 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0899 stack[3] = 0x20 + stack[-1] // @089C stack[4] = 0x20 * memory[stack[-1]:stack[-1] + 0x20] // @089D stack[5] = 0x20 * memory[stack[-1]:stack[-1] + 0x20] // @089E stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @089F stack[7] = 0x20 + stack[-1] // @08A0 stack[8] = 0x00 // } // Block ends with conditional jump to 0x08bd, if !(0x00 < 0x20 * memory[stack[-1]:stack[-1] + 0x20]) label_08AB: // Incoming jump from 0x08AA, if not !(0x00 < 0x20 * memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x08AA, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @08AB stack[-1] // @08AC stack[-2] // @08AE memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @08B0 stack[-3] // } 08AB 80 DUP1 08AC 82 DUP3 08AD 01 ADD 08AE 51 MLOAD 08AF 81 DUP2 08B0 84 DUP5 08B1 01 ADD 08B2 52 MSTORE 08B3 60 PUSH1 0x20 08B5 81 DUP2 08B6 01 ADD 08B7 90 SWAP1 08B8 50 POP 08B9 61 PUSH2 0x08a2 08BC 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @08B2 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @08B7 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x08a2 label_08BD: // Incoming jump from 0x08AA, if !(0x00 < 0x20 * memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x08AA, if !(stack[-1] < stack[-4]) // Inputs[6] // { // @08C2 stack[-6] // @08C2 stack[-5] // @08C4 stack[-7] // @08C5 stack[-10] // @08CB memory[0x40:0x60] // @08D0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]] // } 08BD 5B JUMPDEST 08BE 50 POP 08BF 50 POP 08C0 50 POP 08C1 50 POP 08C2 90 SWAP1 08C3 50 POP 08C4 01 ADD 08C5 92 SWAP3 08C6 50 POP 08C7 50 POP 08C8 50 POP 08C9 60 PUSH1 0x40 08CB 51 MLOAD 08CC 80 DUP1 08CD 91 SWAP2 08CE 03 SUB 08CF 90 SWAP1 08D0 F3 *RETURN // Stack delta = -10 // Outputs[1] { @08D0 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]]; } // Block terminates label_08D1: // Incoming jump from 0x0161, if 0x4f558e79 == stack[-1] // Inputs[1] { @08D8 msg.data.length } 08D1 5B JUMPDEST 08D2 61 PUSH2 0x08fd 08D5 60 PUSH1 0x04 08D7 80 DUP1 08D8 36 CALLDATASIZE 08D9 03 SUB 08DA 60 PUSH1 0x20 08DC 81 DUP2 08DD 10 LT 08DE 15 ISZERO 08DF 61 PUSH2 0x08e7 08E2 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @08D2 stack[0] = 0x08fd // @08D5 stack[1] = 0x04 // @08D9 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x08e7, returns to 0x08FD, if !(msg.data.length - 0x04 < 0x20) label_08E3: // Incoming jump from 0x08E2, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @08E6 memory[0x00:0x00] } 08E3 60 PUSH1 0x00 08E5 80 DUP1 08E6 FD *REVERT // Stack delta = +0 // Outputs[1] { @08E6 revert(memory[0x00:0x00]); } // Block terminates label_08E7: // Incoming call from 0x08E2, returns to 0x08FD, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @08E8 stack[-2] // @08E9 stack[-1] // @08ED msg.data[stack[-2]:stack[-2] + 0x20] // } 08E7 5B JUMPDEST 08E8 81 DUP2 08E9 01 ADD 08EA 90 SWAP1 08EB 80 DUP1 08EC 80 DUP1 08ED 35 CALLDATALOAD 08EE 90 SWAP1 08EF 60 PUSH1 0x20 08F1 01 ADD 08F2 90 SWAP1 08F3 92 SWAP3 08F4 91 SWAP2 08F5 90 SWAP1 08F6 50 POP 08F7 50 POP 08F8 50 POP 08F9 61 PUSH2 0x1937 08FC 56 *JUMP // Stack delta = -1 // Outputs[1] { @08F3 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1937 label_08FD: // Incoming return from call to 0x08E7 at 0x08E2 // Inputs[4] // { // @0900 memory[0x40:0x60] // @0902 stack[-1] // @0911 memory[0x40:0x60] // @0916 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 08FD 5B JUMPDEST 08FE 60 PUSH1 0x40 0900 51 MLOAD 0901 80 DUP1 0902 82 DUP3 0903 15 ISZERO 0904 15 ISZERO 0905 15 ISZERO 0906 15 ISZERO 0907 81 DUP2 0908 52 MSTORE 0909 60 PUSH1 0x20 090B 01 ADD 090C 91 SWAP2 090D 50 POP 090E 50 POP 090F 60 PUSH1 0x40 0911 51 MLOAD 0912 80 DUP1 0913 91 SWAP2 0914 03 SUB 0915 90 SWAP1 0916 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0908 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0916 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0917: // Incoming jump from 0x016C, if 0x510b5158 == stack[-1] // Inputs[1] { @091E msg.data.length } 0917 5B JUMPDEST 0918 61 PUSH2 0x0943 091B 60 PUSH1 0x04 091D 80 DUP1 091E 36 CALLDATASIZE 091F 03 SUB 0920 60 PUSH1 0x20 0922 81 DUP2 0923 10 LT 0924 15 ISZERO 0925 61 PUSH2 0x092d 0928 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0918 stack[0] = 0x0943 // @091B stack[1] = 0x04 // @091F stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x092d, returns to 0x0943, if !(msg.data.length - 0x04 < 0x20) label_0929: // Incoming jump from 0x0928, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @092C memory[0x00:0x00] } 0929 60 PUSH1 0x00 092B 80 DUP1 092C FD *REVERT // Stack delta = +0 // Outputs[1] { @092C revert(memory[0x00:0x00]); } // Block terminates label_092D: // Incoming call from 0x0928, returns to 0x0943, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @092E stack[-2] // @092F stack[-1] // @0933 msg.data[stack[-2]:stack[-2] + 0x20] // } 092D 5B JUMPDEST 092E 81 DUP2 092F 01 ADD 0930 90 SWAP1 0931 80 DUP1 0932 80 DUP1 0933 35 CALLDATALOAD 0934 90 SWAP1 0935 60 PUSH1 0x20 0937 01 ADD 0938 90 SWAP1 0939 92 SWAP3 093A 91 SWAP2 093B 90 SWAP1 093C 50 POP 093D 50 POP 093E 50 POP 093F 61 PUSH2 0x1956 0942 56 *JUMP // Stack delta = -1 // Outputs[1] { @0939 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1956 label_0943: // Incoming return from call to 0x092D at 0x0928 // Inputs[4] // { // @0946 memory[0x40:0x60] // @0948 stack[-1] // @097F memory[0x40:0x60] // @0984 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0943 5B JUMPDEST 0944 60 PUSH1 0x40 0946 51 MLOAD 0947 80 DUP1 0948 82 DUP3 0949 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 095E 16 AND 095F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0974 16 AND 0975 81 DUP2 0976 52 MSTORE 0977 60 PUSH1 0x20 0979 01 ADD 097A 91 SWAP2 097B 50 POP 097C 50 POP 097D 60 PUSH1 0x40 097F 51 MLOAD 0980 80 DUP1 0981 91 SWAP2 0982 03 SUB 0983 90 SWAP1 0984 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0976 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0984 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0985: // Incoming jump from 0x0177, if 0x715018a6 == stack[-1] 0985 5B JUMPDEST 0986 61 PUSH2 0x098d 0989 61 PUSH2 0x1989 098C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0986 stack[0] = 0x098d } // Block ends with call to 0x1989, returns to 0x098D label_098D: // Incoming return from call to 0x1989 at 0x098C 098D 5B JUMPDEST 098E 00 *STOP // Stack delta = +0 // Outputs[1] { @098E stop(); } // Block terminates label_098F: // Incoming jump from 0x0125, if 0x731133e9 == stack[-1] // Inputs[1] { @0996 msg.data.length } 098F 5B JUMPDEST 0990 61 PUSH2 0x0a7c 0993 60 PUSH1 0x04 0995 80 DUP1 0996 36 CALLDATASIZE 0997 03 SUB 0998 60 PUSH1 0x80 099A 81 DUP2 099B 10 LT 099C 15 ISZERO 099D 61 PUSH2 0x09a5 09A0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0990 stack[0] = 0x0a7c // @0993 stack[1] = 0x04 // @0997 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x09a5, returns to 0x0A7C, if !(msg.data.length - 0x04 < 0x80) label_09A1: // Incoming jump from 0x09A0, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @09A4 memory[0x00:0x00] } 09A1 60 PUSH1 0x00 09A3 80 DUP1 09A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @09A4 revert(memory[0x00:0x00]); } // Block terminates label_09A5: // Incoming call from 0x09A0, returns to 0x0A7C, if !(msg.data.length - 0x04 < 0x80) // Inputs[6] // { // @09A6 stack[-2] // @09A7 stack[-1] // @09AB msg.data[stack[-2]:stack[-2] + 0x20] // @09CB msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @09D5 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // @09DF msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] // } 09A5 5B JUMPDEST 09A6 81 DUP2 09A7 01 ADD 09A8 90 SWAP1 09A9 80 DUP1 09AA 80 DUP1 09AB 35 CALLDATALOAD 09AC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09C1 16 AND 09C2 90 SWAP1 09C3 60 PUSH1 0x20 09C5 01 ADD 09C6 90 SWAP1 09C7 92 SWAP3 09C8 91 SWAP2 09C9 90 SWAP1 09CA 80 DUP1 09CB 35 CALLDATALOAD 09CC 90 SWAP1 09CD 60 PUSH1 0x20 09CF 01 ADD 09D0 90 SWAP1 09D1 92 SWAP3 09D2 91 SWAP2 09D3 90 SWAP1 09D4 80 DUP1 09D5 35 CALLDATALOAD 09D6 90 SWAP1 09D7 60 PUSH1 0x20 09D9 01 ADD 09DA 90 SWAP1 09DB 92 SWAP3 09DC 91 SWAP2 09DD 90 SWAP1 09DE 80 DUP1 09DF 35 CALLDATALOAD 09E0 90 SWAP1 09E1 60 PUSH1 0x20 09E3 01 ADD 09E4 90 SWAP1 09E5 64 PUSH5 0x0100000000 09EB 81 DUP2 09EC 11 GT 09ED 15 ISZERO 09EE 61 PUSH2 0x09f6 09F1 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @09C7 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @09D1 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @09DB stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // @09DC stack[1] = stack[-2] + stack[-1] // @09DD stack[2] = stack[-2] // @09E4 stack[4] = msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] // @09E4 stack[3] = 0x20 + 0x20 + 0x20 + 0x20 + stack[-2] // } // Block ends with conditional jump to 0x09f6, if !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) label_09F2: // Incoming jump from 0x09F1, if not !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @09F5 memory[0x00:0x00] } 09F2 60 PUSH1 0x00 09F4 80 DUP1 09F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @09F5 revert(memory[0x00:0x00]); } // Block terminates label_09F6: // Incoming jump from 0x09F1, if !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @09F7 stack[-3] // @09F8 stack[-1] // @09F9 stack[-4] // } 09F6 5B JUMPDEST 09F7 82 DUP3 09F8 01 ADD 09F9 83 DUP4 09FA 60 PUSH1 0x20 09FC 82 DUP3 09FD 01 ADD 09FE 11 GT 09FF 15 ISZERO 0A00 61 PUSH2 0x0a08 0A03 57 *JUMPI // Stack delta = +0 // Outputs[1] { @09F8 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0a08, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0A04: // Incoming jump from 0x0A03, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0A07 memory[0x00:0x00] } 0A04 60 PUSH1 0x00 0A06 80 DUP1 0A07 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A07 revert(memory[0x00:0x00]); } // Block terminates label_0A08: // Incoming jump from 0x0A03, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0A09 stack[-1] // @0A0A msg.data[stack[-1]:stack[-1] + 0x20] // @0A0F stack[-2] // @0A10 stack[-4] // } 0A08 5B JUMPDEST 0A09 80 DUP1 0A0A 35 CALLDATALOAD 0A0B 90 SWAP1 0A0C 60 PUSH1 0x20 0A0E 01 ADD 0A0F 91 SWAP2 0A10 84 DUP5 0A11 60 PUSH1 0x01 0A13 83 DUP4 0A14 02 MUL 0A15 84 DUP5 0A16 01 ADD 0A17 11 GT 0A18 64 PUSH5 0x0100000000 0A1E 83 DUP4 0A1F 11 GT 0A20 17 OR 0A21 15 ISZERO 0A22 61 PUSH2 0x0a2a 0A25 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0A0B stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0A0F stack[0] = stack[-2] // @0A0F stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0a2a, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0A26: // Incoming jump from 0x0A25, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0A29 memory[0x00:0x00] } 0A26 60 PUSH1 0x00 0A28 80 DUP1 0A29 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A29 revert(memory[0x00:0x00]); } // Block terminates label_0A2A: // Incoming jump from 0x0A25, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @0A2B stack[-1] // @0A2B stack[-3] // @0A2C stack[-2] // @0A3D memory[0x40:0x60] // @0A54 msg.data[stack[-3]:stack[-3] + stack[-2]] // @0A70 stack[-4] // @0A71 stack[-5] // } 0A2A 5B JUMPDEST 0A2B 91 SWAP2 0A2C 90 SWAP1 0A2D 80 DUP1 0A2E 80 DUP1 0A2F 60 PUSH1 0x1f 0A31 01 ADD 0A32 60 PUSH1 0x20 0A34 80 DUP1 0A35 91 SWAP2 0A36 04 DIV 0A37 02 MUL 0A38 60 PUSH1 0x20 0A3A 01 ADD 0A3B 60 PUSH1 0x40 0A3D 51 MLOAD 0A3E 90 SWAP1 0A3F 81 DUP2 0A40 01 ADD 0A41 60 PUSH1 0x40 0A43 52 MSTORE 0A44 80 DUP1 0A45 93 SWAP4 0A46 92 SWAP3 0A47 91 SWAP2 0A48 90 SWAP1 0A49 81 DUP2 0A4A 81 DUP2 0A4B 52 MSTORE 0A4C 60 PUSH1 0x20 0A4E 01 ADD 0A4F 83 DUP4 0A50 83 DUP4 0A51 80 DUP1 0A52 82 DUP3 0A53 84 DUP5 0A54 37 CALLDATACOPY 0A55 60 PUSH1 0x00 0A57 81 DUP2 0A58 84 DUP5 0A59 01 ADD 0A5A 52 MSTORE 0A5B 60 PUSH1 0x1f 0A5D 19 NOT 0A5E 60 PUSH1 0x1f 0A60 82 DUP3 0A61 01 ADD 0A62 16 AND 0A63 90 SWAP1 0A64 50 POP 0A65 80 DUP1 0A66 83 DUP4 0A67 01 ADD 0A68 92 SWAP3 0A69 50 POP 0A6A 50 POP 0A6B 50 POP 0A6C 50 POP 0A6D 50 POP 0A6E 50 POP 0A6F 50 POP 0A70 91 SWAP2 0A71 92 SWAP3 0A72 91 SWAP2 0A73 92 SWAP3 0A74 90 SWAP1 0A75 50 POP 0A76 50 POP 0A77 50 POP 0A78 61 PUSH2 0x1aaf 0A7B 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0A43 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0A4B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0A54 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0A5A memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0A73 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1aaf label_0A7C: // Incoming return from call to 0x09A5 at 0x09A0 0A7C 5B JUMPDEST 0A7D 00 *STOP // Stack delta = +0 // Outputs[1] { @0A7D stop(); } // Block terminates label_0A7E: // Incoming jump from 0x0130, if 0x73505d35 == stack[-1] // Inputs[1] { @0A85 msg.data.length } 0A7E 5B JUMPDEST 0A7F 61 PUSH2 0x0ac0 0A82 60 PUSH1 0x04 0A84 80 DUP1 0A85 36 CALLDATASIZE 0A86 03 SUB 0A87 60 PUSH1 0x20 0A89 81 DUP2 0A8A 10 LT 0A8B 15 ISZERO 0A8C 61 PUSH2 0x0a94 0A8F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0A7F stack[0] = 0x0ac0 // @0A82 stack[1] = 0x04 // @0A86 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0a94, returns to 0x0AC0, if !(msg.data.length - 0x04 < 0x20) label_0A90: // Incoming jump from 0x0A8F, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0A93 memory[0x00:0x00] } 0A90 60 PUSH1 0x00 0A92 80 DUP1 0A93 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A93 revert(memory[0x00:0x00]); } // Block terminates label_0A94: // Incoming call from 0x0A8F, returns to 0x0AC0, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0A95 stack[-2] // @0A96 stack[-1] // @0A9A msg.data[stack[-2]:stack[-2] + 0x20] // } 0A94 5B JUMPDEST 0A95 81 DUP2 0A96 01 ADD 0A97 90 SWAP1 0A98 80 DUP1 0A99 80 DUP1 0A9A 35 CALLDATALOAD 0A9B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AB0 16 AND 0AB1 90 SWAP1 0AB2 60 PUSH1 0x20 0AB4 01 ADD 0AB5 90 SWAP1 0AB6 92 SWAP3 0AB7 91 SWAP2 0AB8 90 SWAP1 0AB9 50 POP 0ABA 50 POP 0ABB 50 POP 0ABC 61 PUSH2 0x1b8b 0ABF 56 *JUMP // Stack delta = -1 // Outputs[1] { @0AB6 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1b8b label_0AC0: // Incoming return from call to 0x0A94 at 0x0A8F // Inputs[4] // { // @0AC3 memory[0x40:0x60] // @0AC5 stack[-1] // @0AD4 memory[0x40:0x60] // @0AD9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0AC0 5B JUMPDEST 0AC1 60 PUSH1 0x40 0AC3 51 MLOAD 0AC4 80 DUP1 0AC5 82 DUP3 0AC6 15 ISZERO 0AC7 15 ISZERO 0AC8 15 ISZERO 0AC9 15 ISZERO 0ACA 81 DUP2 0ACB 52 MSTORE 0ACC 60 PUSH1 0x20 0ACE 01 ADD 0ACF 91 SWAP2 0AD0 50 POP 0AD1 50 POP 0AD2 60 PUSH1 0x40 0AD4 51 MLOAD 0AD5 80 DUP1 0AD6 91 SWAP2 0AD7 03 SUB 0AD8 90 SWAP1 0AD9 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0ACB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0AD9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0ADA: // Incoming jump from 0x013B, if 0x862440e2 == stack[-1] // Inputs[1] { @0AE1 msg.data.length } 0ADA 5B JUMPDEST 0ADB 61 PUSH2 0x0b9d 0ADE 60 PUSH1 0x04 0AE0 80 DUP1 0AE1 36 CALLDATASIZE 0AE2 03 SUB 0AE3 60 PUSH1 0x40 0AE5 81 DUP2 0AE6 10 LT 0AE7 15 ISZERO 0AE8 61 PUSH2 0x0af0 0AEB 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0ADB stack[0] = 0x0b9d // @0ADE stack[1] = 0x04 // @0AE2 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0af0, returns to 0x0B9D, if !(msg.data.length - 0x04 < 0x40) label_0AEC: // Incoming jump from 0x0AEB, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0AEF memory[0x00:0x00] } 0AEC 60 PUSH1 0x00 0AEE 80 DUP1 0AEF FD *REVERT // Stack delta = +0 // Outputs[1] { @0AEF revert(memory[0x00:0x00]); } // Block terminates label_0AF0: // Incoming call from 0x0AEB, returns to 0x0B9D, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0AF1 stack[-2] // @0AF2 stack[-1] // @0AF6 msg.data[stack[-2]:stack[-2] + 0x20] // @0B00 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0AF0 5B JUMPDEST 0AF1 81 DUP2 0AF2 01 ADD 0AF3 90 SWAP1 0AF4 80 DUP1 0AF5 80 DUP1 0AF6 35 CALLDATALOAD 0AF7 90 SWAP1 0AF8 60 PUSH1 0x20 0AFA 01 ADD 0AFB 90 SWAP1 0AFC 92 SWAP3 0AFD 91 SWAP2 0AFE 90 SWAP1 0AFF 80 DUP1 0B00 35 CALLDATALOAD 0B01 90 SWAP1 0B02 60 PUSH1 0x20 0B04 01 ADD 0B05 90 SWAP1 0B06 64 PUSH5 0x0100000000 0B0C 81 DUP2 0B0D 11 GT 0B0E 15 ISZERO 0B0F 61 PUSH2 0x0b17 0B12 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0AFC stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0AFD stack[-1] = stack[-2] + stack[-1] // @0AFE stack[0] = stack[-2] // @0B05 stack[1] = 0x20 + 0x20 + stack[-2] // @0B05 stack[2] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with conditional jump to 0x0b17, if !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000) label_0B13: // Incoming jump from 0x0B12, if not !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0B16 memory[0x00:0x00] } 0B13 60 PUSH1 0x00 0B15 80 DUP1 0B16 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B16 revert(memory[0x00:0x00]); } // Block terminates label_0B17: // Incoming jump from 0x0B12, if !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @0B18 stack[-3] // @0B19 stack[-1] // @0B1A stack[-4] // } 0B17 5B JUMPDEST 0B18 82 DUP3 0B19 01 ADD 0B1A 83 DUP4 0B1B 60 PUSH1 0x20 0B1D 82 DUP3 0B1E 01 ADD 0B1F 11 GT 0B20 15 ISZERO 0B21 61 PUSH2 0x0b29 0B24 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0B19 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0b29, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0B25: // Incoming jump from 0x0B24, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0B28 memory[0x00:0x00] } 0B25 60 PUSH1 0x00 0B27 80 DUP1 0B28 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B28 revert(memory[0x00:0x00]); } // Block terminates label_0B29: // Incoming jump from 0x0B24, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0B2A stack[-1] // @0B2B msg.data[stack[-1]:stack[-1] + 0x20] // @0B30 stack[-2] // @0B31 stack[-4] // } 0B29 5B JUMPDEST 0B2A 80 DUP1 0B2B 35 CALLDATALOAD 0B2C 90 SWAP1 0B2D 60 PUSH1 0x20 0B2F 01 ADD 0B30 91 SWAP2 0B31 84 DUP5 0B32 60 PUSH1 0x01 0B34 83 DUP4 0B35 02 MUL 0B36 84 DUP5 0B37 01 ADD 0B38 11 GT 0B39 64 PUSH5 0x0100000000 0B3F 83 DUP4 0B40 11 GT 0B41 17 OR 0B42 15 ISZERO 0B43 61 PUSH2 0x0b4b 0B46 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0B2C stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0B30 stack[0] = stack[-2] // @0B30 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0b4b, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0B47: // Incoming jump from 0x0B46, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0B4A memory[0x00:0x00] } 0B47 60 PUSH1 0x00 0B49 80 DUP1 0B4A FD *REVERT // Stack delta = +0 // Outputs[1] { @0B4A revert(memory[0x00:0x00]); } // Block terminates label_0B4B: // Incoming jump from 0x0B46, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @0B4C stack[-1] // @0B4C stack[-3] // @0B4D stack[-2] // @0B5E memory[0x40:0x60] // @0B75 msg.data[stack[-3]:stack[-3] + stack[-2]] // @0B91 stack[-4] // @0B92 stack[-5] // } 0B4B 5B JUMPDEST 0B4C 91 SWAP2 0B4D 90 SWAP1 0B4E 80 DUP1 0B4F 80 DUP1 0B50 60 PUSH1 0x1f 0B52 01 ADD 0B53 60 PUSH1 0x20 0B55 80 DUP1 0B56 91 SWAP2 0B57 04 DIV 0B58 02 MUL 0B59 60 PUSH1 0x20 0B5B 01 ADD 0B5C 60 PUSH1 0x40 0B5E 51 MLOAD 0B5F 90 SWAP1 0B60 81 DUP2 0B61 01 ADD 0B62 60 PUSH1 0x40 0B64 52 MSTORE 0B65 80 DUP1 0B66 93 SWAP4 0B67 92 SWAP3 0B68 91 SWAP2 0B69 90 SWAP1 0B6A 81 DUP2 0B6B 81 DUP2 0B6C 52 MSTORE 0B6D 60 PUSH1 0x20 0B6F 01 ADD 0B70 83 DUP4 0B71 83 DUP4 0B72 80 DUP1 0B73 82 DUP3 0B74 84 DUP5 0B75 37 CALLDATACOPY 0B76 60 PUSH1 0x00 0B78 81 DUP2 0B79 84 DUP5 0B7A 01 ADD 0B7B 52 MSTORE 0B7C 60 PUSH1 0x1f 0B7E 19 NOT 0B7F 60 PUSH1 0x1f 0B81 82 DUP3 0B82 01 ADD 0B83 16 AND 0B84 90 SWAP1 0B85 50 POP 0B86 80 DUP1 0B87 83 DUP4 0B88 01 ADD 0B89 92 SWAP3 0B8A 50 POP 0B8B 50 POP 0B8C 50 POP 0B8D 50 POP 0B8E 50 POP 0B8F 50 POP 0B90 50 POP 0B91 91 SWAP2 0B92 92 SWAP3 0B93 91 SWAP2 0B94 92 SWAP3 0B95 90 SWAP1 0B96 50 POP 0B97 50 POP 0B98 50 POP 0B99 61 PUSH2 0x1bab 0B9C 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0B64 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0B6C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0B75 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0B7B memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0B94 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1bab label_0B9D: // Incoming return from call to 0x0AF0 at 0x0AEB 0B9D 5B JUMPDEST 0B9E 00 *STOP // Stack delta = +0 // Outputs[1] { @0B9E stop(); } // Block terminates label_0B9F: // Incoming jump from 0x0146, if 0x8da5cb5b == stack[-1] 0B9F 5B JUMPDEST 0BA0 61 PUSH2 0x0ba7 0BA3 61 PUSH2 0x1c21 0BA6 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BA0 stack[0] = 0x0ba7 } // Block ends with call to 0x1c21, returns to 0x0BA7 label_0BA7: // Incoming return from call to 0x1C21 at 0x0BA6 // Inputs[4] // { // @0BAA memory[0x40:0x60] // @0BAC stack[-1] // @0BE3 memory[0x40:0x60] // @0BE8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0BA7 5B JUMPDEST 0BA8 60 PUSH1 0x40 0BAA 51 MLOAD 0BAB 80 DUP1 0BAC 82 DUP3 0BAD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BC2 16 AND 0BC3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BD8 16 AND 0BD9 81 DUP2 0BDA 52 MSTORE 0BDB 60 PUSH1 0x20 0BDD 01 ADD 0BDE 91 SWAP2 0BDF 50 POP 0BE0 50 POP 0BE1 60 PUSH1 0x40 0BE3 51 MLOAD 0BE4 80 DUP1 0BE5 91 SWAP2 0BE6 03 SUB 0BE7 90 SWAP1 0BE8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0BDA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0BE8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0BE9: // Incoming jump from 0x00E9, if 0x8f32d59b == stack[-1] 0BE9 5B JUMPDEST 0BEA 61 PUSH2 0x0bf1 0BED 61 PUSH2 0x1c4b 0BF0 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BEA stack[0] = 0x0bf1 } // Block ends with call to 0x1c4b, returns to 0x0BF1 label_0BF1: // Incoming return from call to 0x1C4B at 0x0BF0 // Inputs[4] // { // @0BF4 memory[0x40:0x60] // @0BF6 stack[-1] // @0C05 memory[0x40:0x60] // @0C0A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0BF1 5B JUMPDEST 0BF2 60 PUSH1 0x40 0BF4 51 MLOAD 0BF5 80 DUP1 0BF6 82 DUP3 0BF7 15 ISZERO 0BF8 15 ISZERO 0BF9 15 ISZERO 0BFA 15 ISZERO 0BFB 81 DUP2 0BFC 52 MSTORE 0BFD 60 PUSH1 0x20 0BFF 01 ADD 0C00 91 SWAP2 0C01 50 POP 0C02 50 POP 0C03 60 PUSH1 0x40 0C05 51 MLOAD 0C06 80 DUP1 0C07 91 SWAP2 0C08 03 SUB 0C09 90 SWAP1 0C0A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0BFC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0C0A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0C0B: // Incoming jump from 0x00F4, if 0x91686f53 == stack[-1] // Inputs[1] { @0C12 msg.data.length } 0C0B 5B JUMPDEST 0C0C 61 PUSH2 0x0c57 0C0F 60 PUSH1 0x04 0C11 80 DUP1 0C12 36 CALLDATASIZE 0C13 03 SUB 0C14 60 PUSH1 0x40 0C16 81 DUP2 0C17 10 LT 0C18 15 ISZERO 0C19 61 PUSH2 0x0c21 0C1C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0C0C stack[0] = 0x0c57 // @0C0F stack[1] = 0x04 // @0C13 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0c21, returns to 0x0C57, if !(msg.data.length - 0x04 < 0x40) label_0C1D: // Incoming jump from 0x0C1C, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0C20 memory[0x00:0x00] } 0C1D 60 PUSH1 0x00 0C1F 80 DUP1 0C20 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C20 revert(memory[0x00:0x00]); } // Block terminates label_0C21: // Incoming call from 0x0C1C, returns to 0x0C57, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0C22 stack[-2] // @0C23 stack[-1] // @0C27 msg.data[stack[-2]:stack[-2] + 0x20] // @0C31 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0C21 5B JUMPDEST 0C22 81 DUP2 0C23 01 ADD 0C24 90 SWAP1 0C25 80 DUP1 0C26 80 DUP1 0C27 35 CALLDATALOAD 0C28 90 SWAP1 0C29 60 PUSH1 0x20 0C2B 01 ADD 0C2C 90 SWAP1 0C2D 92 SWAP3 0C2E 91 SWAP2 0C2F 90 SWAP1 0C30 80 DUP1 0C31 35 CALLDATALOAD 0C32 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C47 16 AND 0C48 90 SWAP1 0C49 60 PUSH1 0x20 0C4B 01 ADD 0C4C 90 SWAP1 0C4D 92 SWAP3 0C4E 91 SWAP2 0C4F 90 SWAP1 0C50 50 POP 0C51 50 POP 0C52 50 POP 0C53 61 PUSH2 0x1caa 0C56 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0C2D stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0C4D stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1caa label_0C57: // Incoming return from call to 0x0C21 at 0x0C1C 0C57 5B JUMPDEST 0C58 00 *STOP // Stack delta = +0 // Outputs[1] { @0C58 stop(); } // Block terminates label_0C59: // Incoming jump from 0x00FF, if 0x95d89b41 == stack[-1] 0C59 5B JUMPDEST 0C5A 61 PUSH2 0x0c61 0C5D 61 PUSH2 0x1e32 0C60 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C5A stack[0] = 0x0c61 } // Block ends with call to 0x1e32, returns to 0x0C61 label_0C61: // Incoming return from call to 0x1E32 at 0x0C60 // Inputs[4] // { // @0C64 memory[0x40:0x60] // @0C6F stack[-1] // @0C72 memory[stack[-1]:stack[-1] + 0x20] // @0C7B memory[stack[-1]:stack[-1] + 0x20] // } 0C61 5B JUMPDEST 0C62 60 PUSH1 0x40 0C64 51 MLOAD 0C65 80 DUP1 0C66 80 DUP1 0C67 60 PUSH1 0x20 0C69 01 ADD 0C6A 82 DUP3 0C6B 81 DUP2 0C6C 03 SUB 0C6D 82 DUP3 0C6E 52 MSTORE 0C6F 83 DUP4 0C70 81 DUP2 0C71 81 DUP2 0C72 51 MLOAD 0C73 81 DUP2 0C74 52 MSTORE 0C75 60 PUSH1 0x20 0C77 01 ADD 0C78 91 SWAP2 0C79 50 POP 0C7A 80 DUP1 0C7B 51 MLOAD 0C7C 90 SWAP1 0C7D 60 PUSH1 0x20 0C7F 01 ADD 0C80 90 SWAP1 0C81 80 DUP1 0C82 83 DUP4 0C83 83 DUP4 0C84 60 PUSH1 0x00 0C86 5B JUMPDEST 0C87 83 DUP4 0C88 81 DUP2 0C89 10 LT 0C8A 15 ISZERO 0C8B 61 PUSH2 0x0ca1 0C8E 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0C64 stack[0] = memory[0x40:0x60] // @0C65 stack[1] = memory[0x40:0x60] // @0C6E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0C74 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0C78 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0C80 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0C80 stack[3] = 0x20 + stack[-1] // @0C81 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0C82 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0C83 stack[7] = 0x20 + stack[-1] // @0C84 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0ca1, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0C8F: // Incoming jump from 0x0C8E, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0C8E, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0C8F stack[-1] // @0C90 stack[-2] // @0C92 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0C94 stack[-3] // } 0C8F 80 DUP1 0C90 82 DUP3 0C91 01 ADD 0C92 51 MLOAD 0C93 81 DUP2 0C94 84 DUP5 0C95 01 ADD 0C96 52 MSTORE 0C97 60 PUSH1 0x20 0C99 81 DUP2 0C9A 01 ADD 0C9B 90 SWAP1 0C9C 50 POP 0C9D 61 PUSH2 0x0c86 0CA0 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0C96 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0C9B stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0c86 label_0CA1: // Incoming jump from 0x0C8E, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0C8E, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0CA6 stack[-6] // @0CA6 stack[-5] // @0CA8 stack[-7] // } 0CA1 5B JUMPDEST 0CA2 50 POP 0CA3 50 POP 0CA4 50 POP 0CA5 50 POP 0CA6 90 SWAP1 0CA7 50 POP 0CA8 90 SWAP1 0CA9 81 DUP2 0CAA 01 ADD 0CAB 90 SWAP1 0CAC 60 PUSH1 0x1f 0CAE 16 AND 0CAF 80 DUP1 0CB0 15 ISZERO 0CB1 61 PUSH2 0x0cce 0CB4 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0CAB stack[-7] = stack[-5] + stack[-7] // @0CAE stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0cce, if !(0x1f & stack[-5]) label_0CB5: // Incoming jump from 0x0CB4, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0CB5 stack[-1] // @0CB6 stack[-2] // @0CB9 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0CD0 stack[-5] // @0CD6 memory[0x40:0x60] // @0CDB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0CB5 80 DUP1 0CB6 82 DUP3 0CB7 03 SUB 0CB8 80 DUP1 0CB9 51 MLOAD 0CBA 60 PUSH1 0x01 0CBC 83 DUP4 0CBD 60 PUSH1 0x20 0CBF 03 SUB 0CC0 61 PUSH2 0x0100 0CC3 0A EXP 0CC4 03 SUB 0CC5 19 NOT 0CC6 16 AND 0CC7 81 DUP2 0CC8 52 MSTORE 0CC9 60 PUSH1 0x20 0CCB 01 ADD 0CCC 91 SWAP2 0CCD 50 POP 0CCE 5B JUMPDEST 0CCF 50 POP 0CD0 92 SWAP3 0CD1 50 POP 0CD2 50 POP 0CD3 50 POP 0CD4 60 PUSH1 0x40 0CD6 51 MLOAD 0CD7 80 DUP1 0CD8 91 SWAP2 0CD9 03 SUB 0CDA 90 SWAP1 0CDB F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0CC8 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0CDB return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0CDC: // Incoming jump from 0x00B8, if 0x9e037eea == stack[-1] // Inputs[1] { @0CE3 msg.data.length } 0CDC 5B JUMPDEST 0CDD 61 PUSH2 0x0d1e 0CE0 60 PUSH1 0x04 0CE2 80 DUP1 0CE3 36 CALLDATASIZE 0CE4 03 SUB 0CE5 60 PUSH1 0x20 0CE7 81 DUP2 0CE8 10 LT 0CE9 15 ISZERO 0CEA 61 PUSH2 0x0cf2 0CED 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0CDD stack[0] = 0x0d1e // @0CE0 stack[1] = 0x04 // @0CE4 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0cf2, returns to 0x0D1E, if !(msg.data.length - 0x04 < 0x20) label_0CEE: // Incoming jump from 0x0CED, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0CF1 memory[0x00:0x00] } 0CEE 60 PUSH1 0x00 0CF0 80 DUP1 0CF1 FD *REVERT // Stack delta = +0 // Outputs[1] { @0CF1 revert(memory[0x00:0x00]); } // Block terminates label_0CF2: // Incoming call from 0x0CED, returns to 0x0D1E, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0CF3 stack[-2] // @0CF4 stack[-1] // @0CF8 msg.data[stack[-2]:stack[-2] + 0x20] // } 0CF2 5B JUMPDEST 0CF3 81 DUP2 0CF4 01 ADD 0CF5 90 SWAP1 0CF6 80 DUP1 0CF7 80 DUP1 0CF8 35 CALLDATALOAD 0CF9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D0E 16 AND 0D0F 90 SWAP1 0D10 60 PUSH1 0x20 0D12 01 ADD 0D13 90 SWAP1 0D14 92 SWAP3 0D15 91 SWAP2 0D16 90 SWAP1 0D17 50 POP 0D18 50 POP 0D19 50 POP 0D1A 61 PUSH2 0x1ed0 0D1D 56 *JUMP // Stack delta = -1 // Outputs[1] { @0D14 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1ed0 label_0D1E: // Incoming return from call to 0x0CF2 at 0x0CED 0D1E 5B JUMPDEST 0D1F 00 *STOP // Stack delta = +0 // Outputs[1] { @0D1F stop(); } // Block terminates label_0D20: // Incoming jump from 0x00C3, if 0xa22cb465 == stack[-1] // Inputs[1] { @0D27 msg.data.length } 0D20 5B JUMPDEST 0D21 61 PUSH2 0x0d6e 0D24 60 PUSH1 0x04 0D26 80 DUP1 0D27 36 CALLDATASIZE 0D28 03 SUB 0D29 60 PUSH1 0x40 0D2B 81 DUP2 0D2C 10 LT 0D2D 15 ISZERO 0D2E 61 PUSH2 0x0d36 0D31 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0D21 stack[0] = 0x0d6e // @0D24 stack[1] = 0x04 // @0D28 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0d36, returns to 0x0D6E, if !(msg.data.length - 0x04 < 0x40) label_0D32: // Incoming jump from 0x0D31, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0D35 memory[0x00:0x00] } 0D32 60 PUSH1 0x00 0D34 80 DUP1 0D35 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D35 revert(memory[0x00:0x00]); } // Block terminates label_0D36: // Incoming call from 0x0D31, returns to 0x0D6E, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0D37 stack[-2] // @0D38 stack[-1] // @0D3C msg.data[stack[-2]:stack[-2] + 0x20] // @0D5C msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0D36 5B JUMPDEST 0D37 81 DUP2 0D38 01 ADD 0D39 90 SWAP1 0D3A 80 DUP1 0D3B 80 DUP1 0D3C 35 CALLDATALOAD 0D3D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D52 16 AND 0D53 90 SWAP1 0D54 60 PUSH1 0x20 0D56 01 ADD 0D57 90 SWAP1 0D58 92 SWAP3 0D59 91 SWAP2 0D5A 90 SWAP1 0D5B 80 DUP1 0D5C 35 CALLDATALOAD 0D5D 15 ISZERO 0D5E 15 ISZERO 0D5F 90 SWAP1 0D60 60 PUSH1 0x20 0D62 01 ADD 0D63 90 SWAP1 0D64 92 SWAP3 0D65 91 SWAP2 0D66 90 SWAP1 0D67 50 POP 0D68 50 POP 0D69 50 POP 0D6A 61 PUSH2 0x1f87 0D6D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0D58 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0D64 stack[-1] = !!msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1f87 label_0D6E: // Incoming return from call to 0x0D36 at 0x0D31 0D6E 5B JUMPDEST 0D6F 00 *STOP // Stack delta = +0 // Outputs[1] { @0D6F stop(); } // Block terminates label_0D70: // Incoming jump from 0x00CE, if 0xa50aa5c3 == stack[-1] // Inputs[1] { @0D77 msg.data.length } 0D70 5B JUMPDEST 0D71 61 PUSH2 0x0db2 0D74 60 PUSH1 0x04 0D76 80 DUP1 0D77 36 CALLDATASIZE 0D78 03 SUB 0D79 60 PUSH1 0x20 0D7B 81 DUP2 0D7C 10 LT 0D7D 15 ISZERO 0D7E 61 PUSH2 0x0d86 0D81 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0D71 stack[0] = 0x0db2 // @0D74 stack[1] = 0x04 // @0D78 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0d86, returns to 0x0DB2, if !(msg.data.length - 0x04 < 0x20) label_0D82: // Incoming jump from 0x0D81, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0D85 memory[0x00:0x00] } 0D82 60 PUSH1 0x00 0D84 80 DUP1 0D85 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D85 revert(memory[0x00:0x00]); } // Block terminates label_0D86: // Incoming call from 0x0D81, returns to 0x0DB2, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0D87 stack[-2] // @0D88 stack[-1] // @0D8C msg.data[stack[-2]:stack[-2] + 0x20] // } 0D86 5B JUMPDEST 0D87 81 DUP2 0D88 01 ADD 0D89 90 SWAP1 0D8A 80 DUP1 0D8B 80 DUP1 0D8C 35 CALLDATALOAD 0D8D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DA2 16 AND 0DA3 90 SWAP1 0DA4 60 PUSH1 0x20 0DA6 01 ADD 0DA7 90 SWAP1 0DA8 92 SWAP3 0DA9 91 SWAP2 0DAA 90 SWAP1 0DAB 50 POP 0DAC 50 POP 0DAD 50 POP 0DAE 61 PUSH2 0x2088 0DB1 56 *JUMP // Stack delta = -1 // Outputs[1] { @0DA8 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2088 label_0DB2: // Incoming return from call to 0x0D86 at 0x0D81 0DB2 5B JUMPDEST 0DB3 00 *STOP // Stack delta = +0 // Outputs[1] { @0DB3 stop(); } // Block terminates label_0DB4: // Incoming jump from 0x00D9, if 0xb48ab8b6 == stack[-1] // Inputs[1] { @0DBB msg.data.length } 0DB4 5B JUMPDEST 0DB5 61 PUSH2 0x0fb5 0DB8 60 PUSH1 0x04 0DBA 80 DUP1 0DBB 36 CALLDATASIZE 0DBC 03 SUB 0DBD 60 PUSH1 0x80 0DBF 81 DUP2 0DC0 10 LT 0DC1 15 ISZERO 0DC2 61 PUSH2 0x0dca 0DC5 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0DB5 stack[0] = 0x0fb5 // @0DB8 stack[1] = 0x04 // @0DBC stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0dca, returns to 0x0FB5, if !(msg.data.length - 0x04 < 0x80) label_0DC6: // Incoming jump from 0x0DC5, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @0DC9 memory[0x00:0x00] } 0DC6 60 PUSH1 0x00 0DC8 80 DUP1 0DC9 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DC9 revert(memory[0x00:0x00]); } // Block terminates label_0DCA: // Incoming call from 0x0DC5, returns to 0x0FB5, if !(msg.data.length - 0x04 < 0x80) // Inputs[4] // { // @0DCB stack[-2] // @0DCC stack[-1] // @0DD0 msg.data[stack[-2]:stack[-2] + 0x20] // @0DF0 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0DCA 5B JUMPDEST 0DCB 81 DUP2 0DCC 01 ADD 0DCD 90 SWAP1 0DCE 80 DUP1 0DCF 80 DUP1 0DD0 35 CALLDATALOAD 0DD1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DE6 16 AND 0DE7 90 SWAP1 0DE8 60 PUSH1 0x20 0DEA 01 ADD 0DEB 90 SWAP1 0DEC 92 SWAP3 0DED 91 SWAP2 0DEE 90 SWAP1 0DEF 80 DUP1 0DF0 35 CALLDATALOAD 0DF1 90 SWAP1 0DF2 60 PUSH1 0x20 0DF4 01 ADD 0DF5 90 SWAP1 0DF6 64 PUSH5 0x0100000000 0DFC 81 DUP2 0DFD 11 GT 0DFE 15 ISZERO 0DFF 61 PUSH2 0x0e07 0E02 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0DEC stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0DED stack[-1] = stack[-2] + stack[-1] // @0DEE stack[0] = stack[-2] // @0DF5 stack[1] = 0x20 + 0x20 + stack[-2] // @0DF5 stack[2] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with conditional jump to 0x0e07, if !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000) label_0E03: // Incoming jump from 0x0E02, if not !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0E06 memory[0x00:0x00] } 0E03 60 PUSH1 0x00 0E05 80 DUP1 0E06 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E06 revert(memory[0x00:0x00]); } // Block terminates label_0E07: // Incoming jump from 0x0E02, if !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @0E08 stack[-3] // @0E09 stack[-1] // @0E0A stack[-4] // } 0E07 5B JUMPDEST 0E08 82 DUP3 0E09 01 ADD 0E0A 83 DUP4 0E0B 60 PUSH1 0x20 0E0D 82 DUP3 0E0E 01 ADD 0E0F 11 GT 0E10 15 ISZERO 0E11 61 PUSH2 0x0e19 0E14 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0E09 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0e19, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0E15: // Incoming jump from 0x0E14, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0E18 memory[0x00:0x00] } 0E15 60 PUSH1 0x00 0E17 80 DUP1 0E18 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E18 revert(memory[0x00:0x00]); } // Block terminates label_0E19: // Incoming jump from 0x0E14, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0E1A stack[-1] // @0E1B msg.data[stack[-1]:stack[-1] + 0x20] // @0E20 stack[-2] // @0E21 stack[-4] // } 0E19 5B JUMPDEST 0E1A 80 DUP1 0E1B 35 CALLDATALOAD 0E1C 90 SWAP1 0E1D 60 PUSH1 0x20 0E1F 01 ADD 0E20 91 SWAP2 0E21 84 DUP5 0E22 60 PUSH1 0x20 0E24 83 DUP4 0E25 02 MUL 0E26 84 DUP5 0E27 01 ADD 0E28 11 GT 0E29 64 PUSH5 0x0100000000 0E2F 83 DUP4 0E30 11 GT 0E31 17 OR 0E32 15 ISZERO 0E33 61 PUSH2 0x0e3b 0E36 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0E1C stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0E20 stack[0] = stack[-2] // @0E20 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0e3b, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0E37: // Incoming jump from 0x0E36, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0E3A memory[0x00:0x00] } 0E37 60 PUSH1 0x00 0E39 80 DUP1 0E3A FD *REVERT // Stack delta = +0 // Outputs[1] { @0E3A revert(memory[0x00:0x00]); } // Block terminates label_0E3B: // Incoming jump from 0x0E36, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @0E3C stack[-1] // @0E3C stack[-3] // @0E3D stack[-2] // @0E48 memory[0x40:0x60] // @0E62 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0E7E stack[-4] // @0E7F stack[-5] // @0E84 msg.data[stack[-1]:stack[-1] + 0x20] // } 0E3B 5B JUMPDEST 0E3C 91 SWAP2 0E3D 90 SWAP1 0E3E 80 DUP1 0E3F 80 DUP1 0E40 60 PUSH1 0x20 0E42 02 MUL 0E43 60 PUSH1 0x20 0E45 01 ADD 0E46 60 PUSH1 0x40 0E48 51 MLOAD 0E49 90 SWAP1 0E4A 81 DUP2 0E4B 01 ADD 0E4C 60 PUSH1 0x40 0E4E 52 MSTORE 0E4F 80 DUP1 0E50 93 SWAP4 0E51 92 SWAP3 0E52 91 SWAP2 0E53 90 SWAP1 0E54 81 DUP2 0E55 81 DUP2 0E56 52 MSTORE 0E57 60 PUSH1 0x20 0E59 01 ADD 0E5A 83 DUP4 0E5B 83 DUP4 0E5C 60 PUSH1 0x20 0E5E 02 MUL 0E5F 80 DUP1 0E60 82 DUP3 0E61 84 DUP5 0E62 37 CALLDATACOPY 0E63 60 PUSH1 0x00 0E65 81 DUP2 0E66 84 DUP5 0E67 01 ADD 0E68 52 MSTORE 0E69 60 PUSH1 0x1f 0E6B 19 NOT 0E6C 60 PUSH1 0x1f 0E6E 82 DUP3 0E6F 01 ADD 0E70 16 AND 0E71 90 SWAP1 0E72 50 POP 0E73 80 DUP1 0E74 83 DUP4 0E75 01 ADD 0E76 92 SWAP3 0E77 50 POP 0E78 50 POP 0E79 50 POP 0E7A 50 POP 0E7B 50 POP 0E7C 50 POP 0E7D 50 POP 0E7E 91 SWAP2 0E7F 92 SWAP3 0E80 91 SWAP2 0E81 92 SWAP3 0E82 90 SWAP1 0E83 80 DUP1 0E84 35 CALLDATALOAD 0E85 90 SWAP1 0E86 60 PUSH1 0x20 0E88 01 ADD 0E89 90 SWAP1 0E8A 64 PUSH5 0x0100000000 0E90 81 DUP2 0E91 11 GT 0E92 15 ISZERO 0E93 61 PUSH2 0x0e9b 0E96 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0E4E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @0E56 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0E62 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0E68 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @0E80 stack[-4] = stack[-5] // @0E81 stack[-5] = memory[0x40:0x60] // @0E82 stack[-3] = stack[-4] // @0E89 stack[-2] = 0x20 + stack[-1] // @0E89 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0e9b, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_0E97: // Incoming jump from 0x0E96, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @0E9A memory[0x00:0x00] } 0E97 60 PUSH1 0x00 0E99 80 DUP1 0E9A FD *REVERT // Stack delta = +0 // Outputs[1] { @0E9A revert(memory[0x00:0x00]); } // Block terminates label_0E9B: // Incoming jump from 0x0E96, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @0E9C stack[-3] // @0E9D stack[-1] // @0E9E stack[-4] // } 0E9B 5B JUMPDEST 0E9C 82 DUP3 0E9D 01 ADD 0E9E 83 DUP4 0E9F 60 PUSH1 0x20 0EA1 82 DUP3 0EA2 01 ADD 0EA3 11 GT 0EA4 15 ISZERO 0EA5 61 PUSH2 0x0ead 0EA8 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0E9D stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0ead, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0EA9: // Incoming jump from 0x0EA8, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0EAC memory[0x00:0x00] } 0EA9 60 PUSH1 0x00 0EAB 80 DUP1 0EAC FD *REVERT // Stack delta = +0 // Outputs[1] { @0EAC revert(memory[0x00:0x00]); } // Block terminates label_0EAD: // Incoming jump from 0x0EA8, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0EAE stack[-1] // @0EAF msg.data[stack[-1]:stack[-1] + 0x20] // @0EB4 stack[-2] // @0EB5 stack[-4] // } 0EAD 5B JUMPDEST 0EAE 80 DUP1 0EAF 35 CALLDATALOAD 0EB0 90 SWAP1 0EB1 60 PUSH1 0x20 0EB3 01 ADD 0EB4 91 SWAP2 0EB5 84 DUP5 0EB6 60 PUSH1 0x20 0EB8 83 DUP4 0EB9 02 MUL 0EBA 84 DUP5 0EBB 01 ADD 0EBC 11 GT 0EBD 64 PUSH5 0x0100000000 0EC3 83 DUP4 0EC4 11 GT 0EC5 17 OR 0EC6 15 ISZERO 0EC7 61 PUSH2 0x0ecf 0ECA 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0EB0 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0EB4 stack[0] = stack[-2] // @0EB4 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0ecf, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0ECB: // Incoming jump from 0x0ECA, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0ECE memory[0x00:0x00] } 0ECB 60 PUSH1 0x00 0ECD 80 DUP1 0ECE FD *REVERT // Stack delta = +0 // Outputs[1] { @0ECE revert(memory[0x00:0x00]); } // Block terminates label_0ECF: // Incoming jump from 0x0ECA, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @0ED0 stack[-1] // @0ED0 stack[-3] // @0ED1 stack[-2] // @0EDC memory[0x40:0x60] // @0EF6 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0F12 stack[-4] // @0F13 stack[-5] // @0F18 msg.data[stack[-1]:stack[-1] + 0x20] // } 0ECF 5B JUMPDEST 0ED0 91 SWAP2 0ED1 90 SWAP1 0ED2 80 DUP1 0ED3 80 DUP1 0ED4 60 PUSH1 0x20 0ED6 02 MUL 0ED7 60 PUSH1 0x20 0ED9 01 ADD 0EDA 60 PUSH1 0x40 0EDC 51 MLOAD 0EDD 90 SWAP1 0EDE 81 DUP2 0EDF 01 ADD 0EE0 60 PUSH1 0x40 0EE2 52 MSTORE 0EE3 80 DUP1 0EE4 93 SWAP4 0EE5 92 SWAP3 0EE6 91 SWAP2 0EE7 90 SWAP1 0EE8 81 DUP2 0EE9 81 DUP2 0EEA 52 MSTORE 0EEB 60 PUSH1 0x20 0EED 01 ADD 0EEE 83 DUP4 0EEF 83 DUP4 0EF0 60 PUSH1 0x20 0EF2 02 MUL 0EF3 80 DUP1 0EF4 82 DUP3 0EF5 84 DUP5 0EF6 37 CALLDATACOPY 0EF7 60 PUSH1 0x00 0EF9 81 DUP2 0EFA 84 DUP5 0EFB 01 ADD 0EFC 52 MSTORE 0EFD 60 PUSH1 0x1f 0EFF 19 NOT 0F00 60 PUSH1 0x1f 0F02 82 DUP3 0F03 01 ADD 0F04 16 AND 0F05 90 SWAP1 0F06 50 POP 0F07 80 DUP1 0F08 83 DUP4 0F09 01 ADD 0F0A 92 SWAP3 0F0B 50 POP 0F0C 50 POP 0F0D 50 POP 0F0E 50 POP 0F0F 50 POP 0F10 50 POP 0F11 50 POP 0F12 91 SWAP2 0F13 92 SWAP3 0F14 91 SWAP2 0F15 92 SWAP3 0F16 90 SWAP1 0F17 80 DUP1 0F18 35 CALLDATALOAD 0F19 90 SWAP1 0F1A 60 PUSH1 0x20 0F1C 01 ADD 0F1D 90 SWAP1 0F1E 64 PUSH5 0x0100000000 0F24 81 DUP2 0F25 11 GT 0F26 15 ISZERO 0F27 61 PUSH2 0x0f2f 0F2A 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0EE2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @0EEA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0EF6 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0EFC memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @0F14 stack[-4] = stack[-5] // @0F15 stack[-5] = memory[0x40:0x60] // @0F16 stack[-3] = stack[-4] // @0F1D stack[-2] = 0x20 + stack[-1] // @0F1D stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0f2f, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_0F2B: // Incoming jump from 0x0F2A, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @0F2E memory[0x00:0x00] } 0F2B 60 PUSH1 0x00 0F2D 80 DUP1 0F2E FD *REVERT // Stack delta = +0 // Outputs[1] { @0F2E revert(memory[0x00:0x00]); } // Block terminates label_0F2F: // Incoming jump from 0x0F2A, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @0F30 stack[-3] // @0F31 stack[-1] // @0F32 stack[-4] // } 0F2F 5B JUMPDEST 0F30 82 DUP3 0F31 01 ADD 0F32 83 DUP4 0F33 60 PUSH1 0x20 0F35 82 DUP3 0F36 01 ADD 0F37 11 GT 0F38 15 ISZERO 0F39 61 PUSH2 0x0f41 0F3C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0F31 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0f41, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0F3D: // Incoming jump from 0x0F3C, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0F40 memory[0x00:0x00] } 0F3D 60 PUSH1 0x00 0F3F 80 DUP1 0F40 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F40 revert(memory[0x00:0x00]); } // Block terminates label_0F41: // Incoming jump from 0x0F3C, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0F42 stack[-1] // @0F43 msg.data[stack[-1]:stack[-1] + 0x20] // @0F48 stack[-2] // @0F49 stack[-4] // } 0F41 5B JUMPDEST 0F42 80 DUP1 0F43 35 CALLDATALOAD 0F44 90 SWAP1 0F45 60 PUSH1 0x20 0F47 01 ADD 0F48 91 SWAP2 0F49 84 DUP5 0F4A 60 PUSH1 0x01 0F4C 83 DUP4 0F4D 02 MUL 0F4E 84 DUP5 0F4F 01 ADD 0F50 11 GT 0F51 64 PUSH5 0x0100000000 0F57 83 DUP4 0F58 11 GT 0F59 17 OR 0F5A 15 ISZERO 0F5B 61 PUSH2 0x0f63 0F5E 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0F44 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0F48 stack[0] = stack[-2] // @0F48 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0f63, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0F5F: // Incoming jump from 0x0F5E, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0F62 memory[0x00:0x00] } 0F5F 60 PUSH1 0x00 0F61 80 DUP1 0F62 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F62 revert(memory[0x00:0x00]); } // Block terminates label_0F63: // Incoming jump from 0x0F5E, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @0F64 stack[-1] // @0F64 stack[-3] // @0F65 stack[-2] // @0F76 memory[0x40:0x60] // @0F8D msg.data[stack[-3]:stack[-3] + stack[-2]] // @0FA9 stack[-4] // @0FAA stack[-5] // } 0F63 5B JUMPDEST 0F64 91 SWAP2 0F65 90 SWAP1 0F66 80 DUP1 0F67 80 DUP1 0F68 60 PUSH1 0x1f 0F6A 01 ADD 0F6B 60 PUSH1 0x20 0F6D 80 DUP1 0F6E 91 SWAP2 0F6F 04 DIV 0F70 02 MUL 0F71 60 PUSH1 0x20 0F73 01 ADD 0F74 60 PUSH1 0x40 0F76 51 MLOAD 0F77 90 SWAP1 0F78 81 DUP2 0F79 01 ADD 0F7A 60 PUSH1 0x40 0F7C 52 MSTORE 0F7D 80 DUP1 0F7E 93 SWAP4 0F7F 92 SWAP3 0F80 91 SWAP2 0F81 90 SWAP1 0F82 81 DUP2 0F83 81 DUP2 0F84 52 MSTORE 0F85 60 PUSH1 0x20 0F87 01 ADD 0F88 83 DUP4 0F89 83 DUP4 0F8A 80 DUP1 0F8B 82 DUP3 0F8C 84 DUP5 0F8D 37 CALLDATACOPY 0F8E 60 PUSH1 0x00 0F90 81 DUP2 0F91 84 DUP5 0F92 01 ADD 0F93 52 MSTORE 0F94 60 PUSH1 0x1f 0F96 19 NOT 0F97 60 PUSH1 0x1f 0F99 82 DUP3 0F9A 01 ADD 0F9B 16 AND 0F9C 90 SWAP1 0F9D 50 POP 0F9E 80 DUP1 0F9F 83 DUP4 0FA0 01 ADD 0FA1 92 SWAP3 0FA2 50 POP 0FA3 50 POP 0FA4 50 POP 0FA5 50 POP 0FA6 50 POP 0FA7 50 POP 0FA8 50 POP 0FA9 91 SWAP2 0FAA 92 SWAP3 0FAB 91 SWAP2 0FAC 92 SWAP3 0FAD 90 SWAP1 0FAE 50 POP 0FAF 50 POP 0FB0 50 POP 0FB1 61 PUSH2 0x2148 0FB4 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0F7C memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0F84 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0F8D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0F93 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0FAC stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2148 label_0FB5: // Incoming return from call to 0x0DCA at 0x0DC5 0FB5 5B JUMPDEST 0FB6 00 *STOP // Stack delta = +0 // Outputs[1] { @0FB6 stop(); } // Block terminates label_0FB7: // Incoming jump from 0x007C, if 0xbd85b039 == stack[-1] // Inputs[1] { @0FBE msg.data.length } 0FB7 5B JUMPDEST 0FB8 61 PUSH2 0x0fe3 0FBB 60 PUSH1 0x04 0FBD 80 DUP1 0FBE 36 CALLDATASIZE 0FBF 03 SUB 0FC0 60 PUSH1 0x20 0FC2 81 DUP2 0FC3 10 LT 0FC4 15 ISZERO 0FC5 61 PUSH2 0x0fcd 0FC8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0FB8 stack[0] = 0x0fe3 // @0FBB stack[1] = 0x04 // @0FBF stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0fcd, returns to 0x0FE3, if !(msg.data.length - 0x04 < 0x20) label_0FC9: // Incoming jump from 0x0FC8, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0FCC memory[0x00:0x00] } 0FC9 60 PUSH1 0x00 0FCB 80 DUP1 0FCC FD *REVERT // Stack delta = +0 // Outputs[1] { @0FCC revert(memory[0x00:0x00]); } // Block terminates label_0FCD: // Incoming call from 0x0FC8, returns to 0x0FE3, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0FCE stack[-2] // @0FCF stack[-1] // @0FD3 msg.data[stack[-2]:stack[-2] + 0x20] // } 0FCD 5B JUMPDEST 0FCE 81 DUP2 0FCF 01 ADD 0FD0 90 SWAP1 0FD1 80 DUP1 0FD2 80 DUP1 0FD3 35 CALLDATALOAD 0FD4 90 SWAP1 0FD5 60 PUSH1 0x20 0FD7 01 ADD 0FD8 90 SWAP1 0FD9 92 SWAP3 0FDA 91 SWAP2 0FDB 90 SWAP1 0FDC 50 POP 0FDD 50 POP 0FDE 50 POP 0FDF 61 PUSH2 0x2267 0FE2 56 *JUMP // Stack delta = -1 // Outputs[1] { @0FD9 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2267 label_0FE3: // Incoming return from call to 0x0FCD at 0x0FC8 // Inputs[4] // { // @0FE6 memory[0x40:0x60] // @0FE8 stack[-1] // @0FF3 memory[0x40:0x60] // @0FF8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0FE3 5B JUMPDEST 0FE4 60 PUSH1 0x40 0FE6 51 MLOAD 0FE7 80 DUP1 0FE8 82 DUP3 0FE9 81 DUP2 0FEA 52 MSTORE 0FEB 60 PUSH1 0x20 0FED 01 ADD 0FEE 91 SWAP2 0FEF 50 POP 0FF0 50 POP 0FF1 60 PUSH1 0x40 0FF3 51 MLOAD 0FF4 80 DUP1 0FF5 91 SWAP2 0FF6 03 SUB 0FF7 90 SWAP1 0FF8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0FEA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0FF8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0FF9: // Incoming jump from 0x0087, if 0xc311c523 == stack[-1] 0FF9 5B JUMPDEST 0FFA 61 PUSH2 0x1001 0FFD 61 PUSH2 0x2284 1000 56 *JUMP // Stack delta = +1 // Outputs[1] { @0FFA stack[0] = 0x1001 } // Block ends with call to 0x2284, returns to 0x1001 label_1001: // Incoming return from call to 0x2284 at 0x1000 // Inputs[4] // { // @1004 memory[0x40:0x60] // @1006 stack[-1] // @1015 memory[0x40:0x60] // @101A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1001 5B JUMPDEST 1002 60 PUSH1 0x40 1004 51 MLOAD 1005 80 DUP1 1006 82 DUP3 1007 15 ISZERO 1008 15 ISZERO 1009 15 ISZERO 100A 15 ISZERO 100B 81 DUP2 100C 52 MSTORE 100D 60 PUSH1 0x20 100F 01 ADD 1010 91 SWAP2 1011 50 POP 1012 50 POP 1013 60 PUSH1 0x40 1015 51 MLOAD 1016 80 DUP1 1017 91 SWAP2 1018 03 SUB 1019 90 SWAP1 101A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @100C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @101A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_101B: // Incoming jump from 0x0092, if 0xcd7c0326 == stack[-1] 101B 5B JUMPDEST 101C 61 PUSH2 0x1023 101F 61 PUSH2 0x228d 1022 56 *JUMP // Stack delta = +1 // Outputs[1] { @101C stack[0] = 0x1023 } // Block ends with call to 0x228d, returns to 0x1023 label_1023: // Incoming return from call to 0x228D at 0x1022 // Inputs[4] // { // @1026 memory[0x40:0x60] // @1028 stack[-1] // @105F memory[0x40:0x60] // @1064 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1023 5B JUMPDEST 1024 60 PUSH1 0x40 1026 51 MLOAD 1027 80 DUP1 1028 82 DUP3 1029 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 103E 16 AND 103F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1054 16 AND 1055 81 DUP2 1056 52 MSTORE 1057 60 PUSH1 0x20 1059 01 ADD 105A 91 SWAP2 105B 50 POP 105C 50 POP 105D 60 PUSH1 0x40 105F 51 MLOAD 1060 80 DUP1 1061 91 SWAP2 1062 03 SUB 1063 90 SWAP1 1064 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @1056 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1064 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_1065: // Incoming jump from 0x009D, if 0xd26ea6c0 == stack[-1] // Inputs[1] { @106C msg.data.length } 1065 5B JUMPDEST 1066 61 PUSH2 0x10a7 1069 60 PUSH1 0x04 106B 80 DUP1 106C 36 CALLDATASIZE 106D 03 SUB 106E 60 PUSH1 0x20 1070 81 DUP2 1071 10 LT 1072 15 ISZERO 1073 61 PUSH2 0x107b 1076 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1066 stack[0] = 0x10a7 // @1069 stack[1] = 0x04 // @106D stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x107b, returns to 0x10A7, if !(msg.data.length - 0x04 < 0x20) label_1077: // Incoming jump from 0x1076, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @107A memory[0x00:0x00] } 1077 60 PUSH1 0x00 1079 80 DUP1 107A FD *REVERT // Stack delta = +0 // Outputs[1] { @107A revert(memory[0x00:0x00]); } // Block terminates label_107B: // Incoming call from 0x1076, returns to 0x10A7, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @107C stack[-2] // @107D stack[-1] // @1081 msg.data[stack[-2]:stack[-2] + 0x20] // } 107B 5B JUMPDEST 107C 81 DUP2 107D 01 ADD 107E 90 SWAP1 107F 80 DUP1 1080 80 DUP1 1081 35 CALLDATALOAD 1082 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1097 16 AND 1098 90 SWAP1 1099 60 PUSH1 0x20 109B 01 ADD 109C 90 SWAP1 109D 92 SWAP3 109E 91 SWAP2 109F 90 SWAP1 10A0 50 POP 10A1 50 POP 10A2 50 POP 10A3 61 PUSH2 0x22b3 10A6 56 *JUMP // Stack delta = -1 // Outputs[1] { @109D stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x22b3 label_10A7: // Incoming return from call to 0x107B at 0x1076 10A7 5B JUMPDEST 10A8 00 *STOP // Stack delta = +0 // Outputs[1] { @10A8 stop(); } // Block terminates label_10A9: // Incoming jump from 0x004B, if 0xe985e9c5 == stack[-1] // Inputs[1] { @10B0 msg.data.length } 10A9 5B JUMPDEST 10AA 61 PUSH2 0x110b 10AD 60 PUSH1 0x04 10AF 80 DUP1 10B0 36 CALLDATASIZE 10B1 03 SUB 10B2 60 PUSH1 0x40 10B4 81 DUP2 10B5 10 LT 10B6 15 ISZERO 10B7 61 PUSH2 0x10bf 10BA 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @10AA stack[0] = 0x110b // @10AD stack[1] = 0x04 // @10B1 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x10bf, returns to 0x110B, if !(msg.data.length - 0x04 < 0x40) label_10BB: // Incoming jump from 0x10BA, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @10BE memory[0x00:0x00] } 10BB 60 PUSH1 0x00 10BD 80 DUP1 10BE FD *REVERT // Stack delta = +0 // Outputs[1] { @10BE revert(memory[0x00:0x00]); } // Block terminates label_10BF: // Incoming call from 0x10BA, returns to 0x110B, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @10C0 stack[-2] // @10C1 stack[-1] // @10C5 msg.data[stack[-2]:stack[-2] + 0x20] // @10E5 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 10BF 5B JUMPDEST 10C0 81 DUP2 10C1 01 ADD 10C2 90 SWAP1 10C3 80 DUP1 10C4 80 DUP1 10C5 35 CALLDATALOAD 10C6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10DB 16 AND 10DC 90 SWAP1 10DD 60 PUSH1 0x20 10DF 01 ADD 10E0 90 SWAP1 10E1 92 SWAP3 10E2 91 SWAP2 10E3 90 SWAP1 10E4 80 DUP1 10E5 35 CALLDATALOAD 10E6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10FB 16 AND 10FC 90 SWAP1 10FD 60 PUSH1 0x20 10FF 01 ADD 1100 90 SWAP1 1101 92 SWAP3 1102 91 SWAP2 1103 90 SWAP1 1104 50 POP 1105 50 POP 1106 50 POP 1107 61 PUSH2 0x235c 110A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @10E1 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @1101 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x235c label_110B: // Incoming return from call to 0x10BF at 0x10BA // Inputs[4] // { // @110E memory[0x40:0x60] // @1110 stack[-1] // @111F memory[0x40:0x60] // @1124 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 110B 5B JUMPDEST 110C 60 PUSH1 0x40 110E 51 MLOAD 110F 80 DUP1 1110 82 DUP3 1111 15 ISZERO 1112 15 ISZERO 1113 15 ISZERO 1114 15 ISZERO 1115 81 DUP2 1116 52 MSTORE 1117 60 PUSH1 0x20 1119 01 ADD 111A 91 SWAP2 111B 50 POP 111C 50 POP 111D 60 PUSH1 0x40 111F 51 MLOAD 1120 80 DUP1 1121 91 SWAP2 1122 03 SUB 1123 90 SWAP1 1124 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @1116 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @1124 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_1125: // Incoming jump from 0x0056, if 0xf242432a == stack[-1] // Inputs[1] { @112C msg.data.length } 1125 5B JUMPDEST 1126 61 PUSH2 0x1232 1129 60 PUSH1 0x04 112B 80 DUP1 112C 36 CALLDATASIZE 112D 03 SUB 112E 60 PUSH1 0xa0 1130 81 DUP2 1131 10 LT 1132 15 ISZERO 1133 61 PUSH2 0x113b 1136 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1126 stack[0] = 0x1232 // @1129 stack[1] = 0x04 // @112D stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x113b, returns to 0x1232, if !(msg.data.length - 0x04 < 0xa0) label_1137: // Incoming jump from 0x1136, if not !(msg.data.length - 0x04 < 0xa0) // Inputs[1] { @113A memory[0x00:0x00] } 1137 60 PUSH1 0x00 1139 80 DUP1 113A FD *REVERT // Stack delta = +0 // Outputs[1] { @113A revert(memory[0x00:0x00]); } // Block terminates label_113B: // Incoming call from 0x1136, returns to 0x1232, if !(msg.data.length - 0x04 < 0xa0) // Inputs[7] // { // @113C stack[-2] // @113D stack[-1] // @1141 msg.data[stack[-2]:stack[-2] + 0x20] // @1161 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @1181 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // @118B msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] // @1195 msg.data[0x20 + 0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + 0x20 + stack[-2] + 0x20] // } 113B 5B JUMPDEST 113C 81 DUP2 113D 01 ADD 113E 90 SWAP1 113F 80 DUP1 1140 80 DUP1 1141 35 CALLDATALOAD 1142 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1157 16 AND 1158 90 SWAP1 1159 60 PUSH1 0x20 115B 01 ADD 115C 90 SWAP1 115D 92 SWAP3 115E 91 SWAP2 115F 90 SWAP1 1160 80 DUP1 1161 35 CALLDATALOAD 1162 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1177 16 AND 1178 90 SWAP1 1179 60 PUSH1 0x20 117B 01 ADD 117C 90 SWAP1 117D 92 SWAP3 117E 91 SWAP2 117F 90 SWAP1 1180 80 DUP1 1181 35 CALLDATALOAD 1182 90 SWAP1 1183 60 PUSH1 0x20 1185 01 ADD 1186 90 SWAP1 1187 92 SWAP3 1188 91 SWAP2 1189 90 SWAP1 118A 80 DUP1 118B 35 CALLDATALOAD 118C 90 SWAP1 118D 60 PUSH1 0x20 118F 01 ADD 1190 90 SWAP1 1191 92 SWAP3 1192 91 SWAP2 1193 90 SWAP1 1194 80 DUP1 1195 35 CALLDATALOAD 1196 90 SWAP1 1197 60 PUSH1 0x20 1199 01 ADD 119A 90 SWAP1 119B 64 PUSH5 0x0100000000 11A1 81 DUP2 11A2 11 GT 11A3 15 ISZERO 11A4 61 PUSH2 0x11ac 11A7 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @115D stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @117D stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @1187 stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // @1191 stack[1] = msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] // @1192 stack[2] = stack[-2] + stack[-1] // @1193 stack[3] = stack[-2] // @119A stack[4] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + stack[-2] // @119A stack[5] = msg.data[0x20 + 0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with conditional jump to 0x11ac, if !(msg.data[0x20 + 0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) label_11A8: // Incoming jump from 0x11A7, if not !(msg.data[0x20 + 0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @11AB memory[0x00:0x00] } 11A8 60 PUSH1 0x00 11AA 80 DUP1 11AB FD *REVERT // Stack delta = +0 // Outputs[1] { @11AB revert(memory[0x00:0x00]); } // Block terminates label_11AC: // Incoming jump from 0x11A7, if !(msg.data[0x20 + 0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @11AD stack[-3] // @11AE stack[-1] // @11AF stack[-4] // } 11AC 5B JUMPDEST 11AD 82 DUP3 11AE 01 ADD 11AF 83 DUP4 11B0 60 PUSH1 0x20 11B2 82 DUP3 11B3 01 ADD 11B4 11 GT 11B5 15 ISZERO 11B6 61 PUSH2 0x11be 11B9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @11AE stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x11be, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_11BA: // Incoming jump from 0x11B9, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @11BD memory[0x00:0x00] } 11BA 60 PUSH1 0x00 11BC 80 DUP1 11BD FD *REVERT // Stack delta = +0 // Outputs[1] { @11BD revert(memory[0x00:0x00]); } // Block terminates label_11BE: // Incoming jump from 0x11B9, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @11BF stack[-1] // @11C0 msg.data[stack[-1]:stack[-1] + 0x20] // @11C5 stack[-2] // @11C6 stack[-4] // } 11BE 5B JUMPDEST 11BF 80 DUP1 11C0 35 CALLDATALOAD 11C1 90 SWAP1 11C2 60 PUSH1 0x20 11C4 01 ADD 11C5 91 SWAP2 11C6 84 DUP5 11C7 60 PUSH1 0x01 11C9 83 DUP4 11CA 02 MUL 11CB 84 DUP5 11CC 01 ADD 11CD 11 GT 11CE 64 PUSH5 0x0100000000 11D4 83 DUP4 11D5 11 GT 11D6 17 OR 11D7 15 ISZERO 11D8 61 PUSH2 0x11e0 11DB 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @11C1 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @11C5 stack[0] = stack[-2] // @11C5 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x11e0, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_11DC: // Incoming jump from 0x11DB, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @11DF memory[0x00:0x00] } 11DC 60 PUSH1 0x00 11DE 80 DUP1 11DF FD *REVERT // Stack delta = +0 // Outputs[1] { @11DF revert(memory[0x00:0x00]); } // Block terminates label_11E0: // Incoming jump from 0x11DB, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @11E1 stack[-3] // @11E1 stack[-1] // @11E2 stack[-2] // @11F3 memory[0x40:0x60] // @120A msg.data[stack[-3]:stack[-3] + stack[-2]] // @1226 stack[-4] // @1227 stack[-5] // } 11E0 5B JUMPDEST 11E1 91 SWAP2 11E2 90 SWAP1 11E3 80 DUP1 11E4 80 DUP1 11E5 60 PUSH1 0x1f 11E7 01 ADD 11E8 60 PUSH1 0x20 11EA 80 DUP1 11EB 91 SWAP2 11EC 04 DIV 11ED 02 MUL 11EE 60 PUSH1 0x20 11F0 01 ADD 11F1 60 PUSH1 0x40 11F3 51 MLOAD 11F4 90 SWAP1 11F5 81 DUP2 11F6 01 ADD 11F7 60 PUSH1 0x40 11F9 52 MSTORE 11FA 80 DUP1 11FB 93 SWAP4 11FC 92 SWAP3 11FD 91 SWAP2 11FE 90 SWAP1 11FF 81 DUP2 1200 81 DUP2 1201 52 MSTORE 1202 60 PUSH1 0x20 1204 01 ADD 1205 83 DUP4 1206 83 DUP4 1207 80 DUP1 1208 82 DUP3 1209 84 DUP5 120A 37 CALLDATACOPY 120B 60 PUSH1 0x00 120D 81 DUP2 120E 84 DUP5 120F 01 ADD 1210 52 MSTORE 1211 60 PUSH1 0x1f 1213 19 NOT 1214 60 PUSH1 0x1f 1216 82 DUP3 1217 01 ADD 1218 16 AND 1219 90 SWAP1 121A 50 POP 121B 80 DUP1 121C 83 DUP4 121D 01 ADD 121E 92 SWAP3 121F 50 POP 1220 50 POP 1221 50 POP 1222 50 POP 1223 50 POP 1224 50 POP 1225 50 POP 1226 91 SWAP2 1227 92 SWAP3 1228 91 SWAP2 1229 92 SWAP3 122A 90 SWAP1 122B 50 POP 122C 50 POP 122D 50 POP 122E 61 PUSH2 0x2389 1231 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @11F9 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @1201 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @120A memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @1210 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @1229 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2389 label_1232: // Incoming return from call to 0x113B at 0x1136 // Incoming return from call to 0x113B at 0x1136 1232 5B JUMPDEST 1233 00 *STOP // Stack delta = +0 // Outputs[1] { @1233 stop(); } // Block terminates label_1234: // Incoming jump from 0x0061, if 0xf2fde38b == stack[-1] // Inputs[1] { @123B msg.data.length } 1234 5B JUMPDEST 1235 61 PUSH2 0x1276 1238 60 PUSH1 0x04 123A 80 DUP1 123B 36 CALLDATASIZE 123C 03 SUB 123D 60 PUSH1 0x20 123F 81 DUP2 1240 10 LT 1241 15 ISZERO 1242 61 PUSH2 0x124a 1245 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1235 stack[0] = 0x1276 // @1238 stack[1] = 0x04 // @123C stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x124a, returns to 0x1276, if !(msg.data.length - 0x04 < 0x20) label_1246: // Incoming jump from 0x1245, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @1249 memory[0x00:0x00] } 1246 60 PUSH1 0x00 1248 80 DUP1 1249 FD *REVERT // Stack delta = +0 // Outputs[1] { @1249 revert(memory[0x00:0x00]); } // Block terminates label_124A: // Incoming call from 0x1245, returns to 0x1276, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @124B stack[-2] // @124C stack[-1] // @1250 msg.data[stack[-2]:stack[-2] + 0x20] // } 124A 5B JUMPDEST 124B 81 DUP2 124C 01 ADD 124D 90 SWAP1 124E 80 DUP1 124F 80 DUP1 1250 35 CALLDATALOAD 1251 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1266 16 AND 1267 90 SWAP1 1268 60 PUSH1 0x20 126A 01 ADD 126B 90 SWAP1 126C 92 SWAP3 126D 91 SWAP2 126E 90 SWAP1 126F 50 POP 1270 50 POP 1271 50 POP 1272 61 PUSH2 0x23ef 1275 56 *JUMP // Stack delta = -1 // Outputs[1] { @126C stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x23ef label_1276: // Incoming return from call to 0x124A at 0x1245 1276 5B JUMPDEST 1277 00 *STOP // Stack delta = +0 // Outputs[1] { @1277 stop(); } // Block terminates label_1278: // Incoming jump from 0x006C, if 0xf923e8c3 == stack[-1] 1278 5B JUMPDEST 1279 61 PUSH2 0x1280 127C 61 PUSH2 0x2460 127F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1279 stack[0] = 0x1280 } // Block ends with call to 0x2460, returns to 0x1280 label_1280: // Incoming return from call to 0x2460 at 0x127F // Inputs[4] // { // @1283 memory[0x40:0x60] // @128E stack[-1] // @1291 memory[stack[-1]:stack[-1] + 0x20] // @129A memory[stack[-1]:stack[-1] + 0x20] // } 1280 5B JUMPDEST 1281 60 PUSH1 0x40 1283 51 MLOAD 1284 80 DUP1 1285 80 DUP1 1286 60 PUSH1 0x20 1288 01 ADD 1289 82 DUP3 128A 81 DUP2 128B 03 SUB 128C 82 DUP3 128D 52 MSTORE 128E 83 DUP4 128F 81 DUP2 1290 81 DUP2 1291 51 MLOAD 1292 81 DUP2 1293 52 MSTORE 1294 60 PUSH1 0x20 1296 01 ADD 1297 91 SWAP2 1298 50 POP 1299 80 DUP1 129A 51 MLOAD 129B 90 SWAP1 129C 60 PUSH1 0x20 129E 01 ADD 129F 90 SWAP1 12A0 80 DUP1 12A1 83 DUP4 12A2 83 DUP4 12A3 60 PUSH1 0x00 12A5 5B JUMPDEST 12A6 83 DUP4 12A7 81 DUP2 12A8 10 LT 12A9 15 ISZERO 12AA 61 PUSH2 0x12c0 12AD 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @1283 stack[0] = memory[0x40:0x60] // @1284 stack[1] = memory[0x40:0x60] // @128D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @1293 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1297 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @129F stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @129F stack[3] = 0x20 + stack[-1] // @12A0 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @12A1 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @12A2 stack[7] = 0x20 + stack[-1] // @12A3 stack[8] = 0x00 // } // Block ends with conditional jump to 0x12c0, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_12AE: // Incoming jump from 0x12AD, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x12AD, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @12AE stack[-1] // @12AF stack[-2] // @12B1 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @12B3 stack[-3] // } 12AE 80 DUP1 12AF 82 DUP3 12B0 01 ADD 12B1 51 MLOAD 12B2 81 DUP2 12B3 84 DUP5 12B4 01 ADD 12B5 52 MSTORE 12B6 60 PUSH1 0x20 12B8 81 DUP2 12B9 01 ADD 12BA 90 SWAP1 12BB 50 POP 12BC 61 PUSH2 0x12a5 12BF 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @12B5 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @12BA stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x12a5 label_12C0: // Incoming jump from 0x12AD, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x12AD, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @12C5 stack[-6] // @12C5 stack[-5] // @12C7 stack[-7] // } 12C0 5B JUMPDEST 12C1 50 POP 12C2 50 POP 12C3 50 POP 12C4 50 POP 12C5 90 SWAP1 12C6 50 POP 12C7 90 SWAP1 12C8 81 DUP2 12C9 01 ADD 12CA 90 SWAP1 12CB 60 PUSH1 0x1f 12CD 16 AND 12CE 80 DUP1 12CF 15 ISZERO 12D0 61 PUSH2 0x12ed 12D3 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @12CA stack[-7] = stack[-5] + stack[-7] // @12CD stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x12ed, if !(0x1f & stack[-5]) label_12D4: // Incoming jump from 0x12D3, if not !(0x1f & stack[-5]) // Inputs[6] // { // @12D4 stack[-1] // @12D5 stack[-2] // @12D8 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @12EF stack[-5] // @12F5 memory[0x40:0x60] // @12FA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 12D4 80 DUP1 12D5 82 DUP3 12D6 03 SUB 12D7 80 DUP1 12D8 51 MLOAD 12D9 60 PUSH1 0x01 12DB 83 DUP4 12DC 60 PUSH1 0x20 12DE 03 SUB 12DF 61 PUSH2 0x0100 12E2 0A EXP 12E3 03 SUB 12E4 19 NOT 12E5 16 AND 12E6 81 DUP2 12E7 52 MSTORE 12E8 60 PUSH1 0x20 12EA 01 ADD 12EB 91 SWAP2 12EC 50 POP 12ED 5B JUMPDEST 12EE 50 POP 12EF 92 SWAP3 12F0 50 POP 12F1 50 POP 12F2 50 POP 12F3 60 PUSH1 0x40 12F5 51 MLOAD 12F6 80 DUP1 12F7 91 SWAP2 12F8 03 SUB 12F9 90 SWAP1 12FA F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @12E7 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @12FA return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_12FB: // Incoming jump from 0x0229 // Inputs[2] // { // @1302 stack[-2] // @1303 stack[-1] // } 12FB 5B JUMPDEST 12FC 60 PUSH1 0x00 12FE 80 DUP1 12FF 61 PUSH2 0x1308 1302 84 DUP5 1303 84 DUP5 1304 61 PUSH2 0x24fe 1307 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @12FC stack[0] = 0x00 // @12FE stack[1] = 0x00 // @12FF stack[2] = 0x1308 // @1302 stack[3] = stack[-2] // @1303 stack[4] = stack[-1] // } // Block ends with call to 0x24fe, returns to 0x1308 label_1308: // Incoming return from call to 0x24FE at 0x1307 // Inputs[4] // { // @1309 stack[-2] // @1309 stack[-1] // @130E stack[-4] // @130F stack[-5] // } 1308 5B JUMPDEST 1309 90 SWAP1 130A 50 POP 130B 61 PUSH2 0x1314 130E 83 DUP4 130F 85 DUP6 1310 61 PUSH2 0x2558 1313 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1309 stack[-2] = stack[-1] // @130B stack[-1] = 0x1314 // @130E stack[0] = stack[-4] // @130F stack[1] = stack[-5] // } // Block ends with call to 0x2558, returns to 0x1314 label_1314: // Incoming return from call to 0x2558 at 0x1313 // Inputs[1] { @1318 stack[-1] } 1314 5B JUMPDEST 1315 61 PUSH2 0x131e 1318 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x131e, if stack[-1] label_1319: // Incoming jump from 0x1318, if not stack[-1] // Inputs[1] { @1319 stack[-1] } 1319 80 DUP1 131A 61 PUSH2 0x133a 131D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1319 stack[0] = stack[-1] } // Block ends with unconditional jump to 0x133a label_131E: // Incoming jump from 0x1318, if stack[-1] // Inputs[1] { @1325 stack[-3] } 131E 5B JUMPDEST 131F 61 PUSH2 0x1339 1322 61 PUSH2 0x132a 1325 84 DUP5 1326 61 PUSH2 0x26c4 1329 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @131F stack[0] = 0x1339 // @1322 stack[1] = 0x132a // @1325 stack[2] = stack[-3] // } // Block ends with call to 0x26c4, returns to 0x132A label_132A: // Incoming return from call to 0x26C4 at 0x1329 // Inputs[2] // { // @132B stack[-3] // @1330 stack[-1] // } 132A 5B JUMPDEST 132B 82 DUP3 132C 61 PUSH2 0x26f0 132F 90 SWAP1 1330 91 SWAP2 1331 90 SWAP1 1332 63 PUSH4 0xffffffff 1337 16 AND 1338 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1330 stack[-1] = stack[-3] // @1331 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0xffffffff & 0x26f0 label_1339: // Incoming return from call to 0x132A at 0x1329 1339 5B JUMPDEST // Stack delta = +0 // Block continues label_133A: // Incoming jump from 0x1339 // Incoming jump from 0x131D // Inputs[4] // { // @133B stack[-3] // @133B stack[-1] // @133E stack[-6] // @133F stack[-5] // } 133A 5B JUMPDEST 133B 91 SWAP2 133C 50 POP 133D 50 POP 133E 92 SWAP3 133F 91 SWAP2 1340 50 POP 1341 50 POP 1342 56 *JUMP // Stack delta = -5 // Outputs[1] { @133E stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1343: // Incoming jump from 0x028A // Inputs[1] { @136D stack[-1] } 1343 5B JUMPDEST 1344 60 PUSH1 0x00 1346 63 PUSH4 0x01ffc9a7 134B 60 PUSH1 0xe0 134D 1B SHL 134E 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 136B 19 NOT 136C 16 AND 136D 82 DUP3 136E 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 138B 19 NOT 138C 16 AND 138D 14 EQ 138E 80 DUP1 138F 61 PUSH2 0x13dc 1392 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1344 stack[0] = 0x00 // @138D stack[1] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x01ffc9a7 << 0xe0) // } // Block ends with conditional jump to 0x13dc, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x01ffc9a7 << 0xe0) label_1393: // Incoming jump from 0x1392, if not ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x01ffc9a7 << 0xe0) // Inputs[1] { @13BB stack[-3] } 1393 50 POP 1394 63 PUSH4 0xd9b67a26 1399 60 PUSH1 0xe0 139B 1B SHL 139C 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 13B9 19 NOT 13BA 16 AND 13BB 82 DUP3 13BC 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 13D9 19 NOT 13DA 16 AND 13DB 14 EQ 13DC 5B JUMPDEST 13DD 15 ISZERO 13DE 61 PUSH2 0x13ea 13E1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x13ea, if !(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xd9b67a26 << 0xe0)) label_13E2: // Incoming jump from 0x13E1, if not !stack[-1] // Incoming jump from 0x13E1, if not !(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xd9b67a26 << 0xe0)) // Inputs[1] { @13E4 stack[-1] } 13E2 60 PUSH1 0x01 13E4 90 SWAP1 13E5 50 POP 13E6 61 PUSH2 0x13ef 13E9 56 *JUMP // Stack delta = +0 // Outputs[1] { @13E4 stack[-1] = 0x01 } // Block ends with unconditional jump to 0x13ef label_13EA: // Incoming jump from 0x13E1, if !stack[-1] // Incoming jump from 0x13E1, if !(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xd9b67a26 << 0xe0)) // Inputs[3] // { // @13ED stack[-1] // @13F0 stack[-3] // @13F1 stack[-2] // } 13EA 5B JUMPDEST 13EB 60 PUSH1 0x00 13ED 90 SWAP1 13EE 50 POP 13EF 5B JUMPDEST 13F0 91 SWAP2 13F1 90 SWAP1 13F2 50 POP 13F3 56 *JUMP // Stack delta = -2 // Outputs[1] { @13F0 stack[-3] = 0x00 } // Block ends with unconditional jump to stack[-3] label_13F4: // Incoming call from 0x02AC, returns to 0x02AD // Inputs[3] // { // @13F8 storage[0x04] // @1419 memory[0x40:0x60] // @142C storage[0x04] // } 13F4 5B JUMPDEST 13F5 60 PUSH1 0x04 13F7 80 DUP1 13F8 54 SLOAD 13F9 60 PUSH1 0x01 13FB 81 DUP2 13FC 60 PUSH1 0x01 13FE 16 AND 13FF 15 ISZERO 1400 61 PUSH2 0x0100 1403 02 MUL 1404 03 SUB 1405 16 AND 1406 60 PUSH1 0x02 1408 90 SWAP1 1409 04 DIV 140A 80 DUP1 140B 60 PUSH1 0x1f 140D 01 ADD 140E 60 PUSH1 0x20 1410 80 DUP1 1411 91 SWAP2 1412 04 DIV 1413 02 MUL 1414 60 PUSH1 0x20 1416 01 ADD 1417 60 PUSH1 0x40 1419 51 MLOAD 141A 90 SWAP1 141B 81 DUP2 141C 01 ADD 141D 60 PUSH1 0x40 141F 52 MSTORE 1420 80 DUP1 1421 92 SWAP3 1422 91 SWAP2 1423 90 SWAP1 1424 81 DUP2 1425 81 DUP2 1426 52 MSTORE 1427 60 PUSH1 0x20 1429 01 ADD 142A 82 DUP3 142B 80 DUP1 142C 54 SLOAD 142D 60 PUSH1 0x01 142F 81 DUP2 1430 60 PUSH1 0x01 1432 16 AND 1433 15 ISZERO 1434 61 PUSH2 0x0100 1437 02 MUL 1438 03 SUB 1439 16 AND 143A 60 PUSH1 0x02 143C 90 SWAP1 143D 04 DIV 143E 80 DUP1 143F 15 ISZERO 1440 61 PUSH2 0x148a 1443 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @141F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x04]) - 0x01 & storage[0x04]) / 0x02) / 0x20 * 0x20 // @1421 stack[0] = memory[0x40:0x60] // @1422 stack[1] = 0x04 // @1423 stack[2] = (0x0100 * !(0x01 & storage[0x04]) - 0x01 & storage[0x04]) / 0x02 // @1426 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x04]) - 0x01 & storage[0x04]) / 0x02 // @1429 stack[3] = 0x20 + memory[0x40:0x60] // @142A stack[4] = 0x04 // @143D stack[5] = (0x0100 * !(0x01 & storage[0x04]) - 0x01 & storage[0x04]) / 0x02 // } // Block ends with conditional jump to 0x148a, if !((0x0100 * !(0x01 & storage[0x04]) - 0x01 & storage[0x04]) / 0x02) label_1444: // Incoming jump from 0x1443, if not !((0x0100 * !(0x01 & storage[0x04]) - 0x01 & storage[0x04]) / 0x02) // Inputs[1] { @1444 stack[-1] } 1444 80 DUP1 1445 60 PUSH1 0x1f 1447 10 LT 1448 61 PUSH2 0x145f 144B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x145f, if 0x1f < stack[-1] label_144C: // Incoming jump from 0x144B, if not 0x1f < stack[-1] // Inputs[4] // { // @1450 stack[-2] // @1451 storage[stack[-2]] // @1454 stack[-3] // @1456 stack[-1] // } 144C 61 PUSH2 0x0100 144F 80 DUP1 1450 83 DUP4 1451 54 SLOAD 1452 04 DIV 1453 02 MUL 1454 83 DUP4 1455 52 MSTORE 1456 91 SWAP2 1457 60 PUSH1 0x20 1459 01 ADD 145A 91 SWAP2 145B 61 PUSH2 0x148a 145E 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1455 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @145A stack[-1] = stack[-1] // @145A stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x148a label_145F: // Incoming jump from 0x144B, if 0x1f < stack[-1] // Inputs[5] // { // @1460 stack[-3] // @1461 stack[-1] // @1463 stack[-2] // @146B memory[0x00:0x20] // @146F storage[keccak256(memory[0x00:0x20])] // } 145F 5B JUMPDEST 1460 82 DUP3 1461 01 ADD 1462 91 SWAP2 1463 90 SWAP1 1464 60 PUSH1 0x00 1466 52 MSTORE 1467 60 PUSH1 0x20 1469 60 PUSH1 0x00 146B 20 SHA3 146C 90 SWAP1 146D 5B JUMPDEST 146E 81 DUP2 146F 54 SLOAD 1470 81 DUP2 1471 52 MSTORE 1472 90 SWAP1 1473 60 PUSH1 0x01 1475 01 ADD 1476 90 SWAP1 1477 60 PUSH1 0x20 1479 01 ADD 147A 80 DUP1 147B 83 DUP4 147C 11 GT 147D 61 PUSH2 0x146d 1480 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1462 stack[-3] = stack[-3] + stack[-1] // @1466 memory[0x00:0x20] = stack[-2] // @1471 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1476 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1479 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x146d, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1481: // Incoming jump from 0x1480, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1480, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1481 stack[-3] // @1482 stack[-1] // } 1481 82 DUP3 1482 90 SWAP1 1483 03 SUB 1484 60 PUSH1 0x1f 1486 16 AND 1487 82 DUP3 1488 01 ADD 1489 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1489 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1489 stack[-1] = stack[-3] // } // Block continues label_148A: // Incoming jump from 0x1443, if !((0x0100 * !(0x01 & storage[0x04]) - 0x01 & storage[0x04]) / 0x02) // Incoming jump from 0x145E // Incoming jump from 0x1489 // Inputs[1] { @1490 stack[-7] } 148A 5B JUMPDEST 148B 50 POP 148C 50 POP 148D 50 POP 148E 50 POP 148F 50 POP 1490 81 DUP2 1491 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_1492: // Incoming jump from 0x0353 // Inputs[5] // { // @149A stack[-1] // @14A8 memory[0x00:0x40] // @14AA storage[keccak256(memory[0x00:0x40])] // @14CB memory[0x40:0x60] // @14DE storage[keccak256(memory[0x00:0x40])] // } 1492 5B JUMPDEST 1493 60 PUSH1 0x60 1495 80 DUP1 1496 60 PUSH1 0x08 1498 60 PUSH1 0x00 149A 84 DUP5 149B 81 DUP2 149C 52 MSTORE 149D 60 PUSH1 0x20 149F 01 ADD 14A0 90 SWAP1 14A1 81 DUP2 14A2 52 MSTORE 14A3 60 PUSH1 0x20 14A5 01 ADD 14A6 60 PUSH1 0x00 14A8 20 SHA3 14A9 80 DUP1 14AA 54 SLOAD 14AB 60 PUSH1 0x01 14AD 81 DUP2 14AE 60 PUSH1 0x01 14B0 16 AND 14B1 15 ISZERO 14B2 61 PUSH2 0x0100 14B5 02 MUL 14B6 03 SUB 14B7 16 AND 14B8 60 PUSH1 0x02 14BA 90 SWAP1 14BB 04 DIV 14BC 80 DUP1 14BD 60 PUSH1 0x1f 14BF 01 ADD 14C0 60 PUSH1 0x20 14C2 80 DUP1 14C3 91 SWAP2 14C4 04 DIV 14C5 02 MUL 14C6 60 PUSH1 0x20 14C8 01 ADD 14C9 60 PUSH1 0x40 14CB 51 MLOAD 14CC 90 SWAP1 14CD 81 DUP2 14CE 01 ADD 14CF 60 PUSH1 0x40 14D1 52 MSTORE 14D2 80 DUP1 14D3 92 SWAP3 14D4 91 SWAP2 14D5 90 SWAP1 14D6 81 DUP2 14D7 81 DUP2 14D8 52 MSTORE 14D9 60 PUSH1 0x20 14DB 01 ADD 14DC 82 DUP3 14DD 80 DUP1 14DE 54 SLOAD 14DF 60 PUSH1 0x01 14E1 81 DUP2 14E2 60 PUSH1 0x01 14E4 16 AND 14E5 15 ISZERO 14E6 61 PUSH2 0x0100 14E9 02 MUL 14EA 03 SUB 14EB 16 AND 14EC 60 PUSH1 0x02 14EE 90 SWAP1 14EF 04 DIV 14F0 80 DUP1 14F1 15 ISZERO 14F2 61 PUSH2 0x153c 14F5 57 *JUMPI // Stack delta = +8 // Outputs[12] // { // @1493 stack[0] = 0x60 // @1495 stack[1] = 0x60 // @149C memory[0x00:0x20] = stack[-1] // @14A2 memory[0x20:0x40] = 0x08 // @14D1 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) / 0x20 * 0x20 // @14D3 stack[2] = memory[0x40:0x60] // @14D4 stack[3] = keccak256(memory[0x00:0x40]) // @14D5 stack[4] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @14D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @14DB stack[5] = 0x20 + memory[0x40:0x60] // @14DC stack[6] = keccak256(memory[0x00:0x40]) // @14EF stack[7] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // } // Block ends with conditional jump to 0x153c, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) label_14F6: // Incoming jump from 0x14F5, if not !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @14F6 stack[-1] } 14F6 80 DUP1 14F7 60 PUSH1 0x1f 14F9 10 LT 14FA 61 PUSH2 0x1511 14FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1511, if 0x1f < stack[-1] label_14FE: // Incoming jump from 0x14FD, if not 0x1f < stack[-1] // Inputs[4] // { // @1502 stack[-2] // @1503 storage[stack[-2]] // @1506 stack[-3] // @1508 stack[-1] // } 14FE 61 PUSH2 0x0100 1501 80 DUP1 1502 83 DUP4 1503 54 SLOAD 1504 04 DIV 1505 02 MUL 1506 83 DUP4 1507 52 MSTORE 1508 91 SWAP2 1509 60 PUSH1 0x20 150B 01 ADD 150C 91 SWAP2 150D 61 PUSH2 0x153c 1510 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1507 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @150C stack[-1] = stack[-1] // @150C stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x153c label_1511: // Incoming jump from 0x14FD, if 0x1f < stack[-1] // Inputs[5] // { // @1512 stack[-3] // @1513 stack[-1] // @1515 stack[-2] // @151D memory[0x00:0x20] // @1521 storage[keccak256(memory[0x00:0x20])] // } 1511 5B JUMPDEST 1512 82 DUP3 1513 01 ADD 1514 91 SWAP2 1515 90 SWAP1 1516 60 PUSH1 0x00 1518 52 MSTORE 1519 60 PUSH1 0x20 151B 60 PUSH1 0x00 151D 20 SHA3 151E 90 SWAP1 151F 5B JUMPDEST 1520 81 DUP2 1521 54 SLOAD 1522 81 DUP2 1523 52 MSTORE 1524 90 SWAP1 1525 60 PUSH1 0x01 1527 01 ADD 1528 90 SWAP1 1529 60 PUSH1 0x20 152B 01 ADD 152C 80 DUP1 152D 83 DUP4 152E 11 GT 152F 61 PUSH2 0x151f 1532 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1514 stack[-3] = stack[-3] + stack[-1] // @1518 memory[0x00:0x20] = stack[-2] // @1523 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1528 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @152B stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x151f, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1533: // Incoming jump from 0x1532, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1532, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1533 stack[-3] // @1534 stack[-1] // } 1533 82 DUP3 1534 90 SWAP1 1535 03 SUB 1536 60 PUSH1 0x1f 1538 16 AND 1539 82 DUP3 153A 01 ADD 153B 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @153B stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @153B stack[-1] = stack[-3] // } // Block continues label_153C: // Incoming jump from 0x153B // Incoming jump from 0x14F5, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Incoming jump from 0x1510 // Inputs[3] // { // @1542 stack[-7] // @1542 stack[-6] // @1547 memory[stack[-6]:stack[-6] + 0x20] // } 153C 5B JUMPDEST 153D 50 POP 153E 50 POP 153F 50 POP 1540 50 POP 1541 50 POP 1542 90 SWAP1 1543 50 POP 1544 60 PUSH1 0x00 1546 81 DUP2 1547 51 MLOAD 1548 14 EQ 1549 61 PUSH2 0x1555 154C 57 *JUMPI // Stack delta = -6 // Outputs[1] { @1542 stack[-7] = stack[-6] } // Block ends with conditional jump to 0x1555, if memory[stack[-6]:stack[-6] + 0x20] == 0x00 label_154D: // Incoming jump from 0x154C, if not memory[stack[-6]:stack[-6] + 0x20] == 0x00 // Inputs[2] // { // @154D stack[-1] // @154E stack[-2] // } 154D 80 DUP1 154E 91 SWAP2 154F 50 POP 1550 50 POP 1551 61 PUSH2 0x15f4 1554 56 *JUMP // Stack delta = -1 // Outputs[1] { @154E stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x15f4 label_1555: // Incoming jump from 0x154C, if memory[stack[-6]:stack[-6] + 0x20] == 0x00 // Inputs[3] // { // @1559 storage[0x07] // @157A memory[0x40:0x60] // @158D storage[0x07] // } 1555 5B JUMPDEST 1556 60 PUSH1 0x07 1558 80 DUP1 1559 54 SLOAD 155A 60 PUSH1 0x01 155C 81 DUP2 155D 60 PUSH1 0x01 155F 16 AND 1560 15 ISZERO 1561 61 PUSH2 0x0100 1564 02 MUL 1565 03 SUB 1566 16 AND 1567 60 PUSH1 0x02 1569 90 SWAP1 156A 04 DIV 156B 80 DUP1 156C 60 PUSH1 0x1f 156E 01 ADD 156F 60 PUSH1 0x20 1571 80 DUP1 1572 91 SWAP2 1573 04 DIV 1574 02 MUL 1575 60 PUSH1 0x20 1577 01 ADD 1578 60 PUSH1 0x40 157A 51 MLOAD 157B 90 SWAP1 157C 81 DUP2 157D 01 ADD 157E 60 PUSH1 0x40 1580 52 MSTORE 1581 80 DUP1 1582 92 SWAP3 1583 91 SWAP2 1584 90 SWAP1 1585 81 DUP2 1586 81 DUP2 1587 52 MSTORE 1588 60 PUSH1 0x20 158A 01 ADD 158B 82 DUP3 158C 80 DUP1 158D 54 SLOAD 158E 60 PUSH1 0x01 1590 81 DUP2 1591 60 PUSH1 0x01 1593 16 AND 1594 15 ISZERO 1595 61 PUSH2 0x0100 1598 02 MUL 1599 03 SUB 159A 16 AND 159B 60 PUSH1 0x02 159D 90 SWAP1 159E 04 DIV 159F 80 DUP1 15A0 15 ISZERO 15A1 61 PUSH2 0x15eb 15A4 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @1580 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) / 0x20 * 0x20 // @1582 stack[0] = memory[0x40:0x60] // @1583 stack[1] = 0x07 // @1584 stack[2] = (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02 // @1587 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02 // @158A stack[3] = 0x20 + memory[0x40:0x60] // @158B stack[4] = 0x07 // @159E stack[5] = (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02 // } // Block ends with conditional jump to 0x15eb, if !((0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) label_15A5: // Incoming jump from 0x15A4, if not !((0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) // Inputs[1] { @15A5 stack[-1] } 15A5 80 DUP1 15A6 60 PUSH1 0x1f 15A8 10 LT 15A9 61 PUSH2 0x15c0 15AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15c0, if 0x1f < stack[-1] label_15AD: // Incoming jump from 0x15AC, if not 0x1f < stack[-1] // Inputs[4] // { // @15B1 stack[-2] // @15B2 storage[stack[-2]] // @15B5 stack[-3] // @15B7 stack[-1] // } 15AD 61 PUSH2 0x0100 15B0 80 DUP1 15B1 83 DUP4 15B2 54 SLOAD 15B3 04 DIV 15B4 02 MUL 15B5 83 DUP4 15B6 52 MSTORE 15B7 91 SWAP2 15B8 60 PUSH1 0x20 15BA 01 ADD 15BB 91 SWAP2 15BC 61 PUSH2 0x15eb 15BF 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @15B6 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @15BB stack[-1] = stack[-1] // @15BB stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x15eb label_15C0: // Incoming jump from 0x15AC, if 0x1f < stack[-1] // Inputs[5] // { // @15C1 stack[-3] // @15C2 stack[-1] // @15C4 stack[-2] // @15CC memory[0x00:0x20] // @15D0 storage[keccak256(memory[0x00:0x20])] // } 15C0 5B JUMPDEST 15C1 82 DUP3 15C2 01 ADD 15C3 91 SWAP2 15C4 90 SWAP1 15C5 60 PUSH1 0x00 15C7 52 MSTORE 15C8 60 PUSH1 0x20 15CA 60 PUSH1 0x00 15CC 20 SHA3 15CD 90 SWAP1 15CE 5B JUMPDEST 15CF 81 DUP2 15D0 54 SLOAD 15D1 81 DUP2 15D2 52 MSTORE 15D3 90 SWAP1 15D4 60 PUSH1 0x01 15D6 01 ADD 15D7 90 SWAP1 15D8 60 PUSH1 0x20 15DA 01 ADD 15DB 80 DUP1 15DC 83 DUP4 15DD 11 GT 15DE 61 PUSH2 0x15ce 15E1 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @15C3 stack[-3] = stack[-3] + stack[-1] // @15C7 memory[0x00:0x20] = stack[-2] // @15D2 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @15D7 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @15DA stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x15ce, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_15E2: // Incoming jump from 0x15E1, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x15E1, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @15E2 stack[-3] // @15E3 stack[-1] // } 15E2 82 DUP3 15E3 90 SWAP1 15E4 03 SUB 15E5 60 PUSH1 0x1f 15E7 16 AND 15E8 82 DUP3 15E9 01 ADD 15EA 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @15EA stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @15EA stack[-1] = stack[-3] // } // Block continues label_15EB: // Incoming jump from 0x15A4, if !((0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) // Incoming jump from 0x15EA // Incoming jump from 0x15BF // Inputs[4] // { // @15F1 stack[-6] // @15F1 stack[-8] // @15F5 stack[-10] // @15F6 stack[-9] // } 15EB 5B JUMPDEST 15EC 50 POP 15ED 50 POP 15EE 50 POP 15EF 50 POP 15F0 50 POP 15F1 91 SWAP2 15F2 50 POP 15F3 50 POP 15F4 5B JUMPDEST 15F5 91 SWAP2 15F6 90 SWAP1 15F7 50 POP 15F8 56 *JUMP // Stack delta = -9 // Outputs[1] { @15F5 stack[-10] = stack[-6] } // Block ends with unconditional jump to stack[-10] label_15F9: // Incoming jump from 0x0487 15F9 5B JUMPDEST 15FA 61 PUSH2 0x1609 15FD 61 PUSH2 0x1604 1600 61 PUSH2 0x2778 1603 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @15FA stack[0] = 0x1609 // @15FD stack[1] = 0x1604 // } // Block ends with call to 0x2778, returns to 0x1604 label_1604: // Incoming return from call to 0x2778 at 0x1603 1604 5B JUMPDEST 1605 61 PUSH2 0x2780 1608 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2780 label_1609: // Incoming return from call to 0x1604 at 0x1603 // Inputs[1] { @160D stack[-1] } 1609 5B JUMPDEST 160A 61 PUSH2 0x165e 160D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x165e, if stack[-1] label_160E: // Incoming jump from 0x160D, if not stack[-1] // Inputs[3] // { // @1610 memory[0x40:0x60] // @1658 memory[0x40:0x60] // @165D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 160E 60 PUSH1 0x40 1610 51 MLOAD 1611 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1632 81 DUP2 1633 52 MSTORE 1634 60 PUSH1 0x04 1636 01 ADD 1637 80 DUP1 1638 80 DUP1 1639 60 PUSH1 0x20 163B 01 ADD 163C 82 DUP3 163D 81 DUP2 163E 03 SUB 163F 82 DUP3 1640 52 MSTORE 1641 60 PUSH1 0x2e 1643 81 DUP2 1644 52 MSTORE 1645 60 PUSH1 0x20 1647 01 ADD 1648 80 DUP1 1649 61 PUSH2 0x40f5 164C 60 PUSH1 0x2e 164E 91 SWAP2 164F 39 CODECOPY 1650 60 PUSH1 0x40 1652 01 ADD 1653 91 SWAP2 1654 50 POP 1655 50 POP 1656 60 PUSH1 0x40 1658 51 MLOAD 1659 80 DUP1 165A 91 SWAP2 165B 03 SUB 165C 90 SWAP1 165D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1633 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1640 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1644 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @164F memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x40f5:0x4123] // @165D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_165E: // Incoming jump from 0x160D, if stack[-1] // Inputs[2] // { // @165F stack[-1] // @1664 memory[stack[-1]:stack[-1] + 0x20] // } 165E 5B JUMPDEST 165F 80 DUP1 1660 60 PUSH1 0x07 1662 90 SWAP1 1663 80 DUP1 1664 51 MLOAD 1665 90 SWAP1 1666 60 PUSH1 0x20 1668 01 ADD 1669 90 SWAP1 166A 61 PUSH2 0x1674 166D 92 SWAP3 166E 91 SWAP2 166F 90 SWAP1 1670 61 PUSH2 0x3efe 1673 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @166D stack[0] = 0x1674 // @166E stack[1] = 0x07 // @166F stack[2] = 0x20 + stack[-1] // @166F stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x3efe, returns to 0x1674 label_1674: // Incoming return from call to 0x3EFE at 0x1673 // Inputs[1] { @1677 stack[-3] } 1674 5B JUMPDEST 1675 50 POP 1676 50 POP 1677 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1678: // Incoming jump from 0x06AA // Inputs[2] // { // @1679 stack[-5] // @1690 msg.sender // } 1678 5B JUMPDEST 1679 84 DUP5 167A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 168F 16 AND 1690 33 CALLER 1691 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16A6 16 AND 16A7 14 EQ 16A8 80 DUP1 16A9 61 PUSH2 0x16b8 16AC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @16A7 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] } // Block ends with conditional jump to 0x16b8, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] label_16AD: // Incoming jump from 0x16AC, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // Inputs[2] // { // @16B1 stack[-6] // @16B2 msg.sender // } 16AD 50 POP 16AE 61 PUSH2 0x16b7 16B1 85 DUP6 16B2 33 CALLER 16B3 61 PUSH2 0x235c 16B6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @16AE stack[-1] = 0x16b7 // @16B1 stack[0] = stack[-6] // @16B2 stack[1] = msg.sender // } // Block ends with call to 0x235c, returns to 0x16B7 label_16B7: // Incoming return from call to 0x235C at 0x16B6 16B7 5B JUMPDEST // Stack delta = +0 // Block continues label_16B8: // Incoming jump from 0x16B7 // Incoming jump from 0x16AC, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // Inputs[1] { @16BC stack[-1] } 16B8 5B JUMPDEST 16B9 61 PUSH2 0x170d 16BC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x170d, if stack[-1] label_16BD: // Incoming jump from 0x16BC, if not stack[-1] // Inputs[3] // { // @16BF memory[0x40:0x60] // @1707 memory[0x40:0x60] // @170C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 16BD 60 PUSH1 0x40 16BF 51 MLOAD 16C0 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 16E1 81 DUP2 16E2 52 MSTORE 16E3 60 PUSH1 0x04 16E5 01 ADD 16E6 80 DUP1 16E7 80 DUP1 16E8 60 PUSH1 0x20 16EA 01 ADD 16EB 82 DUP3 16EC 81 DUP2 16ED 03 SUB 16EE 82 DUP3 16EF 52 MSTORE 16F0 60 PUSH1 0x2f 16F2 81 DUP2 16F3 52 MSTORE 16F4 60 PUSH1 0x20 16F6 01 ADD 16F7 80 DUP1 16F8 61 PUSH2 0x41e4 16FB 60 PUSH1 0x2f 16FD 91 SWAP2 16FE 39 CODECOPY 16FF 60 PUSH1 0x40 1701 01 ADD 1702 91 SWAP2 1703 50 POP 1704 50 POP 1705 60 PUSH1 0x40 1707 51 MLOAD 1708 80 DUP1 1709 91 SWAP2 170A 03 SUB 170B 90 SWAP1 170C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @16E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @16EF memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @16F3 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2f // @16FE memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2f] = code[0x41e4:0x4213] // @170C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_170D: // Incoming jump from 0x16BC, if stack[-1] // Inputs[1] { @1726 stack[-4] } 170D 5B JUMPDEST 170E 60 PUSH1 0x00 1710 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1725 16 AND 1726 84 DUP5 1727 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 173C 16 AND 173D 14 EQ 173E 15 ISZERO 173F 61 PUSH2 0x1793 1742 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1793, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1743: // Incoming jump from 0x1742, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1745 memory[0x40:0x60] // @178D memory[0x40:0x60] // @1792 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1743 60 PUSH1 0x40 1745 51 MLOAD 1746 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1767 81 DUP2 1768 52 MSTORE 1769 60 PUSH1 0x04 176B 01 ADD 176C 80 DUP1 176D 80 DUP1 176E 60 PUSH1 0x20 1770 01 ADD 1771 82 DUP3 1772 81 DUP2 1773 03 SUB 1774 82 DUP3 1775 52 MSTORE 1776 60 PUSH1 0x30 1778 81 DUP2 1779 52 MSTORE 177A 60 PUSH1 0x20 177C 01 ADD 177D 80 DUP1 177E 61 PUSH2 0x4188 1781 60 PUSH1 0x30 1783 91 SWAP2 1784 39 CODECOPY 1785 60 PUSH1 0x40 1787 01 ADD 1788 91 SWAP2 1789 50 POP 178A 50 POP 178B 60 PUSH1 0x40 178D 51 MLOAD 178E 80 DUP1 178F 91 SWAP2 1790 03 SUB 1791 90 SWAP1 1792 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1768 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1775 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1779 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x30 // @1784 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x30] = code[0x4188:0x41b8] // @1792 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1793: // Incoming jump from 0x1742, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[4] // { // @1797 stack[-5] // @1798 stack[-4] // @1799 stack[-3] // @179A stack[-2] // } 1793 5B JUMPDEST 1794 61 PUSH2 0x179f 1797 85 DUP6 1798 85 DUP6 1799 85 DUP6 179A 85 DUP6 179B 61 PUSH2 0x27d7 179E 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1794 stack[0] = 0x179f // @1797 stack[1] = stack[-5] // @1798 stack[2] = stack[-4] // @1799 stack[3] = stack[-3] // @179A stack[4] = stack[-2] // } // Block ends with call to 0x27d7, returns to 0x179F label_179F: // Incoming return from call to 0x27D7 at 0x179E // Inputs[6] // { // @17A3 stack[-5] // @17A4 stack[-4] // @17A5 stack[-3] // @17A6 stack[-2] // @17A7 msg.gas // @17A8 stack[-1] // } 179F 5B JUMPDEST 17A0 61 PUSH2 0x17ad 17A3 85 DUP6 17A4 85 DUP6 17A5 85 DUP6 17A6 85 DUP6 17A7 5A GAS 17A8 86 DUP7 17A9 61 PUSH2 0x2b3c 17AC 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @17A0 stack[0] = 0x17ad // @17A3 stack[1] = stack[-5] // @17A4 stack[2] = stack[-4] // @17A5 stack[3] = stack[-3] // @17A6 stack[4] = stack[-2] // @17A7 stack[5] = msg.gas // @17A8 stack[6] = stack[-1] // } // Block ends with call to 0x2b3c, returns to 0x17AD label_17AD: // Incoming return from call to 0x2B3C at 0x17AC // Inputs[1] { @17B3 stack[-6] } 17AD 5B JUMPDEST 17AE 50 POP 17AF 50 POP 17B0 50 POP 17B1 50 POP 17B2 50 POP 17B3 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_17B4: // Incoming call from 0x06B4, returns to 0x06B5 // Inputs[2] // { // @17B9 memory[0x40:0x60] // @17EF stack[-1] // } 17B4 5B JUMPDEST 17B5 60 PUSH1 0x60 17B7 60 PUSH1 0x40 17B9 51 MLOAD 17BA 80 DUP1 17BB 60 PUSH1 0x40 17BD 01 ADD 17BE 60 PUSH1 0x40 17C0 52 MSTORE 17C1 80 DUP1 17C2 60 PUSH1 0x05 17C4 81 DUP2 17C5 52 MSTORE 17C6 60 PUSH1 0x20 17C8 01 ADD 17C9 7F PUSH32 0x322e302e30000000000000000000000000000000000000000000000000000000 17EA 81 DUP2 17EB 52 MSTORE 17EC 50 POP 17ED 90 SWAP1 17EE 50 POP 17EF 90 SWAP1 17F0 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @17C0 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @17C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x05 // @17EB memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x322e302e30000000000000000000000000000000000000000000000000000000 // @17EF stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_17F1: // Incoming jump from 0x0879 // Inputs[4] // { // @17F4 stack[-1] // @17F5 memory[stack[-1]:stack[-1] + 0x20] // @17F6 stack[-2] // @17F7 memory[stack[-2]:stack[-2] + 0x20] // } 17F1 5B JUMPDEST 17F2 60 PUSH1 0x60 17F4 81 DUP2 17F5 51 MLOAD 17F6 83 DUP4 17F7 51 MLOAD 17F8 14 EQ 17F9 61 PUSH2 0x184d 17FC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @17F2 stack[0] = 0x60 } // Block ends with conditional jump to 0x184d, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] label_17FD: // Incoming jump from 0x17FC, if not memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @17FF memory[0x40:0x60] // @1847 memory[0x40:0x60] // @184C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 17FD 60 PUSH1 0x40 17FF 51 MLOAD 1800 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1821 81 DUP2 1822 52 MSTORE 1823 60 PUSH1 0x04 1825 01 ADD 1826 80 DUP1 1827 80 DUP1 1828 60 PUSH1 0x20 182A 01 ADD 182B 82 DUP3 182C 81 DUP2 182D 03 SUB 182E 82 DUP3 182F 52 MSTORE 1830 60 PUSH1 0x2c 1832 81 DUP2 1833 52 MSTORE 1834 60 PUSH1 0x20 1836 01 ADD 1837 80 DUP1 1838 61 PUSH2 0x41b8 183B 60 PUSH1 0x2c 183D 91 SWAP2 183E 39 CODECOPY 183F 60 PUSH1 0x40 1841 01 ADD 1842 91 SWAP2 1843 50 POP 1844 50 POP 1845 60 PUSH1 0x40 1847 51 MLOAD 1848 80 DUP1 1849 91 SWAP2 184A 03 SUB 184B 90 SWAP1 184C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1822 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @182F memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1833 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @183E memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x41b8:0x41e4] // @184C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_184D: // Incoming jump from 0x17FC, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @1850 stack[-3] // @1851 memory[stack[-3]:stack[-3] + 0x20] // @1854 memory[0x40:0x60] // } 184D 5B JUMPDEST 184E 60 PUSH1 0x60 1850 83 DUP4 1851 51 MLOAD 1852 60 PUSH1 0x40 1854 51 MLOAD 1855 90 SWAP1 1856 80 DUP1 1857 82 DUP3 1858 52 MSTORE 1859 80 DUP1 185A 60 PUSH1 0x20 185C 02 MUL 185D 60 PUSH1 0x20 185F 01 ADD 1860 82 DUP3 1861 01 ADD 1862 60 PUSH1 0x40 1864 52 MSTORE 1865 80 DUP1 1866 15 ISZERO 1867 61 PUSH2 0x187f 186A 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @184E stack[0] = 0x60 // @1855 stack[1] = memory[0x40:0x60] // @1855 stack[2] = memory[stack[-3]:stack[-3] + 0x20] // @1858 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = memory[stack[-3]:stack[-3] + 0x20] // @1864 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * memory[stack[-3]:stack[-3] + 0x20] // } // Block ends with conditional jump to 0x187f, if !memory[stack[-3]:stack[-3] + 0x20] label_186B: // Incoming jump from 0x186A, if not !memory[stack[-3]:stack[-3] + 0x20] // Inputs[6] // { // @186B stack[-2] // @1871 stack[-1] // @1874 code.length // @1881 stack[-3] // @1889 stack[-6] // @188A memory[stack[-6]:stack[-6] + 0x20] // } 186B 81 DUP2 186C 60 PUSH1 0x20 186E 01 ADD 186F 60 PUSH1 0x20 1871 82 DUP3 1872 02 MUL 1873 80 DUP1 1874 38 CODESIZE 1875 83 DUP4 1876 39 CODECOPY 1877 80 DUP1 1878 82 DUP3 1879 01 ADD 187A 91 SWAP2 187B 50 POP 187C 50 POP 187D 90 SWAP1 187E 50 POP 187F 5B JUMPDEST 1880 50 POP 1881 90 SWAP1 1882 50 POP 1883 60 PUSH1 0x00 1885 80 DUP1 1886 90 SWAP1 1887 50 POP 1888 5B JUMPDEST 1889 84 DUP5 188A 51 MLOAD 188B 81 DUP2 188C 10 LT 188D 15 ISZERO 188E 61 PUSH2 0x192c 1891 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @1876 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = code[code.length:code.length + stack[-1] * 0x20] // @1881 stack[-3] = stack[-2] // @1886 stack[-2] = 0x00 // } // Block ends with conditional jump to 0x192c, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_1892: // Incoming jump from 0x1891, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x1891, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x1891, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[3] // { // @1895 stack[-5] // @1896 stack[-1] // @1898 memory[stack[-5]:stack[-5] + 0x20] // } 1892 60 PUSH1 0x00 1894 80 DUP1 1895 86 DUP7 1896 83 DUP4 1897 81 DUP2 1898 51 MLOAD 1899 81 DUP2 189A 10 LT 189B 61 PUSH2 0x18a0 189E 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1892 stack[0] = 0x00 // @1894 stack[1] = 0x00 // @1895 stack[2] = stack[-5] // @1896 stack[3] = stack[-1] // } // Block ends with conditional jump to 0x18a0, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_189F: // Incoming jump from 0x189E, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 189F FE *ASSERT // Stack delta = +0 // Outputs[1] { @189F assert(); } // Block terminates label_18A0: // Incoming jump from 0x189E, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[9] // { // @18A3 stack[-1] // @18A7 stack[-2] // @18A8 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @18D5 stack[-3] // @18DA stack[-4] // @18E2 memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @18E5 stack[-8] // @18E6 stack[-5] // @18E8 memory[stack[-8]:stack[-8] + 0x20] // } 18A0 5B JUMPDEST 18A1 60 PUSH1 0x20 18A3 02 MUL 18A4 60 PUSH1 0x20 18A6 01 ADD 18A7 01 ADD 18A8 51 MLOAD 18A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18BE 16 AND 18BF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18D4 16 AND 18D5 81 DUP2 18D6 52 MSTORE 18D7 60 PUSH1 0x20 18D9 01 ADD 18DA 90 SWAP1 18DB 81 DUP2 18DC 52 MSTORE 18DD 60 PUSH1 0x20 18DF 01 ADD 18E0 60 PUSH1 0x00 18E2 20 SHA3 18E3 60 PUSH1 0x00 18E5 85 DUP6 18E6 83 DUP4 18E7 81 DUP2 18E8 51 MLOAD 18E9 81 DUP2 18EA 10 LT 18EB 61 PUSH2 0x18f0 18EE 57 *JUMPI // Stack delta = +0 // Outputs[6] // { // @18D6 memory[stack[-3]:stack[-3] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @18DC memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @18E2 stack[-4] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) // @18E3 stack[-3] = 0x00 // @18E5 stack[-2] = stack[-8] // @18E6 stack[-1] = stack[-5] // } // Block ends with conditional jump to 0x18f0, if stack[-5] < memory[stack[-8]:stack[-8] + 0x20] label_18EF: // Incoming jump from 0x18EE, if not stack[-5] < memory[stack[-8]:stack[-8] + 0x20] 18EF FE *ASSERT // Stack delta = +0 // Outputs[1] { @18EF assert(); } // Block terminates label_18F0: // Incoming jump from 0x18EE, if stack[-5] < memory[stack[-8]:stack[-8] + 0x20] // Inputs[10] // { // @18F3 stack[-1] // @18F7 stack[-2] // @18F8 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @18F9 stack[-3] // @18FE stack[-4] // @1906 memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @1907 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @1908 stack[-6] // @1909 stack[-5] // @190B memory[stack[-6]:stack[-6] + 0x20] // } 18F0 5B JUMPDEST 18F1 60 PUSH1 0x20 18F3 02 MUL 18F4 60 PUSH1 0x20 18F6 01 ADD 18F7 01 ADD 18F8 51 MLOAD 18F9 81 DUP2 18FA 52 MSTORE 18FB 60 PUSH1 0x20 18FD 01 ADD 18FE 90 SWAP1 18FF 81 DUP2 1900 52 MSTORE 1901 60 PUSH1 0x20 1903 01 ADD 1904 60 PUSH1 0x00 1906 20 SHA3 1907 54 SLOAD 1908 82 DUP3 1909 82 DUP3 190A 81 DUP2 190B 51 MLOAD 190C 81 DUP2 190D 10 LT 190E 61 PUSH2 0x1913 1911 57 *JUMPI // Stack delta = -1 // Outputs[5] // { // @18FA memory[stack[-3]:stack[-3] + 0x20] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1900 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @1907 stack[-4] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @1908 stack[-3] = stack[-6] // @1909 stack[-2] = stack[-5] // } // Block ends with conditional jump to 0x1913, if stack[-5] < memory[stack[-6]:stack[-6] + 0x20] label_1912: // Incoming jump from 0x1911, if not stack[-5] < memory[stack[-6]:stack[-6] + 0x20] 1912 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1912 assert(); } // Block terminates label_1913: // Incoming jump from 0x1911, if stack[-5] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[4] // { // @1916 stack[-1] // @191A stack[-2] // @191B stack[-3] // @1920 stack[-4] // } 1913 5B JUMPDEST 1914 60 PUSH1 0x20 1916 02 MUL 1917 60 PUSH1 0x20 1919 01 ADD 191A 01 ADD 191B 81 DUP2 191C 81 DUP2 191D 52 MSTORE 191E 50 POP 191F 50 POP 1920 80 DUP1 1921 80 DUP1 1922 60 PUSH1 0x01 1924 01 ADD 1925 91 SWAP2 1926 50 POP 1927 50 POP 1928 61 PUSH2 0x1888 192B 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @191D memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] // @1925 stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x1888 label_192C: // Incoming jump from 0x1891, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x1891, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x1891, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[4] // { // @192E stack[-2] // @192F stack[-3] // @1932 stack[-6] // @1933 stack[-5] // } 192C 5B JUMPDEST 192D 50 POP 192E 80 DUP1 192F 91 SWAP2 1930 50 POP 1931 50 POP 1932 92 SWAP3 1933 91 SWAP2 1934 50 POP 1935 50 POP 1936 56 *JUMP // Stack delta = -5 // Outputs[1] { @1932 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_1937: // Incoming jump from 0x08FC // Inputs[4] // { // @193F stack[-1] // @194D memory[0x00:0x40] // @194E storage[keccak256(memory[0x00:0x40])] // @1952 stack[-2] // } 1937 5B JUMPDEST 1938 60 PUSH1 0x00 193A 80 DUP1 193B 60 PUSH1 0x06 193D 60 PUSH1 0x00 193F 84 DUP5 1940 81 DUP2 1941 52 MSTORE 1942 60 PUSH1 0x20 1944 01 ADD 1945 90 SWAP1 1946 81 DUP2 1947 52 MSTORE 1948 60 PUSH1 0x20 194A 01 ADD 194B 60 PUSH1 0x00 194D 20 SHA3 194E 54 SLOAD 194F 11 GT 1950 90 SWAP1 1951 50 POP 1952 91 SWAP2 1953 90 SWAP1 1954 50 POP 1955 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1941 memory[0x00:0x20] = stack[-1] // @1947 memory[0x20:0x40] = 0x06 // @1952 stack[-2] = storage[keccak256(memory[0x00:0x40])] > 0x00 // } // Block ends with unconditional jump to stack[-2] label_1956: // Incoming jump from 0x0942 // Inputs[4] // { // @195C stack[-1] // @1964 memory[0x00:0x40] // @1969 storage[keccak256(memory[0x00:0x40])] // @1987 stack[-2] // } 1956 5B JUMPDEST 1957 60 PUSH1 0x0b 1959 60 PUSH1 0x20 195B 52 MSTORE 195C 80 DUP1 195D 60 PUSH1 0x00 195F 52 MSTORE 1960 60 PUSH1 0x40 1962 60 PUSH1 0x00 1964 20 SHA3 1965 60 PUSH1 0x00 1967 91 SWAP2 1968 50 POP 1969 54 SLOAD 196A 90 SWAP1 196B 61 PUSH2 0x0100 196E 0A EXP 196F 90 SWAP1 1970 04 DIV 1971 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1986 16 AND 1987 81 DUP2 1988 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @195B memory[0x20:0x40] = 0x0b // @195F memory[0x00:0x20] = stack[-1] // @1986 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] label_1989: // Incoming call from 0x098C, returns to 0x098D 1989 5B JUMPDEST 198A 61 PUSH2 0x1999 198D 61 PUSH2 0x1994 1990 61 PUSH2 0x2778 1993 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @198A stack[0] = 0x1999 // @198D stack[1] = 0x1994 // } // Block ends with call to 0x2778, returns to 0x1994 label_1994: // Incoming return from call to 0x2778 at 0x1993 1994 5B JUMPDEST 1995 61 PUSH2 0x2780 1998 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2780 label_1999: // Incoming return from call to 0x1994 at 0x1993 // Inputs[1] { @199D stack[-1] } 1999 5B JUMPDEST 199A 61 PUSH2 0x19ee 199D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x19ee, if stack[-1] label_199E: // Incoming jump from 0x199D, if not stack[-1] // Inputs[3] // { // @19A0 memory[0x40:0x60] // @19E8 memory[0x40:0x60] // @19ED memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 199E 60 PUSH1 0x40 19A0 51 MLOAD 19A1 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 19C2 81 DUP2 19C3 52 MSTORE 19C4 60 PUSH1 0x04 19C6 01 ADD 19C7 80 DUP1 19C8 80 DUP1 19C9 60 PUSH1 0x20 19CB 01 ADD 19CC 82 DUP3 19CD 81 DUP2 19CE 03 SUB 19CF 82 DUP3 19D0 52 MSTORE 19D1 60 PUSH1 0x2e 19D3 81 DUP2 19D4 52 MSTORE 19D5 60 PUSH1 0x20 19D7 01 ADD 19D8 80 DUP1 19D9 61 PUSH2 0x40f5 19DC 60 PUSH1 0x2e 19DE 91 SWAP2 19DF 39 CODECOPY 19E0 60 PUSH1 0x40 19E2 01 ADD 19E3 91 SWAP2 19E4 50 POP 19E5 50 POP 19E6 60 PUSH1 0x40 19E8 51 MLOAD 19E9 80 DUP1 19EA 91 SWAP2 19EB 03 SUB 19EC 90 SWAP1 19ED FD *REVERT // Stack delta = +0 // Outputs[5] // { // @19C3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @19D0 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @19D4 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @19DF memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x40f5:0x4123] // @19ED revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_19EE: // Incoming jump from 0x199D, if stack[-1] // Inputs[6] // { // @1A0C storage[0x02] // @1A63 memory[0x40:0x60] // @1A66 memory[0x40:0x60] // @1A6B memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1A77 storage[0x02] // @1AAE stack[-1] // } 19EE 5B JUMPDEST 19EF 60 PUSH1 0x00 19F1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A06 16 AND 1A07 60 PUSH1 0x02 1A09 60 PUSH1 0x00 1A0B 90 SWAP1 1A0C 54 SLOAD 1A0D 90 SWAP1 1A0E 61 PUSH2 0x0100 1A11 0A EXP 1A12 90 SWAP1 1A13 04 DIV 1A14 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A29 16 AND 1A2A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A3F 16 AND 1A40 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1A61 60 PUSH1 0x40 1A63 51 MLOAD 1A64 60 PUSH1 0x40 1A66 51 MLOAD 1A67 80 DUP1 1A68 91 SWAP2 1A69 03 SUB 1A6A 90 SWAP1 1A6B A3 LOG3 1A6C 60 PUSH1 0x00 1A6E 60 PUSH1 0x02 1A70 60 PUSH1 0x00 1A72 61 PUSH2 0x0100 1A75 0A EXP 1A76 81 DUP2 1A77 54 SLOAD 1A78 81 DUP2 1A79 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A8E 02 MUL 1A8F 19 NOT 1A90 16 AND 1A91 90 SWAP1 1A92 83 DUP4 1A93 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AA8 16 AND 1AA9 02 MUL 1AAA 17 OR 1AAB 90 SWAP1 1AAC 55 SSTORE 1AAD 50 POP 1AAE 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1A6B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x02] & 0xffffffffffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffffffffffff & 0x00]); // @1AAC storage[0x02] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x02]) // } // Block ends with unconditional jump to stack[-1] label_1AAF: // Incoming jump from 0x23BC // Incoming jump from 0x0A7B // Inputs[1] { @1AB5 storage[0x09] } 1AAF 5B JUMPDEST 1AB0 60 PUSH1 0x09 1AB2 60 PUSH1 0x00 1AB4 90 SWAP1 1AB5 54 SLOAD 1AB6 90 SWAP1 1AB7 61 PUSH2 0x0100 1ABA 0A EXP 1ABB 90 SWAP1 1ABC 04 DIV 1ABD 60 PUSH1 0xff 1ABF 16 AND 1AC0 61 PUSH2 0x1b31 1AC3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b31, if 0xff & storage[0x09] / 0x0100 ** 0x00 label_1AC4: // Incoming jump from 0x1AC3, if not 0xff & storage[0x09] / 0x0100 ** 0x00 // Inputs[3] // { // @1AC6 memory[0x40:0x60] // @1B2B memory[0x40:0x60] // @1B30 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1AC4 60 PUSH1 0x40 1AC6 51 MLOAD 1AC7 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1AE8 81 DUP2 1AE9 52 MSTORE 1AEA 60 PUSH1 0x04 1AEC 01 ADD 1AED 80 DUP1 1AEE 80 DUP1 1AEF 60 PUSH1 0x20 1AF1 01 ADD 1AF2 82 DUP3 1AF3 81 DUP2 1AF4 03 SUB 1AF5 82 DUP3 1AF6 52 MSTORE 1AF7 60 PUSH1 0x1f 1AF9 81 DUP2 1AFA 52 MSTORE 1AFB 60 PUSH1 0x20 1AFD 01 ADD 1AFE 80 DUP1 1AFF 7F PUSH32 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 1B20 81 DUP2 1B21 52 MSTORE 1B22 50 POP 1B23 60 PUSH1 0x20 1B25 01 ADD 1B26 91 SWAP2 1B27 50 POP 1B28 50 POP 1B29 60 PUSH1 0x40 1B2B 51 MLOAD 1B2C 80 DUP1 1B2D 91 SWAP2 1B2E 03 SUB 1B2F 90 SWAP1 1B30 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1AE9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1AF6 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1AFA memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1f // @1B21 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 // @1B30 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1B31: // Incoming jump from 0x1AC3, if 0xff & storage[0x09] / 0x0100 ** 0x00 // Inputs[1] { @1B3D storage[0x09] } 1B31 5B JUMPDEST 1B32 60 PUSH1 0x00 1B34 60 PUSH1 0x09 1B36 60 PUSH1 0x00 1B38 61 PUSH2 0x0100 1B3B 0A EXP 1B3C 81 DUP2 1B3D 54 SLOAD 1B3E 81 DUP2 1B3F 60 PUSH1 0xff 1B41 02 MUL 1B42 19 NOT 1B43 16 AND 1B44 90 SWAP1 1B45 83 DUP4 1B46 15 ISZERO 1B47 15 ISZERO 1B48 02 MUL 1B49 17 OR 1B4A 90 SWAP1 1B4B 55 SSTORE 1B4C 50 POP 1B4D 61 PUSH2 0x1b5e 1B50 61 PUSH2 0x1b57 1B53 61 PUSH2 0x2778 1B56 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1B4B storage[0x09] = !!0x00 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x09]) // @1B4D stack[0] = 0x1b5e // @1B50 stack[1] = 0x1b57 // } // Block ends with call to 0x2778, returns to 0x1B57 label_1B57: // Incoming return from call to 0x2778 at 0x1B56 // Inputs[2] // { // @1B58 stack[-5] // @1B59 stack[-4] // } 1B57 5B JUMPDEST 1B58 84 DUP5 1B59 84 DUP5 1B5A 61 PUSH2 0x2dfa 1B5D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1B58 stack[0] = stack[-5] // @1B59 stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x2dfa label_1B5E: // Incoming return from call to 0x1B57 at 0x1B56 // Inputs[4] // { // @1B62 stack[-4] // @1B63 stack[-3] // @1B64 stack[-2] // @1B65 stack[-1] // } 1B5E 5B JUMPDEST 1B5F 61 PUSH2 0x1b6a 1B62 84 DUP5 1B63 84 DUP5 1B64 84 DUP5 1B65 84 DUP5 1B66 61 PUSH2 0x2ebf 1B69 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1B5F stack[0] = 0x1b6a // @1B62 stack[1] = stack[-4] // @1B63 stack[2] = stack[-3] // @1B64 stack[3] = stack[-2] // @1B65 stack[4] = stack[-1] // } // Block ends with call to 0x2ebf, returns to 0x1B6A label_1B6A: // Incoming return from call to 0x2EBF at 0x1B69 // Inputs[2] // { // @1B76 storage[0x09] // @1B8A stack[-5] // } 1B6A 5B JUMPDEST 1B6B 60 PUSH1 0x01 1B6D 60 PUSH1 0x09 1B6F 60 PUSH1 0x00 1B71 61 PUSH2 0x0100 1B74 0A EXP 1B75 81 DUP2 1B76 54 SLOAD 1B77 81 DUP2 1B78 60 PUSH1 0xff 1B7A 02 MUL 1B7B 19 NOT 1B7C 16 AND 1B7D 90 SWAP1 1B7E 83 DUP4 1B7F 15 ISZERO 1B80 15 ISZERO 1B81 02 MUL 1B82 17 OR 1B83 90 SWAP1 1B84 55 SSTORE 1B85 50 POP 1B86 50 POP 1B87 50 POP 1B88 50 POP 1B89 50 POP 1B8A 56 *JUMP // Stack delta = -5 // Outputs[1] { @1B84 storage[0x09] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x09]) } // Block ends with unconditional jump to stack[-5] label_1B8B: // Incoming jump from 0x0ABF // Inputs[4] // { // @1B91 stack[-1] // @1B99 memory[0x00:0x40] // @1B9E storage[keccak256(memory[0x00:0x40])] // @1BA9 stack[-2] // } 1B8B 5B JUMPDEST 1B8C 60 PUSH1 0x0a 1B8E 60 PUSH1 0x20 1B90 52 MSTORE 1B91 80 DUP1 1B92 60 PUSH1 0x00 1B94 52 MSTORE 1B95 60 PUSH1 0x40 1B97 60 PUSH1 0x00 1B99 20 SHA3 1B9A 60 PUSH1 0x00 1B9C 91 SWAP2 1B9D 50 POP 1B9E 54 SLOAD 1B9F 90 SWAP1 1BA0 61 PUSH2 0x0100 1BA3 0A EXP 1BA4 90 SWAP1 1BA5 04 DIV 1BA6 60 PUSH1 0xff 1BA8 16 AND 1BA9 81 DUP2 1BAA 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1B90 memory[0x20:0x40] = 0x0a // @1B94 memory[0x00:0x20] = stack[-1] // @1BA8 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] label_1BAB: // Incoming jump from 0x0B9C // Inputs[1] { @1BAC stack[-2] } 1BAB 5B JUMPDEST 1BAC 81 DUP2 1BAD 61 PUSH2 0x1bbd 1BB0 81 DUP2 1BB1 61 PUSH2 0x1bb8 1BB4 61 PUSH2 0x2778 1BB7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BAC stack[0] = stack[-2] // @1BAD stack[1] = 0x1bbd // @1BB0 stack[2] = stack[-2] // @1BB1 stack[3] = 0x1bb8 // } // Block ends with call to 0x2778, returns to 0x1BB8 label_1BB8: // Incoming return from call to 0x2778 at 0x1BB7 1BB8 5B JUMPDEST 1BB9 61 PUSH2 0x2558 1BBC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2558 label_1BBD: // Incoming return from call to 0x1BB8 at 0x1BB7 // Inputs[1] { @1BC1 stack[-1] } 1BBD 5B JUMPDEST 1BBE 61 PUSH2 0x1c12 1BC1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1c12, if stack[-1] label_1BC2: // Incoming jump from 0x1BC1, if not stack[-1] // Inputs[3] // { // @1BC4 memory[0x40:0x60] // @1C0C memory[0x40:0x60] // @1C11 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1BC2 60 PUSH1 0x40 1BC4 51 MLOAD 1BC5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1BE6 81 DUP2 1BE7 52 MSTORE 1BE8 60 PUSH1 0x04 1BEA 01 ADD 1BEB 80 DUP1 1BEC 80 DUP1 1BED 60 PUSH1 0x20 1BEF 01 ADD 1BF0 82 DUP3 1BF1 81 DUP2 1BF2 03 SUB 1BF3 82 DUP3 1BF4 52 MSTORE 1BF5 60 PUSH1 0x35 1BF7 81 DUP2 1BF8 52 MSTORE 1BF9 60 PUSH1 0x20 1BFB 01 ADD 1BFC 80 DUP1 1BFD 61 PUSH2 0x428c 1C00 60 PUSH1 0x35 1C02 91 SWAP2 1C03 39 CODECOPY 1C04 60 PUSH1 0x40 1C06 01 ADD 1C07 91 SWAP2 1C08 50 POP 1C09 50 POP 1C0A 60 PUSH1 0x40 1C0C 51 MLOAD 1C0D 80 DUP1 1C0E 91 SWAP2 1C0F 03 SUB 1C10 90 SWAP1 1C11 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1BE7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1BF4 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1BF8 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x35 // @1C03 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x35] = code[0x428c:0x42c1] // @1C11 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1C12: // Incoming jump from 0x1BC1, if stack[-1] // Inputs[2] // { // @1C16 stack[-3] // @1C17 stack[-2] // } 1C12 5B JUMPDEST 1C13 61 PUSH2 0x1c1c 1C16 83 DUP4 1C17 83 DUP4 1C18 61 PUSH2 0x2ee6 1C1B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C13 stack[0] = 0x1c1c // @1C16 stack[1] = stack[-3] // @1C17 stack[2] = stack[-2] // } // Block ends with call to 0x2ee6, returns to 0x1C1C label_1C1C: // Incoming return from call to 0x2EE6 at 0x1C1B // Inputs[1] { @1C20 stack[-4] } 1C1C 5B JUMPDEST 1C1D 50 POP 1C1E 50 POP 1C1F 50 POP 1C20 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_1C21: // Incoming call from 0x0BA6, returns to 0x0BA7 // Incoming call from 0x27A0, returns to 0x27A1 // Incoming call from 0x27C8, returns to 0x27C9 // Inputs[2] // { // @1C29 storage[0x02] // @1C49 stack[-1] // } 1C21 5B JUMPDEST 1C22 60 PUSH1 0x00 1C24 60 PUSH1 0x02 1C26 60 PUSH1 0x00 1C28 90 SWAP1 1C29 54 SLOAD 1C2A 90 SWAP1 1C2B 61 PUSH2 0x0100 1C2E 0A EXP 1C2F 90 SWAP1 1C30 04 DIV 1C31 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C46 16 AND 1C47 90 SWAP1 1C48 50 POP 1C49 90 SWAP1 1C4A 56 *JUMP // Stack delta = +0 // Outputs[1] { @1C49 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_1C4B: // Incoming call from 0x0BF0, returns to 0x0BF1 // Inputs[1] { @1C53 storage[0x02] } 1C4B 5B JUMPDEST 1C4C 60 PUSH1 0x00 1C4E 60 PUSH1 0x02 1C50 60 PUSH1 0x00 1C52 90 SWAP1 1C53 54 SLOAD 1C54 90 SWAP1 1C55 61 PUSH2 0x0100 1C58 0A EXP 1C59 90 SWAP1 1C5A 04 DIV 1C5B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C70 16 AND 1C71 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C86 16 AND 1C87 61 PUSH2 0x1c8e 1C8A 61 PUSH2 0x2778 1C8D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C4C stack[0] = 0x00 // @1C86 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 // @1C87 stack[2] = 0x1c8e // } // Block ends with call to 0x2778, returns to 0x1C8E label_1C8E: // Incoming return from call to 0x2778 at 0x1C8D // Inputs[4] // { // @1CA4 stack[-1] // @1CA5 stack[-2] // @1CA6 stack[-3] // @1CA8 stack[-4] // } 1C8E 5B JUMPDEST 1C8F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CA4 16 AND 1CA5 14 EQ 1CA6 90 SWAP1 1CA7 50 POP 1CA8 90 SWAP1 1CA9 56 *JUMP // Stack delta = -3 // Outputs[1] { @1CA8 stack[-4] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-4] label_1CAA: // Incoming jump from 0x0C56 // Inputs[1] { @1CAB stack[-2] } 1CAA 5B JUMPDEST 1CAB 81 DUP2 1CAC 61 PUSH2 0x1cbc 1CAF 81 DUP2 1CB0 61 PUSH2 0x1cb7 1CB3 61 PUSH2 0x2778 1CB6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1CAB stack[0] = stack[-2] // @1CAC stack[1] = 0x1cbc // @1CAF stack[2] = stack[-2] // @1CB0 stack[3] = 0x1cb7 // } // Block ends with call to 0x2778, returns to 0x1CB7 label_1CB7: // Incoming return from call to 0x2778 at 0x1CB6 1CB7 5B JUMPDEST 1CB8 61 PUSH2 0x2558 1CBB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2558 label_1CBC: // Incoming return from call to 0x1CB7 at 0x1CB6 // Inputs[1] { @1CC0 stack[-1] } 1CBC 5B JUMPDEST 1CBD 61 PUSH2 0x1d11 1CC0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1d11, if stack[-1] label_1CC1: // Incoming jump from 0x1CC0, if not stack[-1] // Inputs[3] // { // @1CC3 memory[0x40:0x60] // @1D0B memory[0x40:0x60] // @1D10 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1CC1 60 PUSH1 0x40 1CC3 51 MLOAD 1CC4 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1CE5 81 DUP2 1CE6 52 MSTORE 1CE7 60 PUSH1 0x04 1CE9 01 ADD 1CEA 80 DUP1 1CEB 80 DUP1 1CEC 60 PUSH1 0x20 1CEE 01 ADD 1CEF 82 DUP3 1CF0 81 DUP2 1CF1 03 SUB 1CF2 82 DUP3 1CF3 52 MSTORE 1CF4 60 PUSH1 0x35 1CF6 81 DUP2 1CF7 52 MSTORE 1CF8 60 PUSH1 0x20 1CFA 01 ADD 1CFB 80 DUP1 1CFC 61 PUSH2 0x428c 1CFF 60 PUSH1 0x35 1D01 91 SWAP2 1D02 39 CODECOPY 1D03 60 PUSH1 0x40 1D05 01 ADD 1D06 91 SWAP2 1D07 50 POP 1D08 50 POP 1D09 60 PUSH1 0x40 1D0B 51 MLOAD 1D0C 80 DUP1 1D0D 91 SWAP2 1D0E 03 SUB 1D0F 90 SWAP1 1D10 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1CE6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1CF3 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1CF7 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x35 // @1D02 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x35] = code[0x428c:0x42c1] // @1D10 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1D11: // Incoming jump from 0x1CC0, if stack[-1] // Inputs[1] { @1D2A stack[-2] } 1D11 5B JUMPDEST 1D12 60 PUSH1 0x00 1D14 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D29 16 AND 1D2A 82 DUP3 1D2B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D40 16 AND 1D41 14 EQ 1D42 15 ISZERO 1D43 61 PUSH2 0x1d97 1D46 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d97, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1D47: // Incoming jump from 0x1D46, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1D49 memory[0x40:0x60] // @1D91 memory[0x40:0x60] // @1D96 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1D47 60 PUSH1 0x40 1D49 51 MLOAD 1D4A 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1D6B 81 DUP2 1D6C 52 MSTORE 1D6D 60 PUSH1 0x04 1D6F 01 ADD 1D70 80 DUP1 1D71 80 DUP1 1D72 60 PUSH1 0x20 1D74 01 ADD 1D75 82 DUP3 1D76 81 DUP2 1D77 03 SUB 1D78 82 DUP3 1D79 52 MSTORE 1D7A 60 PUSH1 0x30 1D7C 81 DUP2 1D7D 52 MSTORE 1D7E 60 PUSH1 0x20 1D80 01 ADD 1D81 80 DUP1 1D82 61 PUSH2 0x3ff5 1D85 60 PUSH1 0x30 1D87 91 SWAP2 1D88 39 CODECOPY 1D89 60 PUSH1 0x40 1D8B 01 ADD 1D8C 91 SWAP2 1D8D 50 POP 1D8E 50 POP 1D8F 60 PUSH1 0x40 1D91 51 MLOAD 1D92 80 DUP1 1D93 91 SWAP2 1D94 03 SUB 1D95 90 SWAP1 1D96 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1D6C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1D79 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1D7D memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x30 // @1D88 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x30] = code[0x3ff5:0x4025] // @1D96 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1D97: // Incoming jump from 0x1D46, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[8] // { // @1D98 stack[-2] // @1D9D stack[-3] // @1DAB memory[0x00:0x40] // @1DB3 storage[keccak256(memory[0x00:0x40])] // @1E25 memory[0x40:0x60] // @1E28 memory[0x40:0x60] // @1E2D memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1E31 stack[-4] // } 1D97 5B JUMPDEST 1D98 81 DUP2 1D99 60 PUSH1 0x0b 1D9B 60 PUSH1 0x00 1D9D 85 DUP6 1D9E 81 DUP2 1D9F 52 MSTORE 1DA0 60 PUSH1 0x20 1DA2 01 ADD 1DA3 90 SWAP1 1DA4 81 DUP2 1DA5 52 MSTORE 1DA6 60 PUSH1 0x20 1DA8 01 ADD 1DA9 60 PUSH1 0x00 1DAB 20 SHA3 1DAC 60 PUSH1 0x00 1DAE 61 PUSH2 0x0100 1DB1 0A EXP 1DB2 81 DUP2 1DB3 54 SLOAD 1DB4 81 DUP2 1DB5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DCA 02 MUL 1DCB 19 NOT 1DCC 16 AND 1DCD 90 SWAP1 1DCE 83 DUP4 1DCF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DE4 16 AND 1DE5 02 MUL 1DE6 17 OR 1DE7 90 SWAP1 1DE8 55 SSTORE 1DE9 50 POP 1DEA 81 DUP2 1DEB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E00 16 AND 1E01 83 DUP4 1E02 7F PUSH32 0x39071c63e44267bfdefc7b625c0df99d3ce2e6ff98d9f5e9e8a7ab43cdf5000d 1E23 60 PUSH1 0x40 1E25 51 MLOAD 1E26 60 PUSH1 0x40 1E28 51 MLOAD 1E29 80 DUP1 1E2A 91 SWAP2 1E2B 03 SUB 1E2C 90 SWAP1 1E2D A3 LOG3 1E2E 50 POP 1E2F 50 POP 1E30 50 POP 1E31 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1D9F memory[0x00:0x20] = stack[-3] // @1DA5 memory[0x20:0x40] = 0x0b // @1DE8 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @1E2D log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x39071c63e44267bfdefc7b625c0df99d3ce2e6ff98d9f5e9e8a7ab43cdf5000d, stack[-3], stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-4] label_1E32: // Incoming call from 0x0C60, returns to 0x0C61 // Inputs[3] // { // @1E36 storage[0x05] // @1E57 memory[0x40:0x60] // @1E6A storage[0x05] // } 1E32 5B JUMPDEST 1E33 60 PUSH1 0x05 1E35 80 DUP1 1E36 54 SLOAD 1E37 60 PUSH1 0x01 1E39 81 DUP2 1E3A 60 PUSH1 0x01 1E3C 16 AND 1E3D 15 ISZERO 1E3E 61 PUSH2 0x0100 1E41 02 MUL 1E42 03 SUB 1E43 16 AND 1E44 60 PUSH1 0x02 1E46 90 SWAP1 1E47 04 DIV 1E48 80 DUP1 1E49 60 PUSH1 0x1f 1E4B 01 ADD 1E4C 60 PUSH1 0x20 1E4E 80 DUP1 1E4F 91 SWAP2 1E50 04 DIV 1E51 02 MUL 1E52 60 PUSH1 0x20 1E54 01 ADD 1E55 60 PUSH1 0x40 1E57 51 MLOAD 1E58 90 SWAP1 1E59 81 DUP2 1E5A 01 ADD 1E5B 60 PUSH1 0x40 1E5D 52 MSTORE 1E5E 80 DUP1 1E5F 92 SWAP3 1E60 91 SWAP2 1E61 90 SWAP1 1E62 81 DUP2 1E63 81 DUP2 1E64 52 MSTORE 1E65 60 PUSH1 0x20 1E67 01 ADD 1E68 82 DUP3 1E69 80 DUP1 1E6A 54 SLOAD 1E6B 60 PUSH1 0x01 1E6D 81 DUP2 1E6E 60 PUSH1 0x01 1E70 16 AND 1E71 15 ISZERO 1E72 61 PUSH2 0x0100 1E75 02 MUL 1E76 03 SUB 1E77 16 AND 1E78 60 PUSH1 0x02 1E7A 90 SWAP1 1E7B 04 DIV 1E7C 80 DUP1 1E7D 15 ISZERO 1E7E 61 PUSH2 0x1ec8 1E81 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @1E5D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02) / 0x20 * 0x20 // @1E5F stack[0] = memory[0x40:0x60] // @1E60 stack[1] = 0x05 // @1E61 stack[2] = (0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02 // @1E64 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02 // @1E67 stack[3] = 0x20 + memory[0x40:0x60] // @1E68 stack[4] = 0x05 // @1E7B stack[5] = (0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02 // } // Block ends with conditional jump to 0x1ec8, if !((0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02) label_1E82: // Incoming jump from 0x1E81, if not !((0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02) // Inputs[1] { @1E82 stack[-1] } 1E82 80 DUP1 1E83 60 PUSH1 0x1f 1E85 10 LT 1E86 61 PUSH2 0x1e9d 1E89 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e9d, if 0x1f < stack[-1] label_1E8A: // Incoming jump from 0x1E89, if not 0x1f < stack[-1] // Inputs[4] // { // @1E8E stack[-2] // @1E8F storage[stack[-2]] // @1E92 stack[-3] // @1E94 stack[-1] // } 1E8A 61 PUSH2 0x0100 1E8D 80 DUP1 1E8E 83 DUP4 1E8F 54 SLOAD 1E90 04 DIV 1E91 02 MUL 1E92 83 DUP4 1E93 52 MSTORE 1E94 91 SWAP2 1E95 60 PUSH1 0x20 1E97 01 ADD 1E98 91 SWAP2 1E99 61 PUSH2 0x1ec8 1E9C 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1E93 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1E98 stack[-1] = stack[-1] // @1E98 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1ec8 label_1E9D: // Incoming jump from 0x1E89, if 0x1f < stack[-1] // Inputs[5] // { // @1E9E stack[-3] // @1E9F stack[-1] // @1EA1 stack[-2] // @1EA9 memory[0x00:0x20] // @1EAD storage[keccak256(memory[0x00:0x20])] // } 1E9D 5B JUMPDEST 1E9E 82 DUP3 1E9F 01 ADD 1EA0 91 SWAP2 1EA1 90 SWAP1 1EA2 60 PUSH1 0x00 1EA4 52 MSTORE 1EA5 60 PUSH1 0x20 1EA7 60 PUSH1 0x00 1EA9 20 SHA3 1EAA 90 SWAP1 1EAB 5B JUMPDEST 1EAC 81 DUP2 1EAD 54 SLOAD 1EAE 81 DUP2 1EAF 52 MSTORE 1EB0 90 SWAP1 1EB1 60 PUSH1 0x01 1EB3 01 ADD 1EB4 90 SWAP1 1EB5 60 PUSH1 0x20 1EB7 01 ADD 1EB8 80 DUP1 1EB9 83 DUP4 1EBA 11 GT 1EBB 61 PUSH2 0x1eab 1EBE 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1EA0 stack[-3] = stack[-3] + stack[-1] // @1EA4 memory[0x00:0x20] = stack[-2] // @1EAF memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1EB4 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1EB7 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1eab, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1EBF: // Incoming jump from 0x1EBE, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1EBE, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1EBF stack[-3] // @1EC0 stack[-1] // } 1EBF 82 DUP3 1EC0 90 SWAP1 1EC1 03 SUB 1EC2 60 PUSH1 0x1f 1EC4 16 AND 1EC5 82 DUP3 1EC6 01 ADD 1EC7 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1EC7 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1EC7 stack[-1] = stack[-3] // } // Block continues label_1EC8: // Incoming jump from 0x1EC7 // Incoming jump from 0x1E9C // Incoming jump from 0x1E81, if !((0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02) // Inputs[1] { @1ECE stack[-7] } 1EC8 5B JUMPDEST 1EC9 50 POP 1ECA 50 POP 1ECB 50 POP 1ECC 50 POP 1ECD 50 POP 1ECE 81 DUP2 1ECF 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_1ED0: // Incoming jump from 0x0D1D 1ED0 5B JUMPDEST 1ED1 61 PUSH2 0x1ee0 1ED4 61 PUSH2 0x1edb 1ED7 61 PUSH2 0x2778 1EDA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1ED1 stack[0] = 0x1ee0 // @1ED4 stack[1] = 0x1edb // } // Block ends with call to 0x2778, returns to 0x1EDB label_1EDB: // Incoming return from call to 0x2778 at 0x1EDA 1EDB 5B JUMPDEST 1EDC 61 PUSH2 0x2780 1EDF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2780 label_1EE0: // Incoming return from call to 0x1EDB at 0x1EDA // Inputs[1] { @1EE4 stack[-1] } 1EE0 5B JUMPDEST 1EE1 61 PUSH2 0x1f35 1EE4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1f35, if stack[-1] label_1EE5: // Incoming jump from 0x1EE4, if not stack[-1] // Inputs[3] // { // @1EE7 memory[0x40:0x60] // @1F2F memory[0x40:0x60] // @1F34 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1EE5 60 PUSH1 0x40 1EE7 51 MLOAD 1EE8 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1F09 81 DUP2 1F0A 52 MSTORE 1F0B 60 PUSH1 0x04 1F0D 01 ADD 1F0E 80 DUP1 1F0F 80 DUP1 1F10 60 PUSH1 0x20 1F12 01 ADD 1F13 82 DUP3 1F14 81 DUP2 1F15 03 SUB 1F16 82 DUP3 1F17 52 MSTORE 1F18 60 PUSH1 0x2e 1F1A 81 DUP2 1F1B 52 MSTORE 1F1C 60 PUSH1 0x20 1F1E 01 ADD 1F1F 80 DUP1 1F20 61 PUSH2 0x40f5 1F23 60 PUSH1 0x2e 1F25 91 SWAP2 1F26 39 CODECOPY 1F27 60 PUSH1 0x40 1F29 01 ADD 1F2A 91 SWAP2 1F2B 50 POP 1F2C 50 POP 1F2D 60 PUSH1 0x40 1F2F 51 MLOAD 1F30 80 DUP1 1F31 91 SWAP2 1F32 03 SUB 1F33 90 SWAP1 1F34 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1F0A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1F17 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1F1B memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @1F26 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x40f5:0x4123] // @1F34 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1F35: // Incoming jump from 0x1EE4, if stack[-1] // Inputs[4] // { // @1F3A stack[-1] // @1F74 memory[0x00:0x40] // @1F7C storage[keccak256(memory[0x00:0x40])] // @1F86 stack[-2] // } 1F35 5B JUMPDEST 1F36 60 PUSH1 0x0a 1F38 60 PUSH1 0x00 1F3A 82 DUP3 1F3B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F50 16 AND 1F51 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F66 16 AND 1F67 81 DUP2 1F68 52 MSTORE 1F69 60 PUSH1 0x20 1F6B 01 ADD 1F6C 90 SWAP1 1F6D 81 DUP2 1F6E 52 MSTORE 1F6F 60 PUSH1 0x20 1F71 01 ADD 1F72 60 PUSH1 0x00 1F74 20 SHA3 1F75 60 PUSH1 0x00 1F77 61 PUSH2 0x0100 1F7A 0A EXP 1F7B 81 DUP2 1F7C 54 SLOAD 1F7D 90 SWAP1 1F7E 60 PUSH1 0xff 1F80 02 MUL 1F81 19 NOT 1F82 16 AND 1F83 90 SWAP1 1F84 55 SSTORE 1F85 50 POP 1F86 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @1F68 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1F6E memory[0x20:0x40] = 0x0a // @1F84 storage[keccak256(memory[0x00:0x40])] = ~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_1F87: // Incoming jump from 0x0D6D // Inputs[11] // { // @1F88 stack[-1] // @1F8D msg.sender // @1FC7 memory[0x00:0x40] // @1FCA stack[-2] // @2004 memory[0x00:0x40] // @200C storage[keccak256(memory[0x00:0x40])] // @2033 msg.sender // @206E memory[0x40:0x60] // @207F memory[0x40:0x60] // @2084 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @2087 stack[-3] // } 1F87 5B JUMPDEST 1F88 80 DUP1 1F89 60 PUSH1 0x01 1F8B 60 PUSH1 0x00 1F8D 33 CALLER 1F8E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FA3 16 AND 1FA4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FB9 16 AND 1FBA 81 DUP2 1FBB 52 MSTORE 1FBC 60 PUSH1 0x20 1FBE 01 ADD 1FBF 90 SWAP1 1FC0 81 DUP2 1FC1 52 MSTORE 1FC2 60 PUSH1 0x20 1FC4 01 ADD 1FC5 60 PUSH1 0x00 1FC7 20 SHA3 1FC8 60 PUSH1 0x00 1FCA 84 DUP5 1FCB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FE0 16 AND 1FE1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FF6 16 AND 1FF7 81 DUP2 1FF8 52 MSTORE 1FF9 60 PUSH1 0x20 1FFB 01 ADD 1FFC 90 SWAP1 1FFD 81 DUP2 1FFE 52 MSTORE 1FFF 60 PUSH1 0x20 2001 01 ADD 2002 60 PUSH1 0x00 2004 20 SHA3 2005 60 PUSH1 0x00 2007 61 PUSH2 0x0100 200A 0A EXP 200B 81 DUP2 200C 54 SLOAD 200D 81 DUP2 200E 60 PUSH1 0xff 2010 02 MUL 2011 19 NOT 2012 16 AND 2013 90 SWAP1 2014 83 DUP4 2015 15 ISZERO 2016 15 ISZERO 2017 02 MUL 2018 17 OR 2019 90 SWAP1 201A 55 SSTORE 201B 50 POP 201C 81 DUP2 201D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2032 16 AND 2033 33 CALLER 2034 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2049 16 AND 204A 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 206B 83 DUP4 206C 60 PUSH1 0x40 206E 51 MLOAD 206F 80 DUP1 2070 82 DUP3 2071 15 ISZERO 2072 15 ISZERO 2073 15 ISZERO 2074 15 ISZERO 2075 81 DUP2 2076 52 MSTORE 2077 60 PUSH1 0x20 2079 01 ADD 207A 91 SWAP2 207B 50 POP 207C 50 POP 207D 60 PUSH1 0x40 207F 51 MLOAD 2080 80 DUP1 2081 91 SWAP2 2082 03 SUB 2083 90 SWAP1 2084 A3 LOG3 2085 50 POP 2086 50 POP 2087 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @1FBB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1FC1 memory[0x20:0x40] = 0x01 // @1FF8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1FFE memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @201A storage[keccak256(memory[0x00:0x40])] = !!stack[-1] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @2076 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @2084 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-3] label_2088: // Incoming jump from 0x0DB1 2088 5B JUMPDEST 2089 61 PUSH2 0x2098 208C 61 PUSH2 0x2093 208F 61 PUSH2 0x2778 2092 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2089 stack[0] = 0x2098 // @208C stack[1] = 0x2093 // } // Block ends with call to 0x2778, returns to 0x2093 label_2093: // Incoming return from call to 0x2778 at 0x2092 2093 5B JUMPDEST 2094 61 PUSH2 0x2780 2097 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2780 label_2098: // Incoming return from call to 0x2093 at 0x2092 // Inputs[1] { @209C stack[-1] } 2098 5B JUMPDEST 2099 61 PUSH2 0x20ed 209C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x20ed, if stack[-1] label_209D: // Incoming jump from 0x209C, if not stack[-1] // Inputs[3] // { // @209F memory[0x40:0x60] // @20E7 memory[0x40:0x60] // @20EC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 209D 60 PUSH1 0x40 209F 51 MLOAD 20A0 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 20C1 81 DUP2 20C2 52 MSTORE 20C3 60 PUSH1 0x04 20C5 01 ADD 20C6 80 DUP1 20C7 80 DUP1 20C8 60 PUSH1 0x20 20CA 01 ADD 20CB 82 DUP3 20CC 81 DUP2 20CD 03 SUB 20CE 82 DUP3 20CF 52 MSTORE 20D0 60 PUSH1 0x2e 20D2 81 DUP2 20D3 52 MSTORE 20D4 60 PUSH1 0x20 20D6 01 ADD 20D7 80 DUP1 20D8 61 PUSH2 0x40f5 20DB 60 PUSH1 0x2e 20DD 91 SWAP2 20DE 39 CODECOPY 20DF 60 PUSH1 0x40 20E1 01 ADD 20E2 91 SWAP2 20E3 50 POP 20E4 50 POP 20E5 60 PUSH1 0x40 20E7 51 MLOAD 20E8 80 DUP1 20E9 91 SWAP2 20EA 03 SUB 20EB 90 SWAP1 20EC FD *REVERT // Stack delta = +0 // Outputs[5] // { // @20C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @20CF memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @20D3 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @20DE memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x40f5:0x4123] // @20EC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_20ED: // Incoming jump from 0x209C, if stack[-1] // Inputs[4] // { // @20F4 stack[-1] // @212E memory[0x00:0x40] // @2136 storage[keccak256(memory[0x00:0x40])] // @2147 stack[-2] // } 20ED 5B JUMPDEST 20EE 60 PUSH1 0x01 20F0 60 PUSH1 0x0a 20F2 60 PUSH1 0x00 20F4 83 DUP4 20F5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 210A 16 AND 210B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2120 16 AND 2121 81 DUP2 2122 52 MSTORE 2123 60 PUSH1 0x20 2125 01 ADD 2126 90 SWAP1 2127 81 DUP2 2128 52 MSTORE 2129 60 PUSH1 0x20 212B 01 ADD 212C 60 PUSH1 0x00 212E 20 SHA3 212F 60 PUSH1 0x00 2131 61 PUSH2 0x0100 2134 0A EXP 2135 81 DUP2 2136 54 SLOAD 2137 81 DUP2 2138 60 PUSH1 0xff 213A 02 MUL 213B 19 NOT 213C 16 AND 213D 90 SWAP1 213E 83 DUP4 213F 15 ISZERO 2140 15 ISZERO 2141 02 MUL 2142 17 OR 2143 90 SWAP1 2144 55 SSTORE 2145 50 POP 2146 50 POP 2147 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @2122 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @2128 memory[0x20:0x40] = 0x0a // @2144 storage[keccak256(memory[0x00:0x40])] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-2] label_2148: // Incoming jump from 0x0FB4 // Inputs[1] { @214E storage[0x09] } 2148 5B JUMPDEST 2149 60 PUSH1 0x09 214B 60 PUSH1 0x00 214D 90 SWAP1 214E 54 SLOAD 214F 90 SWAP1 2150 61 PUSH2 0x0100 2153 0A EXP 2154 90 SWAP1 2155 04 DIV 2156 60 PUSH1 0xff 2158 16 AND 2159 61 PUSH2 0x21ca 215C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x21ca, if 0xff & storage[0x09] / 0x0100 ** 0x00 label_215D: // Incoming jump from 0x215C, if not 0xff & storage[0x09] / 0x0100 ** 0x00 // Inputs[3] // { // @215F memory[0x40:0x60] // @21C4 memory[0x40:0x60] // @21C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 215D 60 PUSH1 0x40 215F 51 MLOAD 2160 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2181 81 DUP2 2182 52 MSTORE 2183 60 PUSH1 0x04 2185 01 ADD 2186 80 DUP1 2187 80 DUP1 2188 60 PUSH1 0x20 218A 01 ADD 218B 82 DUP3 218C 81 DUP2 218D 03 SUB 218E 82 DUP3 218F 52 MSTORE 2190 60 PUSH1 0x1f 2192 81 DUP2 2193 52 MSTORE 2194 60 PUSH1 0x20 2196 01 ADD 2197 80 DUP1 2198 7F PUSH32 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 21B9 81 DUP2 21BA 52 MSTORE 21BB 50 POP 21BC 60 PUSH1 0x20 21BE 01 ADD 21BF 91 SWAP2 21C0 50 POP 21C1 50 POP 21C2 60 PUSH1 0x40 21C4 51 MLOAD 21C5 80 DUP1 21C6 91 SWAP2 21C7 03 SUB 21C8 90 SWAP1 21C9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2182 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @218F memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2193 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1f // @21BA memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 // @21C9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_21CA: // Incoming jump from 0x215C, if 0xff & storage[0x09] / 0x0100 ** 0x00 // Inputs[3] // { // @21D6 storage[0x09] // @21EC stack[-3] // @21ED memory[stack[-3]:stack[-3] + 0x20] // } 21CA 5B JUMPDEST 21CB 60 PUSH1 0x00 21CD 60 PUSH1 0x09 21CF 60 PUSH1 0x00 21D1 61 PUSH2 0x0100 21D4 0A EXP 21D5 81 DUP2 21D6 54 SLOAD 21D7 81 DUP2 21D8 60 PUSH1 0xff 21DA 02 MUL 21DB 19 NOT 21DC 16 AND 21DD 90 SWAP1 21DE 83 DUP4 21DF 15 ISZERO 21E0 15 ISZERO 21E1 02 MUL 21E2 17 OR 21E3 90 SWAP1 21E4 55 SSTORE 21E5 50 POP 21E6 60 PUSH1 0x00 21E8 80 DUP1 21E9 90 SWAP1 21EA 50 POP 21EB 5B JUMPDEST 21EC 83 DUP4 21ED 51 MLOAD 21EE 81 DUP2 21EF 10 LT 21F0 15 ISZERO 21F1 61 PUSH2 0x2239 21F4 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @21E4 storage[0x09] = !!0x00 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x09]) // @21E9 stack[0] = 0x00 // } // Block ends with conditional jump to 0x2239, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_21F5: // Incoming jump from 0x21F4, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x21F4, if not !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) 21F5 61 PUSH2 0x222c 21F8 61 PUSH2 0x21ff 21FB 61 PUSH2 0x2778 21FE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @21F5 stack[0] = 0x222c // @21F8 stack[1] = 0x21ff // } // Block ends with call to 0x2778, returns to 0x21FF label_21FF: // Incoming return from call to 0x2778 at 0x21FE // Inputs[3] // { // @2200 stack[-6] // @2201 stack[-3] // @2203 memory[stack[-6]:stack[-6] + 0x20] // } 21FF 5B JUMPDEST 2200 85 DUP6 2201 83 DUP4 2202 81 DUP2 2203 51 MLOAD 2204 81 DUP2 2205 10 LT 2206 61 PUSH2 0x220b 2209 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2200 stack[0] = stack[-6] // @2201 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x220b, if stack[-3] < memory[stack[-6]:stack[-6] + 0x20] label_220A: // Incoming jump from 0x2209, if not stack[-3] < memory[stack[-6]:stack[-6] + 0x20] 220A FE *ASSERT // Stack delta = +0 // Outputs[1] { @220A assert(); } // Block terminates label_220B: // Incoming jump from 0x2209, if stack[-3] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[6] // { // @220E stack[-1] // @2212 stack[-2] // @2213 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2214 stack[-7] // @2215 stack[-5] // @2217 memory[stack[-7]:stack[-7] + 0x20] // } 220B 5B JUMPDEST 220C 60 PUSH1 0x20 220E 02 MUL 220F 60 PUSH1 0x20 2211 01 ADD 2212 01 ADD 2213 51 MLOAD 2214 85 DUP6 2215 84 DUP5 2216 81 DUP2 2217 51 MLOAD 2218 81 DUP2 2219 10 LT 221A 61 PUSH2 0x221f 221D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2213 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2214 stack[-1] = stack[-7] // @2215 stack[0] = stack[-5] // } // Block ends with conditional jump to 0x221f, if stack[-5] < memory[stack[-7]:stack[-7] + 0x20] label_221E: // Incoming jump from 0x221D, if not stack[-5] < memory[stack[-7]:stack[-7] + 0x20] 221E FE *ASSERT // Stack delta = +0 // Outputs[1] { @221E assert(); } // Block terminates label_221F: // Incoming jump from 0x221D, if stack[-5] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[3] // { // @2222 stack[-1] // @2226 stack[-2] // @2227 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 221F 5B JUMPDEST 2220 60 PUSH1 0x20 2222 02 MUL 2223 60 PUSH1 0x20 2225 01 ADD 2226 01 ADD 2227 51 MLOAD 2228 61 PUSH2 0x2dfa 222B 56 *JUMP // Stack delta = -1 // Outputs[1] { @2227 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2dfa label_222C: // Incoming return from call to 0x21FF at 0x21FE // Inputs[1] { @222D stack[-1] } 222C 5B JUMPDEST 222D 80 DUP1 222E 80 DUP1 222F 60 PUSH1 0x01 2231 01 ADD 2232 91 SWAP2 2233 50 POP 2234 50 POP 2235 61 PUSH2 0x21eb 2238 56 *JUMP // Stack delta = +0 // Outputs[1] { @2232 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x21eb label_2239: // Incoming jump from 0x21F4, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x21F4, if !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[4] // { // @223E stack[-5] // @223F stack[-4] // @2240 stack[-3] // @2241 stack[-2] // } 2239 5B JUMPDEST 223A 50 POP 223B 61 PUSH2 0x2246 223E 84 DUP5 223F 84 DUP5 2240 84 DUP5 2241 84 DUP5 2242 61 PUSH2 0x2faf 2245 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @223B stack[-1] = 0x2246 // @223E stack[0] = stack[-5] // @223F stack[1] = stack[-4] // @2240 stack[2] = stack[-3] // @2241 stack[3] = stack[-2] // } // Block ends with call to 0x2faf, returns to 0x2246 label_2246: // Incoming return from call to 0x2FAF at 0x2245 // Inputs[2] // { // @2252 storage[0x09] // @2266 stack[-5] // } 2246 5B JUMPDEST 2247 60 PUSH1 0x01 2249 60 PUSH1 0x09 224B 60 PUSH1 0x00 224D 61 PUSH2 0x0100 2250 0A EXP 2251 81 DUP2 2252 54 SLOAD 2253 81 DUP2 2254 60 PUSH1 0xff 2256 02 MUL 2257 19 NOT 2258 16 AND 2259 90 SWAP1 225A 83 DUP4 225B 15 ISZERO 225C 15 ISZERO 225D 02 MUL 225E 17 OR 225F 90 SWAP1 2260 55 SSTORE 2261 50 POP 2262 50 POP 2263 50 POP 2264 50 POP 2265 50 POP 2266 56 *JUMP // Stack delta = -5 // Outputs[1] { @2260 storage[0x09] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x09]) } // Block ends with unconditional jump to stack[-5] label_2267: // Incoming call from 0x26D1, returns to 0x26D2 // Incoming jump from 0x0FE2 // Inputs[4] // { // @226E stack[-1] // @227C memory[0x00:0x40] // @227D storage[keccak256(memory[0x00:0x40])] // @2280 stack[-2] // } 2267 5B JUMPDEST 2268 60 PUSH1 0x00 226A 60 PUSH1 0x06 226C 60 PUSH1 0x00 226E 83 DUP4 226F 81 DUP2 2270 52 MSTORE 2271 60 PUSH1 0x20 2273 01 ADD 2274 90 SWAP1 2275 81 DUP2 2276 52 MSTORE 2277 60 PUSH1 0x20 2279 01 ADD 227A 60 PUSH1 0x00 227C 20 SHA3 227D 54 SLOAD 227E 90 SWAP1 227F 50 POP 2280 91 SWAP2 2281 90 SWAP1 2282 50 POP 2283 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @2270 memory[0x00:0x20] = stack[-1] // @2276 memory[0x20:0x40] = 0x06 // @2280 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_2284: // Incoming call from 0x1000, returns to 0x1001 // Inputs[1] { @228B stack[-1] } 2284 5B JUMPDEST 2285 60 PUSH1 0x00 2287 60 PUSH1 0x01 2289 90 SWAP1 228A 50 POP 228B 90 SWAP1 228C 56 *JUMP // Stack delta = +0 // Outputs[1] { @228B stack[-1] = 0x01 } // Block ends with unconditional jump to stack[-1] label_228D: // Incoming call from 0x1022, returns to 0x1023 // Inputs[2] // { // @2293 storage[0x03] // @22B1 stack[-1] // } 228D 5B JUMPDEST 228E 60 PUSH1 0x03 2290 60 PUSH1 0x00 2292 90 SWAP1 2293 54 SLOAD 2294 90 SWAP1 2295 61 PUSH2 0x0100 2298 0A EXP 2299 90 SWAP1 229A 04 DIV 229B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 22B0 16 AND 22B1 81 DUP2 22B2 56 *JUMP // Stack delta = +1 // Outputs[1] { @22B0 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_22B3: // Incoming jump from 0x10A6 22B3 5B JUMPDEST 22B4 61 PUSH2 0x22c3 22B7 61 PUSH2 0x22be 22BA 61 PUSH2 0x2778 22BD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @22B4 stack[0] = 0x22c3 // @22B7 stack[1] = 0x22be // } // Block ends with call to 0x2778, returns to 0x22BE label_22BE: // Incoming return from call to 0x2778 at 0x22BD 22BE 5B JUMPDEST 22BF 61 PUSH2 0x2780 22C2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2780 label_22C3: // Incoming return from call to 0x22BE at 0x22BD // Inputs[1] { @22C7 stack[-1] } 22C3 5B JUMPDEST 22C4 61 PUSH2 0x2318 22C7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2318, if stack[-1] label_22C8: // Incoming jump from 0x22C7, if not stack[-1] // Inputs[3] // { // @22CA memory[0x40:0x60] // @2312 memory[0x40:0x60] // @2317 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 22C8 60 PUSH1 0x40 22CA 51 MLOAD 22CB 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 22EC 81 DUP2 22ED 52 MSTORE 22EE 60 PUSH1 0x04 22F0 01 ADD 22F1 80 DUP1 22F2 80 DUP1 22F3 60 PUSH1 0x20 22F5 01 ADD 22F6 82 DUP3 22F7 81 DUP2 22F8 03 SUB 22F9 82 DUP3 22FA 52 MSTORE 22FB 60 PUSH1 0x2e 22FD 81 DUP2 22FE 52 MSTORE 22FF 60 PUSH1 0x20 2301 01 ADD 2302 80 DUP1 2303 61 PUSH2 0x40f5 2306 60 PUSH1 0x2e 2308 91 SWAP2 2309 39 CODECOPY 230A 60 PUSH1 0x40 230C 01 ADD 230D 91 SWAP2 230E 50 POP 230F 50 POP 2310 60 PUSH1 0x40 2312 51 MLOAD 2313 80 DUP1 2314 91 SWAP2 2315 03 SUB 2316 90 SWAP1 2317 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @22ED memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @22FA memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @22FE memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @2309 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x40f5:0x4123] // @2317 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2318: // Incoming jump from 0x22C7, if stack[-1] // Inputs[3] // { // @2319 stack[-1] // @2323 storage[0x03] // @235B stack[-2] // } 2318 5B JUMPDEST 2319 80 DUP1 231A 60 PUSH1 0x03 231C 60 PUSH1 0x00 231E 61 PUSH2 0x0100 2321 0A EXP 2322 81 DUP2 2323 54 SLOAD 2324 81 DUP2 2325 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 233A 02 MUL 233B 19 NOT 233C 16 AND 233D 90 SWAP1 233E 83 DUP4 233F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2354 16 AND 2355 02 MUL 2356 17 OR 2357 90 SWAP1 2358 55 SSTORE 2359 50 POP 235A 50 POP 235B 56 *JUMP // Stack delta = -2 // Outputs[1] { @2358 storage[0x03] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x03]) } // Block ends with unconditional jump to stack[-2] label_235C: // Incoming call from 0x31D1, returns to 0x31D2 // Incoming call from 0x16B6, returns to 0x16B7 // Incoming jump from 0x110A // Inputs[2] // { // @2362 stack[-2] // @2363 stack[-1] // } 235C 5B JUMPDEST 235D 60 PUSH1 0x00 235F 61 PUSH2 0x2368 2362 83 DUP4 2363 83 DUP4 2364 61 PUSH2 0x3006 2367 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @235D stack[0] = 0x00 // @235F stack[1] = 0x2368 // @2362 stack[2] = stack[-2] // @2363 stack[3] = stack[-1] // } // Block ends with call to 0x3006, returns to 0x2368 label_2368: // Incoming return from call to 0x3006 at 0x2367 // Inputs[1] { @2369 stack[-1] } 2368 5B JUMPDEST 2369 15 ISZERO 236A 61 PUSH2 0x2376 236D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2376, if !stack[-1] label_236E: // Incoming jump from 0x236D, if not !stack[-1] // Inputs[1] { @2370 stack[-1] } 236E 60 PUSH1 0x01 2370 90 SWAP1 2371 50 POP 2372 61 PUSH2 0x2383 2375 56 *JUMP // Stack delta = +0 // Outputs[1] { @2370 stack[-1] = 0x01 } // Block ends with unconditional jump to 0x2383 label_2376: // Incoming jump from 0x236D, if !stack[-1] // Inputs[2] // { // @237A stack[-3] // @237B stack[-2] // } 2376 5B JUMPDEST 2377 61 PUSH2 0x2380 237A 83 DUP4 237B 83 DUP4 237C 61 PUSH2 0x3076 237F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2377 stack[0] = 0x2380 // @237A stack[1] = stack[-3] // @237B stack[2] = stack[-2] // } // Block ends with call to 0x3076, returns to 0x2380 label_2380: // Incoming return from call to 0x3076 at 0x237F // Inputs[2] // { // @2381 stack[-1] // @2381 stack[-2] // } 2380 5B JUMPDEST 2381 90 SWAP1 2382 50 POP // Stack delta = -1 // Outputs[1] { @2381 stack[-2] = stack[-1] } // Block continues label_2383: // Incoming jump from 0x2382 // Incoming jump from 0x2375 // Inputs[3] // { // @2384 stack[-4] // @2384 stack[-1] // @2385 stack[-3] // } 2383 5B JUMPDEST 2384 92 SWAP3 2385 91 SWAP2 2386 50 POP 2387 50 POP 2388 56 *JUMP // Stack delta = -3 // Outputs[1] { @2384 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2389: // Incoming jump from 0x1231 // Inputs[2] // { // @238F stack[-5] // @2390 stack[-3] // } 2389 5B JUMPDEST 238A 60 PUSH1 0x00 238C 61 PUSH2 0x2395 238F 86 DUP7 2390 85 DUP6 2391 61 PUSH2 0x24fe 2394 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @238A stack[0] = 0x00 // @238C stack[1] = 0x2395 // @238F stack[2] = stack[-5] // @2390 stack[3] = stack[-3] // } // Block ends with call to 0x24fe, returns to 0x2395 label_2395: // Incoming return from call to 0x24FE at 0x2394 // Inputs[3] // { // @2396 stack[-1] // @2396 stack[-2] // @2398 stack[-4] // } 2395 5B JUMPDEST 2396 90 SWAP1 2397 50 POP 2398 82 DUP3 2399 81 DUP2 239A 10 LT 239B 15 ISZERO 239C 61 PUSH2 0x23d9 239F 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2396 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x23d9, if !(stack[-1] < stack[-4]) label_23A0: // Incoming jump from 0x239F, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @23A3 stack[-5] // @23A4 stack[-4] // @23A8 stack[-1] // @23A9 stack[-3] // } 23A0 61 PUSH2 0x23bd 23A3 85 DUP6 23A4 85 DUP6 23A5 61 PUSH2 0x23b7 23A8 84 DUP5 23A9 87 DUP8 23AA 61 PUSH2 0x310a 23AD 90 SWAP1 23AE 91 SWAP2 23AF 90 SWAP1 23B0 63 PUSH4 0xffffffff 23B5 16 AND 23B6 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @23A0 stack[0] = 0x23bd // @23A3 stack[1] = stack[-5] // @23A4 stack[2] = stack[-4] // @23A5 stack[3] = 0x23b7 // @23AE stack[4] = stack[-3] // @23AF stack[5] = stack[-1] // } // Block ends with call to 0xffffffff & 0x310a, returns to 0x23B7 label_23B7: // Incoming return from call to 0x310A at 0x23B6 // Inputs[1] { @23B8 stack[-6] } 23B7 5B JUMPDEST 23B8 85 DUP6 23B9 61 PUSH2 0x1aaf 23BC 56 *JUMP // Stack delta = +1 // Outputs[1] { @23B8 stack[0] = stack[-6] } // Block ends with unconditional jump to 0x1aaf label_23BD: // Incoming return from call to 0x23B7 at 0x23B6 // Inputs[1] { @23C0 stack[-1] } 23BD 5B JUMPDEST 23BE 60 PUSH1 0x00 23C0 81 DUP2 23C1 11 GT 23C2 15 ISZERO 23C3 61 PUSH2 0x23d4 23C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x23d4, if !(stack[-1] > 0x00) label_23C7: // Incoming jump from 0x23C6, if not !(stack[-1] > 0x00) // Inputs[5] // { // @23CA stack[-6] // @23CB stack[-5] // @23CC stack[-4] // @23CD stack[-1] // @23CE stack[-2] // } 23C7 61 PUSH2 0x23d3 23CA 86 DUP7 23CB 86 DUP7 23CC 86 DUP7 23CD 84 DUP5 23CE 86 DUP7 23CF 61 PUSH2 0x3193 23D2 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @23C7 stack[0] = 0x23d3 // @23CA stack[1] = stack[-6] // @23CB stack[2] = stack[-5] // @23CC stack[3] = stack[-4] // @23CD stack[4] = stack[-1] // @23CE stack[5] = stack[-2] // } // Block ends with call to 0x3193, returns to 0x23D3 label_23D3: // Incoming return from call to 0x3193 at 0x23D2 23D3 5B JUMPDEST // Stack delta = +0 // Block continues label_23D4: // Incoming jump from 0x23D3 // Incoming jump from 0x23C6, if !(stack[-1] > 0x00) 23D4 5B JUMPDEST 23D5 61 PUSH2 0x23e7 23D8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x23e7 label_23D9: // Incoming jump from 0x239F, if !(stack[-1] < stack[-4]) // Inputs[5] // { // @23DD stack[-6] // @23DE stack[-5] // @23DF stack[-4] // @23E0 stack[-3] // @23E1 stack[-2] // } 23D9 5B JUMPDEST 23DA 61 PUSH2 0x23e6 23DD 86 DUP7 23DE 86 DUP7 23DF 86 DUP7 23E0 86 DUP7 23E1 86 DUP7 23E2 61 PUSH2 0x3193 23E5 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @23DA stack[0] = 0x23e6 // @23DD stack[1] = stack[-6] // @23DE stack[2] = stack[-5] // @23DF stack[3] = stack[-4] // @23E0 stack[4] = stack[-3] // @23E1 stack[5] = stack[-2] // } // Block ends with call to 0x3193, returns to 0x23E6 label_23E6: // Incoming return from call to 0x3193 at 0x23E5 // Inputs[1] { @23EE stack[-7] } 23E6 5B JUMPDEST 23E7 5B JUMPDEST 23E8 50 POP 23E9 50 POP 23EA 50 POP 23EB 50 POP 23EC 50 POP 23ED 50 POP 23EE 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_23EF: // Incoming jump from 0x1275 23EF 5B JUMPDEST 23F0 61 PUSH2 0x23ff 23F3 61 PUSH2 0x23fa 23F6 61 PUSH2 0x2778 23F9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23F0 stack[0] = 0x23ff // @23F3 stack[1] = 0x23fa // } // Block ends with call to 0x2778, returns to 0x23FA label_23FA: // Incoming return from call to 0x2778 at 0x23F9 23FA 5B JUMPDEST 23FB 61 PUSH2 0x2780 23FE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2780 label_23FF: // Incoming return from call to 0x23FA at 0x23F9 // Inputs[1] { @2403 stack[-1] } 23FF 5B JUMPDEST 2400 61 PUSH2 0x2454 2403 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2454, if stack[-1] label_2404: // Incoming jump from 0x2403, if not stack[-1] // Inputs[3] // { // @2406 memory[0x40:0x60] // @244E memory[0x40:0x60] // @2453 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2404 60 PUSH1 0x40 2406 51 MLOAD 2407 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2428 81 DUP2 2429 52 MSTORE 242A 60 PUSH1 0x04 242C 01 ADD 242D 80 DUP1 242E 80 DUP1 242F 60 PUSH1 0x20 2431 01 ADD 2432 82 DUP3 2433 81 DUP2 2434 03 SUB 2435 82 DUP3 2436 52 MSTORE 2437 60 PUSH1 0x2e 2439 81 DUP2 243A 52 MSTORE 243B 60 PUSH1 0x20 243D 01 ADD 243E 80 DUP1 243F 61 PUSH2 0x40f5 2442 60 PUSH1 0x2e 2444 91 SWAP2 2445 39 CODECOPY 2446 60 PUSH1 0x40 2448 01 ADD 2449 91 SWAP2 244A 50 POP 244B 50 POP 244C 60 PUSH1 0x40 244E 51 MLOAD 244F 80 DUP1 2450 91 SWAP2 2451 03 SUB 2452 90 SWAP1 2453 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2429 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2436 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @243A memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @2445 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x40f5:0x4123] // @2453 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2454: // Incoming jump from 0x2403, if stack[-1] // Inputs[1] { @2458 stack[-1] } 2454 5B JUMPDEST 2455 61 PUSH2 0x245d 2458 81 DUP2 2459 61 PUSH2 0x32cf 245C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2455 stack[0] = 0x245d // @2458 stack[1] = stack[-1] // } // Block ends with call to 0x32cf, returns to 0x245D label_245D: // Incoming return from call to 0x32CF at 0x245C // Inputs[1] { @245F stack[-2] } 245D 5B JUMPDEST 245E 50 POP 245F 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_2460: // Incoming call from 0x127F, returns to 0x1280 // Inputs[3] // { // @2464 storage[0x07] // @2485 memory[0x40:0x60] // @2498 storage[0x07] // } 2460 5B JUMPDEST 2461 60 PUSH1 0x07 2463 80 DUP1 2464 54 SLOAD 2465 60 PUSH1 0x01 2467 81 DUP2 2468 60 PUSH1 0x01 246A 16 AND 246B 15 ISZERO 246C 61 PUSH2 0x0100 246F 02 MUL 2470 03 SUB 2471 16 AND 2472 60 PUSH1 0x02 2474 90 SWAP1 2475 04 DIV 2476 80 DUP1 2477 60 PUSH1 0x1f 2479 01 ADD 247A 60 PUSH1 0x20 247C 80 DUP1 247D 91 SWAP2 247E 04 DIV 247F 02 MUL 2480 60 PUSH1 0x20 2482 01 ADD 2483 60 PUSH1 0x40 2485 51 MLOAD 2486 90 SWAP1 2487 81 DUP2 2488 01 ADD 2489 60 PUSH1 0x40 248B 52 MSTORE 248C 80 DUP1 248D 92 SWAP3 248E 91 SWAP2 248F 90 SWAP1 2490 81 DUP2 2491 81 DUP2 2492 52 MSTORE 2493 60 PUSH1 0x20 2495 01 ADD 2496 82 DUP3 2497 80 DUP1 2498 54 SLOAD 2499 60 PUSH1 0x01 249B 81 DUP2 249C 60 PUSH1 0x01 249E 16 AND 249F 15 ISZERO 24A0 61 PUSH2 0x0100 24A3 02 MUL 24A4 03 SUB 24A5 16 AND 24A6 60 PUSH1 0x02 24A8 90 SWAP1 24A9 04 DIV 24AA 80 DUP1 24AB 15 ISZERO 24AC 61 PUSH2 0x24f6 24AF 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @248B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) / 0x20 * 0x20 // @248D stack[0] = memory[0x40:0x60] // @248E stack[1] = 0x07 // @248F stack[2] = (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02 // @2492 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02 // @2495 stack[3] = 0x20 + memory[0x40:0x60] // @2496 stack[4] = 0x07 // @24A9 stack[5] = (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02 // } // Block ends with conditional jump to 0x24f6, if !((0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) label_24B0: // Incoming jump from 0x24AF, if not !((0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) // Inputs[1] { @24B0 stack[-1] } 24B0 80 DUP1 24B1 60 PUSH1 0x1f 24B3 10 LT 24B4 61 PUSH2 0x24cb 24B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x24cb, if 0x1f < stack[-1] label_24B8: // Incoming jump from 0x24B7, if not 0x1f < stack[-1] // Inputs[4] // { // @24BC stack[-2] // @24BD storage[stack[-2]] // @24C0 stack[-3] // @24C2 stack[-1] // } 24B8 61 PUSH2 0x0100 24BB 80 DUP1 24BC 83 DUP4 24BD 54 SLOAD 24BE 04 DIV 24BF 02 MUL 24C0 83 DUP4 24C1 52 MSTORE 24C2 91 SWAP2 24C3 60 PUSH1 0x20 24C5 01 ADD 24C6 91 SWAP2 24C7 61 PUSH2 0x24f6 24CA 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @24C1 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @24C6 stack[-1] = stack[-1] // @24C6 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x24f6 label_24CB: // Incoming jump from 0x24B7, if 0x1f < stack[-1] // Inputs[5] // { // @24CC stack[-3] // @24CD stack[-1] // @24CF stack[-2] // @24D7 memory[0x00:0x20] // @24DB storage[keccak256(memory[0x00:0x20])] // } 24CB 5B JUMPDEST 24CC 82 DUP3 24CD 01 ADD 24CE 91 SWAP2 24CF 90 SWAP1 24D0 60 PUSH1 0x00 24D2 52 MSTORE 24D3 60 PUSH1 0x20 24D5 60 PUSH1 0x00 24D7 20 SHA3 24D8 90 SWAP1 24D9 5B JUMPDEST 24DA 81 DUP2 24DB 54 SLOAD 24DC 81 DUP2 24DD 52 MSTORE 24DE 90 SWAP1 24DF 60 PUSH1 0x01 24E1 01 ADD 24E2 90 SWAP1 24E3 60 PUSH1 0x20 24E5 01 ADD 24E6 80 DUP1 24E7 83 DUP4 24E8 11 GT 24E9 61 PUSH2 0x24d9 24EC 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @24CE stack[-3] = stack[-3] + stack[-1] // @24D2 memory[0x00:0x20] = stack[-2] // @24DD memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @24E2 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @24E5 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x24d9, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_24ED: // Incoming jump from 0x24EC, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x24EC, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @24ED stack[-3] // @24EE stack[-1] // } 24ED 82 DUP3 24EE 90 SWAP1 24EF 03 SUB 24F0 60 PUSH1 0x1f 24F2 16 AND 24F3 82 DUP3 24F4 01 ADD 24F5 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @24F5 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @24F5 stack[-1] = stack[-3] // } // Block continues label_24F6: // Incoming jump from 0x24AF, if !((0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) // Incoming jump from 0x24CA // Incoming jump from 0x24F5 // Inputs[1] { @24FC stack[-7] } 24F6 5B JUMPDEST 24F7 50 POP 24F8 50 POP 24F9 50 POP 24FA 50 POP 24FB 50 POP 24FC 81 DUP2 24FD 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_24FE: // Incoming call from 0x2394, returns to 0x2395 // Incoming call from 0x1307, returns to 0x1308 // Inputs[6] // { // @2504 stack[-2] // @253E memory[0x00:0x40] // @2541 stack[-1] // @254F memory[0x00:0x40] // @2550 storage[keccak256(memory[0x00:0x40])] // @2553 stack[-3] // } 24FE 5B JUMPDEST 24FF 60 PUSH1 0x00 2501 80 DUP1 2502 60 PUSH1 0x00 2504 84 DUP5 2505 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 251A 16 AND 251B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2530 16 AND 2531 81 DUP2 2532 52 MSTORE 2533 60 PUSH1 0x20 2535 01 ADD 2536 90 SWAP1 2537 81 DUP2 2538 52 MSTORE 2539 60 PUSH1 0x20 253B 01 ADD 253C 60 PUSH1 0x00 253E 20 SHA3 253F 60 PUSH1 0x00 2541 83 DUP4 2542 81 DUP2 2543 52 MSTORE 2544 60 PUSH1 0x20 2546 01 ADD 2547 90 SWAP1 2548 81 DUP2 2549 52 MSTORE 254A 60 PUSH1 0x20 254C 01 ADD 254D 60 PUSH1 0x00 254F 20 SHA3 2550 54 SLOAD 2551 90 SWAP1 2552 50 POP 2553 92 SWAP3 2554 91 SWAP2 2555 50 POP 2556 50 POP 2557 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @2532 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @2538 memory[0x20:0x40] = 0x00 // @2543 memory[0x00:0x20] = stack[-1] // @2549 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2553 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_2558: // Incoming jump from 0x1BBC // Incoming call from 0x2E03, returns to 0x2E04 // Incoming call from 0x1313, returns to 0x1314 // Incoming jump from 0x1CBB // Inputs[3] // { // @2576 stack[-2] // @2584 memory[0x00:0x40] // @2588 storage[keccak256(memory[0x00:0x40])] // } 2558 5B JUMPDEST 2559 60 PUSH1 0x00 255B 80 DUP1 255C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2571 16 AND 2572 60 PUSH1 0x0b 2574 60 PUSH1 0x00 2576 85 DUP6 2577 81 DUP2 2578 52 MSTORE 2579 60 PUSH1 0x20 257B 01 ADD 257C 90 SWAP1 257D 81 DUP2 257E 52 MSTORE 257F 60 PUSH1 0x20 2581 01 ADD 2582 60 PUSH1 0x00 2584 20 SHA3 2585 60 PUSH1 0x00 2587 90 SWAP1 2588 54 SLOAD 2589 90 SWAP1 258A 61 PUSH2 0x0100 258D 0A EXP 258E 90 SWAP1 258F 04 DIV 2590 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25A5 16 AND 25A6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25BB 16 AND 25BC 14 EQ 25BD 61 PUSH2 0x266d 25C0 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2559 stack[0] = 0x00 // @2578 memory[0x00:0x20] = stack[-2] // @257E memory[0x20:0x40] = 0x0b // } // Block ends with conditional jump to 0x266d, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 label_25C1: // Incoming jump from 0x25C0, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // Inputs[4] // { // @25C1 stack[-2] // @25DC stack[-3] // @25EA memory[0x00:0x40] // @25EE storage[keccak256(memory[0x00:0x40])] // } 25C1 81 DUP2 25C2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25D7 16 AND 25D8 60 PUSH1 0x0b 25DA 60 PUSH1 0x00 25DC 85 DUP6 25DD 81 DUP2 25DE 52 MSTORE 25DF 60 PUSH1 0x20 25E1 01 ADD 25E2 90 SWAP1 25E3 81 DUP2 25E4 52 MSTORE 25E5 60 PUSH1 0x20 25E7 01 ADD 25E8 60 PUSH1 0x00 25EA 20 SHA3 25EB 60 PUSH1 0x00 25ED 90 SWAP1 25EE 54 SLOAD 25EF 90 SWAP1 25F0 61 PUSH2 0x0100 25F3 0A EXP 25F4 90 SWAP1 25F5 04 DIV 25F6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 260B 16 AND 260C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2621 16 AND 2622 14 EQ 2623 80 DUP1 2624 61 PUSH2 0x2666 2627 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @25DE memory[0x00:0x20] = stack[-3] // @25E4 memory[0x20:0x40] = 0x0b // @2622 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // } // Block ends with conditional jump to 0x2666, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] label_2628: // Incoming jump from 0x2627, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // Inputs[4] // { // @2630 stack[-4] // @263E memory[0x00:0x40] // @2642 storage[keccak256(memory[0x00:0x40])] // @2660 stack[-3] // } 2628 50 POP 2629 61 PUSH2 0x2665 262C 60 PUSH1 0x0b 262E 60 PUSH1 0x00 2630 85 DUP6 2631 81 DUP2 2632 52 MSTORE 2633 60 PUSH1 0x20 2635 01 ADD 2636 90 SWAP1 2637 81 DUP2 2638 52 MSTORE 2639 60 PUSH1 0x20 263B 01 ADD 263C 60 PUSH1 0x00 263E 20 SHA3 263F 60 PUSH1 0x00 2641 90 SWAP1 2642 54 SLOAD 2643 90 SWAP1 2644 61 PUSH2 0x0100 2647 0A EXP 2648 90 SWAP1 2649 04 DIV 264A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 265F 16 AND 2660 83 DUP4 2661 61 PUSH2 0x3006 2664 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @2629 stack[-1] = 0x2665 // @2632 memory[0x00:0x20] = stack[-4] // @2638 memory[0x20:0x40] = 0x0b // @265F stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // @2660 stack[1] = stack[-3] // } // Block ends with call to 0x3006, returns to 0x2665 label_2665: // Incoming return from call to 0x3006 at 0x2664 2665 5B JUMPDEST // Stack delta = +0 // Block continues label_2666: // Incoming jump from 0x2627, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // Incoming jump from 0x2665 // Inputs[2] // { // @2667 stack[-2] // @2667 stack[-1] // } 2666 5B JUMPDEST 2667 90 SWAP1 2668 50 POP 2669 61 PUSH2 0x26be 266C 56 *JUMP // Stack delta = -1 // Outputs[1] { @2667 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x26be label_266D: // Incoming jump from 0x25C0, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // Inputs[1] { @2673 stack[-3] } 266D 5B JUMPDEST 266E 60 PUSH1 0x00 2670 61 PUSH2 0x2678 2673 84 DUP5 2674 61 PUSH2 0x3415 2677 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @266E stack[0] = 0x00 // @2670 stack[1] = 0x2678 // @2673 stack[2] = stack[-3] // } // Block ends with call to 0x3415, returns to 0x2678 label_2678: // Incoming return from call to 0x3415 at 0x2677 // Inputs[3] // { // @2679 stack[-2] // @2679 stack[-1] // @267B stack[-4] // } 2678 5B JUMPDEST 2679 90 SWAP1 267A 50 POP 267B 82 DUP3 267C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2691 16 AND 2692 81 DUP2 2693 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26A8 16 AND 26A9 14 EQ 26AA 80 DUP1 26AB 61 PUSH2 0x26ba 26AE 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2679 stack[-2] = stack[-1] // @26A9 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // } // Block ends with conditional jump to 0x26ba, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] label_26AF: // Incoming jump from 0x26AE, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // Inputs[2] // { // @26B3 stack[-2] // @26B4 stack[-4] // } 26AF 50 POP 26B0 61 PUSH2 0x26b9 26B3 81 DUP2 26B4 84 DUP5 26B5 61 PUSH2 0x3006 26B8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @26B0 stack[-1] = 0x26b9 // @26B3 stack[0] = stack[-2] // @26B4 stack[1] = stack[-4] // } // Block ends with call to 0x3006, returns to 0x26B9 label_26B9: // Incoming return from call to 0x3006 at 0x26B8 26B9 5B JUMPDEST // Stack delta = +0 // Block continues label_26BA: // Incoming jump from 0x26AE, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // Incoming jump from 0x26B9 // Inputs[2] // { // @26BB stack[-1] // @26BB stack[-3] // } 26BA 5B JUMPDEST 26BB 91 SWAP2 26BC 50 POP 26BD 50 POP // Stack delta = -2 // Outputs[1] { @26BB stack[-3] = stack[-1] } // Block continues label_26BE: // Incoming jump from 0x266C // Incoming jump from 0x26BD // Inputs[3] // { // @26BF stack[-4] // @26BF stack[-1] // @26C0 stack[-3] // } 26BE 5B JUMPDEST 26BF 92 SWAP3 26C0 91 SWAP2 26C1 50 POP 26C2 50 POP 26C3 56 *JUMP // Stack delta = -3 // Outputs[1] { @26BF stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_26C4: // Incoming call from 0x1329, returns to 0x132A // Incoming call from 0x2E62, returns to 0x2E63 // Inputs[1] { @26CD stack[-1] } 26C4 5B JUMPDEST 26C5 60 PUSH1 0x00 26C7 61 PUSH2 0x26e9 26CA 61 PUSH2 0x26d2 26CD 83 DUP4 26CE 61 PUSH2 0x2267 26D1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @26C5 stack[0] = 0x00 // @26C7 stack[1] = 0x26e9 // @26CA stack[2] = 0x26d2 // @26CD stack[3] = stack[-1] // } // Block ends with call to 0x2267, returns to 0x26D2 label_26D2: // Incoming return from call to 0x2267 at 0x26D1 // Inputs[1] { @26D6 stack[-4] } 26D2 5B JUMPDEST 26D3 61 PUSH2 0x26db 26D6 84 DUP5 26D7 61 PUSH2 0x3429 26DA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @26D3 stack[0] = 0x26db // @26D6 stack[1] = stack[-4] // } // Block ends with call to 0x3429, returns to 0x26DB label_26DB: // Incoming return from call to 0x3429 at 0x26DA // Inputs[2] // { // @26DF stack[-1] // @26E0 stack[-2] // } 26DB 5B JUMPDEST 26DC 61 PUSH2 0x310a 26DF 90 SWAP1 26E0 91 SWAP2 26E1 90 SWAP1 26E2 63 PUSH4 0xffffffff 26E7 16 AND 26E8 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @26E0 stack[-2] = stack[-1] // @26E1 stack[-1] = stack[-2] // } // Block ends with unconditional jump to 0xffffffff & 0x310a label_26E9: // Incoming return from call to 0x26D2 at 0x26D1 // Inputs[4] // { // @26EA stack[-1] // @26EA stack[-2] // @26EC stack[-4] // @26ED stack[-3] // } 26E9 5B JUMPDEST 26EA 90 SWAP1 26EB 50 POP 26EC 91 SWAP2 26ED 90 SWAP1 26EE 50 POP 26EF 56 *JUMP // Stack delta = -3 // Outputs[1] { @26EC stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_26F0: // Incoming call from 0x355F, returns to 0x3560 // Incoming call from 0x3AEA, returns to 0x3AEB // Incoming jump from 0x1338 // Incoming call from 0x34E6, returns to 0x34E7 // Incoming jump from 0x29BA // Incoming jump from 0x3850 // Incoming jump from 0x37C4 // Inputs[2] // { // @26F4 stack[-1] // @26F5 stack[-2] // } 26F0 5B JUMPDEST 26F1 60 PUSH1 0x00 26F3 80 DUP1 26F4 82 DUP3 26F5 84 DUP5 26F6 01 ADD 26F7 90 SWAP1 26F8 50 POP 26F9 83 DUP4 26FA 81 DUP2 26FB 10 LT 26FC 15 ISZERO 26FD 61 PUSH2 0x276e 2700 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @26F1 stack[0] = 0x00 // @26F7 stack[1] = stack[-2] + stack[-1] // } // Block ends with conditional jump to 0x276e, if !(stack[-2] + stack[-1] < stack[-2]) label_2701: // Incoming jump from 0x2700, if not !(stack[-2] + stack[-1] < stack[-2]) // Inputs[3] // { // @2703 memory[0x40:0x60] // @2768 memory[0x40:0x60] // @276D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2701 60 PUSH1 0x40 2703 51 MLOAD 2704 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2725 81 DUP2 2726 52 MSTORE 2727 60 PUSH1 0x04 2729 01 ADD 272A 80 DUP1 272B 80 DUP1 272C 60 PUSH1 0x20 272E 01 ADD 272F 82 DUP3 2730 81 DUP2 2731 03 SUB 2732 82 DUP3 2733 52 MSTORE 2734 60 PUSH1 0x16 2736 81 DUP2 2737 52 MSTORE 2738 60 PUSH1 0x20 273A 01 ADD 273B 80 DUP1 273C 7F PUSH32 0x536166654d617468236164643a204f564552464c4f5700000000000000000000 275D 81 DUP2 275E 52 MSTORE 275F 50 POP 2760 60 PUSH1 0x20 2762 01 ADD 2763 91 SWAP2 2764 50 POP 2765 50 POP 2766 60 PUSH1 0x40 2768 51 MLOAD 2769 80 DUP1 276A 91 SWAP2 276B 03 SUB 276C 90 SWAP1 276D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2726 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2733 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2737 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x16 // @275E memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x536166654d617468236164643a204f564552464c4f5700000000000000000000 // @276D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_276E: // Incoming jump from 0x2700, if !(stack[-2] + stack[-1] < stack[-2]) // Inputs[4] // { // @276F stack[-1] // @2770 stack[-2] // @2773 stack[-5] // @2774 stack[-4] // } 276E 5B JUMPDEST 276F 80 DUP1 2770 91 SWAP2 2771 50 POP 2772 50 POP 2773 92 SWAP3 2774 91 SWAP2 2775 50 POP 2776 50 POP 2777 56 *JUMP // Stack delta = -4 // Outputs[1] { @2773 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2778: // Incoming call from 0x23F9, returns to 0x23FA // Incoming call from 0x1993, returns to 0x1994 // Incoming call from 0x1603, returns to 0x1604 // Incoming call from 0x1CB6, returns to 0x1CB7 // Incoming call from 0x1BB7, returns to 0x1BB8 // Incoming call from 0x22BD, returns to 0x22BE // Incoming call from 0x1B56, returns to 0x1B57 // Incoming call from 0x21FE, returns to 0x21FF // Incoming call from 0x1C8D, returns to 0x1C8E // Incoming call from 0x1EDA, returns to 0x1EDB // Incoming call from 0x2092, returns to 0x2093 // Inputs[2] // { // @277B msg.sender // @277E stack[-1] // } 2778 5B JUMPDEST 2779 60 PUSH1 0x00 277B 33 CALLER 277C 90 SWAP1 277D 50 POP 277E 90 SWAP1 277F 56 *JUMP // Stack delta = +0 // Outputs[1] { @277E stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_2780: // Incoming jump from 0x22C2 // Incoming jump from 0x1608 // Incoming jump from 0x1EDF // Incoming jump from 0x23FE // Incoming jump from 0x1998 // Incoming jump from 0x2097 // Inputs[1] { @2783 stack[-1] } 2780 5B JUMPDEST 2781 60 PUSH1 0x00 2783 81 DUP2 2784 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2799 16 AND 279A 61 PUSH2 0x27a1 279D 61 PUSH2 0x1c21 27A0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2781 stack[0] = 0x00 // @2799 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @279A stack[2] = 0x27a1 // } // Block ends with call to 0x1c21, returns to 0x27A1 label_27A1: // Incoming return from call to 0x1C21 at 0x27A0 // Inputs[2] // { // @27B7 stack[-1] // @27B8 stack[-2] // } 27A1 5B JUMPDEST 27A2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27B7 16 AND 27B8 14 EQ 27B9 80 DUP1 27BA 61 PUSH2 0x27d0 27BD 57 *JUMPI // Stack delta = -1 // Outputs[1] { @27B8 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x27d0, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_27BE: // Incoming jump from 0x27BD, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] 27BE 50 POP 27BF 61 PUSH2 0x27cf 27C2 61 PUSH2 0x27c9 27C5 61 PUSH2 0x1c21 27C8 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @27BF stack[-1] = 0x27cf // @27C2 stack[0] = 0x27c9 // } // Block ends with call to 0x1c21, returns to 0x27C9 label_27C9: // Incoming return from call to 0x1C21 at 0x27C8 // Inputs[1] { @27CA stack[-4] } 27C9 5B JUMPDEST 27CA 83 DUP4 27CB 61 PUSH2 0x3006 27CE 56 *JUMP // Stack delta = +1 // Outputs[1] { @27CA stack[0] = stack[-4] } // Block ends with unconditional jump to 0x3006 label_27CF: // Incoming return from call to 0x27C9 at 0x27C8 27CF 5B JUMPDEST // Stack delta = +0 // Block continues label_27D0: // Incoming jump from 0x27CF // Incoming jump from 0x27BD, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[4] // { // @27D1 stack[-2] // @27D1 stack[-1] // @27D3 stack[-4] // @27D4 stack[-3] // } 27D0 5B JUMPDEST 27D1 90 SWAP1 27D2 50 POP 27D3 91 SWAP2 27D4 90 SWAP1 27D5 50 POP 27D6 56 *JUMP // Stack delta = -3 // Outputs[1] { @27D3 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_27D7: // Incoming call from 0x179E, returns to 0x179F // Inputs[4] // { // @27D8 stack[-1] // @27D9 memory[stack[-1]:stack[-1] + 0x20] // @27DA stack[-2] // @27DB memory[stack[-2]:stack[-2] + 0x20] // } 27D7 5B JUMPDEST 27D8 80 DUP1 27D9 51 MLOAD 27DA 82 DUP3 27DB 51 MLOAD 27DC 14 EQ 27DD 61 PUSH2 0x2831 27E0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2831, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] label_27E1: // Incoming jump from 0x27E0, if not memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @27E3 memory[0x40:0x60] // @282B memory[0x40:0x60] // @2830 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 27E1 60 PUSH1 0x40 27E3 51 MLOAD 27E4 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2805 81 DUP2 2806 52 MSTORE 2807 60 PUSH1 0x04 2809 01 ADD 280A 80 DUP1 280B 80 DUP1 280C 60 PUSH1 0x20 280E 01 ADD 280F 82 DUP3 2810 81 DUP2 2811 03 SUB 2812 82 DUP3 2813 52 MSTORE 2814 60 PUSH1 0x35 2816 81 DUP2 2817 52 MSTORE 2818 60 PUSH1 0x20 281A 01 ADD 281B 80 DUP1 281C 61 PUSH2 0x4123 281F 60 PUSH1 0x35 2821 91 SWAP2 2822 39 CODECOPY 2823 60 PUSH1 0x40 2825 01 ADD 2826 91 SWAP2 2827 50 POP 2828 50 POP 2829 60 PUSH1 0x40 282B 51 MLOAD 282C 80 DUP1 282D 91 SWAP2 282E 03 SUB 282F 90 SWAP1 2830 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2806 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2813 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2817 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x35 // @2822 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x35] = code[0x4123:0x4158] // @2830 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2831: // Incoming jump from 0x27E0, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[2] // { // @2834 stack[-2] // @2835 memory[stack[-2]:stack[-2] + 0x20] // } 2831 5B JUMPDEST 2832 60 PUSH1 0x00 2834 82 DUP3 2835 51 MLOAD 2836 90 SWAP1 2837 50 POP 2838 60 PUSH1 0x00 283A 80 DUP1 283B 90 SWAP1 283C 50 POP 283D 5B JUMPDEST 283E 81 DUP2 283F 81 DUP2 2840 10 LT 2841 15 ISZERO 2842 61 PUSH2 0x2a2e 2845 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2836 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @283B stack[1] = 0x00 // } // Block ends with conditional jump to 0x2a2e, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_2846: // Incoming jump from 0x2845, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x2845, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @2849 stack[-3] // @284A stack[-1] // @284C memory[stack[-3]:stack[-3] + 0x20] // } 2846 61 PUSH2 0x28cd 2849 83 DUP4 284A 82 DUP3 284B 81 DUP2 284C 51 MLOAD 284D 81 DUP2 284E 10 LT 284F 61 PUSH2 0x2854 2852 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2846 stack[0] = 0x28cd // @2849 stack[1] = stack[-3] // @284A stack[2] = stack[-1] // } // Block ends with conditional call to 0x2854, returns to 0x28CD, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_2853: // Incoming jump from 0x2852, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 2853 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2853 assert(); } // Block terminates label_2854: // Incoming call from 0x2852, returns to 0x28CD, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[8] // { // @2857 stack[-1] // @285B stack[-2] // @285C memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2860 stack[-9] // @289A memory[0x00:0x40] // @289D stack[-7] // @289E stack[-4] // @28A0 memory[stack[-7]:stack[-7] + 0x20] // } 2854 5B JUMPDEST 2855 60 PUSH1 0x20 2857 02 MUL 2858 60 PUSH1 0x20 285A 01 ADD 285B 01 ADD 285C 51 MLOAD 285D 60 PUSH1 0x00 285F 80 DUP1 2860 89 DUP10 2861 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2876 16 AND 2877 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 288C 16 AND 288D 81 DUP2 288E 52 MSTORE 288F 60 PUSH1 0x20 2891 01 ADD 2892 90 SWAP1 2893 81 DUP2 2894 52 MSTORE 2895 60 PUSH1 0x20 2897 01 ADD 2898 60 PUSH1 0x00 289A 20 SHA3 289B 60 PUSH1 0x00 289D 87 DUP8 289E 85 DUP6 289F 81 DUP2 28A0 51 MLOAD 28A1 81 DUP2 28A2 10 LT 28A3 61 PUSH2 0x28a8 28A6 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @285C stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @288E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-9] // @2894 memory[0x20:0x40] = 0x00 // @289A stack[-1] = keccak256(memory[0x00:0x40]) // @289B stack[0] = 0x00 // @289D stack[1] = stack[-7] // @289E stack[2] = stack[-4] // } // Block ends with conditional jump to 0x28a8, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] label_28A7: // Incoming jump from 0x28A6, if not stack[-4] < memory[stack[-7]:stack[-7] + 0x20] 28A7 FE *ASSERT // Stack delta = +0 // Outputs[1] { @28A7 assert(); } // Block terminates label_28A8: // Incoming jump from 0x28A6, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[8] // { // @28AB stack[-1] // @28AF stack[-2] // @28B0 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @28B1 stack[-3] // @28B6 stack[-4] // @28BE memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @28BF storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @28C4 stack[-5] // } 28A8 5B JUMPDEST 28A9 60 PUSH1 0x20 28AB 02 MUL 28AC 60 PUSH1 0x20 28AE 01 ADD 28AF 01 ADD 28B0 51 MLOAD 28B1 81 DUP2 28B2 52 MSTORE 28B3 60 PUSH1 0x20 28B5 01 ADD 28B6 90 SWAP1 28B7 81 DUP2 28B8 52 MSTORE 28B9 60 PUSH1 0x20 28BB 01 ADD 28BC 60 PUSH1 0x00 28BE 20 SHA3 28BF 54 SLOAD 28C0 61 PUSH2 0x310a 28C3 90 SWAP1 28C4 91 SWAP2 28C5 90 SWAP1 28C6 63 PUSH4 0xffffffff 28CB 16 AND 28CC 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @28B2 memory[stack[-3]:stack[-3] + 0x20] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @28B8 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @28C4 stack[-5] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @28C5 stack[-4] = stack[-5] // } // Block ends with unconditional jump to 0xffffffff & 0x310a label_28CD: // Incoming return from call to 0x2854 at 0x2852 // Inputs[5] // { // @28D1 stack[-7] // @290B memory[0x00:0x40] // @290E stack[-5] // @290F stack[-2] // @2911 memory[stack[-5]:stack[-5] + 0x20] // } 28CD 5B JUMPDEST 28CE 60 PUSH1 0x00 28D0 80 DUP1 28D1 88 DUP9 28D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 28E7 16 AND 28E8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 28FD 16 AND 28FE 81 DUP2 28FF 52 MSTORE 2900 60 PUSH1 0x20 2902 01 ADD 2903 90 SWAP1 2904 81 DUP2 2905 52 MSTORE 2906 60 PUSH1 0x20 2908 01 ADD 2909 60 PUSH1 0x00 290B 20 SHA3 290C 60 PUSH1 0x00 290E 86 DUP7 290F 84 DUP5 2910 81 DUP2 2911 51 MLOAD 2912 81 DUP2 2913 10 LT 2914 61 PUSH2 0x2919 2917 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @28FF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @2905 memory[0x20:0x40] = 0x00 // @290B stack[0] = keccak256(memory[0x00:0x40]) // @290C stack[1] = 0x00 // @290E stack[2] = stack[-5] // @290F stack[3] = stack[-2] // } // Block ends with conditional jump to 0x2919, if stack[-2] < memory[stack[-5]:stack[-5] + 0x20] label_2918: // Incoming jump from 0x2917, if not stack[-2] < memory[stack[-5]:stack[-5] + 0x20] 2918 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2918 assert(); } // Block terminates label_2919: // Incoming jump from 0x2917, if stack[-2] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[10] // { // @291C stack[-1] // @2920 stack[-2] // @2921 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2922 stack[-3] // @2927 stack[-4] // @292F memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @2930 stack[-5] // @2937 stack[-8] // @2938 stack[-6] // @293A memory[stack[-8]:stack[-8] + 0x20] // } 2919 5B JUMPDEST 291A 60 PUSH1 0x20 291C 02 MUL 291D 60 PUSH1 0x20 291F 01 ADD 2920 01 ADD 2921 51 MLOAD 2922 81 DUP2 2923 52 MSTORE 2924 60 PUSH1 0x20 2926 01 ADD 2927 90 SWAP1 2928 81 DUP2 2929 52 MSTORE 292A 60 PUSH1 0x20 292C 01 ADD 292D 60 PUSH1 0x00 292F 20 SHA3 2930 81 DUP2 2931 90 SWAP1 2932 55 SSTORE 2933 50 POP 2934 61 PUSH2 0x29bb 2937 83 DUP4 2938 82 DUP3 2939 81 DUP2 293A 51 MLOAD 293B 81 DUP2 293C 10 LT 293D 61 PUSH2 0x2942 2940 57 *JUMPI // Stack delta = -2 // Outputs[6] // { // @2923 memory[stack[-3]:stack[-3] + 0x20] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2929 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @2932 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] = stack[-5] // @2934 stack[-5] = 0x29bb // @2937 stack[-4] = stack[-8] // @2938 stack[-3] = stack[-6] // } // Block ends with conditional call to 0x2942, returns to 0x29BB, if stack[-6] < memory[stack[-8]:stack[-8] + 0x20] label_2941: // Incoming jump from 0x2940, if not stack[-6] < memory[stack[-8]:stack[-8] + 0x20] 2941 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2941 assert(); } // Block terminates label_2942: // Incoming call from 0x2940, returns to 0x29BB, if stack[-6] < memory[stack[-8]:stack[-8] + 0x20] // Inputs[8] // { // @2945 stack[-1] // @2949 stack[-2] // @294A memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @294E stack[-8] // @2988 memory[0x00:0x40] // @298B stack[-7] // @298C stack[-4] // @298E memory[stack[-7]:stack[-7] + 0x20] // } 2942 5B JUMPDEST 2943 60 PUSH1 0x20 2945 02 MUL 2946 60 PUSH1 0x20 2948 01 ADD 2949 01 ADD 294A 51 MLOAD 294B 60 PUSH1 0x00 294D 80 DUP1 294E 88 DUP9 294F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2964 16 AND 2965 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 297A 16 AND 297B 81 DUP2 297C 52 MSTORE 297D 60 PUSH1 0x20 297F 01 ADD 2980 90 SWAP1 2981 81 DUP2 2982 52 MSTORE 2983 60 PUSH1 0x20 2985 01 ADD 2986 60 PUSH1 0x00 2988 20 SHA3 2989 60 PUSH1 0x00 298B 87 DUP8 298C 85 DUP6 298D 81 DUP2 298E 51 MLOAD 298F 81 DUP2 2990 10 LT 2991 61 PUSH2 0x2996 2994 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @294A stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @297C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-8] // @2982 memory[0x20:0x40] = 0x00 // @2988 stack[-1] = keccak256(memory[0x00:0x40]) // @2989 stack[0] = 0x00 // @298B stack[1] = stack[-7] // @298C stack[2] = stack[-4] // } // Block ends with conditional jump to 0x2996, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] label_2995: // Incoming jump from 0x2994, if not stack[-4] < memory[stack[-7]:stack[-7] + 0x20] 2995 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2995 assert(); } // Block terminates label_2996: // Incoming jump from 0x2994, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[8] // { // @2999 stack[-1] // @299D stack[-2] // @299E memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @299F stack[-3] // @29A4 stack[-4] // @29AC memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @29AD storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @29B2 stack[-5] // } 2996 5B JUMPDEST 2997 60 PUSH1 0x20 2999 02 MUL 299A 60 PUSH1 0x20 299C 01 ADD 299D 01 ADD 299E 51 MLOAD 299F 81 DUP2 29A0 52 MSTORE 29A1 60 PUSH1 0x20 29A3 01 ADD 29A4 90 SWAP1 29A5 81 DUP2 29A6 52 MSTORE 29A7 60 PUSH1 0x20 29A9 01 ADD 29AA 60 PUSH1 0x00 29AC 20 SHA3 29AD 54 SLOAD 29AE 61 PUSH2 0x26f0 29B1 90 SWAP1 29B2 91 SWAP2 29B3 90 SWAP1 29B4 63 PUSH4 0xffffffff 29B9 16 AND 29BA 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @29A0 memory[stack[-3]:stack[-3] + 0x20] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @29A6 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @29B2 stack[-5] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @29B3 stack[-4] = stack[-5] // } // Block ends with unconditional jump to 0xffffffff & 0x26f0 label_29BB: // Incoming return from call to 0x2942 at 0x2940 // Inputs[5] // { // @29BF stack[-6] // @29F9 memory[0x00:0x40] // @29FC stack[-5] // @29FD stack[-2] // @29FF memory[stack[-5]:stack[-5] + 0x20] // } 29BB 5B JUMPDEST 29BC 60 PUSH1 0x00 29BE 80 DUP1 29BF 87 DUP8 29C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29D5 16 AND 29D6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29EB 16 AND 29EC 81 DUP2 29ED 52 MSTORE 29EE 60 PUSH1 0x20 29F0 01 ADD 29F1 90 SWAP1 29F2 81 DUP2 29F3 52 MSTORE 29F4 60 PUSH1 0x20 29F6 01 ADD 29F7 60 PUSH1 0x00 29F9 20 SHA3 29FA 60 PUSH1 0x00 29FC 86 DUP7 29FD 84 DUP5 29FE 81 DUP2 29FF 51 MLOAD 2A00 81 DUP2 2A01 10 LT 2A02 61 PUSH2 0x2a07 2A05 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @29ED memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @29F3 memory[0x20:0x40] = 0x00 // @29F9 stack[0] = keccak256(memory[0x00:0x40]) // @29FA stack[1] = 0x00 // @29FC stack[2] = stack[-5] // @29FD stack[3] = stack[-2] // } // Block ends with conditional jump to 0x2a07, if stack[-2] < memory[stack[-5]:stack[-5] + 0x20] label_2A06: // Incoming jump from 0x2A05, if not stack[-2] < memory[stack[-5]:stack[-5] + 0x20] 2A06 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2A06 assert(); } // Block terminates label_2A07: // Incoming jump from 0x2A05, if stack[-2] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[8] // { // @2A0A stack[-1] // @2A0E stack[-2] // @2A0F memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2A10 stack[-3] // @2A15 stack[-4] // @2A1D memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @2A1E stack[-5] // @2A22 stack[-6] // } 2A07 5B JUMPDEST 2A08 60 PUSH1 0x20 2A0A 02 MUL 2A0B 60 PUSH1 0x20 2A0D 01 ADD 2A0E 01 ADD 2A0F 51 MLOAD 2A10 81 DUP2 2A11 52 MSTORE 2A12 60 PUSH1 0x20 2A14 01 ADD 2A15 90 SWAP1 2A16 81 DUP2 2A17 52 MSTORE 2A18 60 PUSH1 0x20 2A1A 01 ADD 2A1B 60 PUSH1 0x00 2A1D 20 SHA3 2A1E 81 DUP2 2A1F 90 SWAP1 2A20 55 SSTORE 2A21 50 POP 2A22 80 DUP1 2A23 80 DUP1 2A24 60 PUSH1 0x01 2A26 01 ADD 2A27 91 SWAP2 2A28 50 POP 2A29 50 POP 2A2A 61 PUSH2 0x283d 2A2D 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @2A11 memory[stack[-3]:stack[-3] + 0x20] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2A17 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @2A20 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] = stack[-5] // @2A27 stack[-6] = 0x01 + stack[-6] // } // Block ends with unconditional jump to 0x283d label_2A2E: // Incoming jump from 0x2845, if !(stack[-1] < stack[-2]) // Incoming jump from 0x2845, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[8] // { // @2A30 stack[-5] // @2A47 stack[-6] // @2A5E msg.sender // @2A96 stack[-4] // @2A97 stack[-3] // @2A9A memory[0x40:0x60] // @2AAC memory[stack[-4]:stack[-4] + 0x20] // @2AB5 memory[stack[-4]:stack[-4] + 0x20] // } 2A2E 5B JUMPDEST 2A2F 50 POP 2A30 83 DUP4 2A31 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A46 16 AND 2A47 85 DUP6 2A48 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A5D 16 AND 2A5E 33 CALLER 2A5F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A74 16 AND 2A75 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 2A96 86 DUP7 2A97 86 DUP7 2A98 60 PUSH1 0x40 2A9A 51 MLOAD 2A9B 80 DUP1 2A9C 80 DUP1 2A9D 60 PUSH1 0x20 2A9F 01 ADD 2AA0 80 DUP1 2AA1 60 PUSH1 0x20 2AA3 01 ADD 2AA4 83 DUP4 2AA5 81 DUP2 2AA6 03 SUB 2AA7 83 DUP4 2AA8 52 MSTORE 2AA9 85 DUP6 2AAA 81 DUP2 2AAB 81 DUP2 2AAC 51 MLOAD 2AAD 81 DUP2 2AAE 52 MSTORE 2AAF 60 PUSH1 0x20 2AB1 01 ADD 2AB2 91 SWAP2 2AB3 50 POP 2AB4 80 DUP1 2AB5 51 MLOAD 2AB6 90 SWAP1 2AB7 60 PUSH1 0x20 2AB9 01 ADD 2ABA 90 SWAP1 2ABB 60 PUSH1 0x20 2ABD 02 MUL 2ABE 80 DUP1 2ABF 83 DUP4 2AC0 83 DUP4 2AC1 60 PUSH1 0x00 2AC3 5B JUMPDEST 2AC4 83 DUP4 2AC5 81 DUP2 2AC6 10 LT 2AC7 15 ISZERO 2AC8 61 PUSH2 0x2ade 2ACB 57 *JUMPI // Stack delta = +15 // Outputs[18] // { // @2A46 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @2A5D stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @2A74 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2A75 stack[2] = 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb // @2A96 stack[3] = stack[-4] // @2A97 stack[4] = stack[-3] // @2A9A stack[5] = memory[0x40:0x60] // @2A9B stack[6] = memory[0x40:0x60] // @2A9F stack[7] = 0x20 + memory[0x40:0x60] // @2AA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @2AAE memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-4]:stack[-4] + 0x20] // @2AB2 stack[8] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @2ABA stack[9] = 0x20 + stack[-4] // @2ABD stack[10] = 0x20 * memory[stack[-4]:stack[-4] + 0x20] // @2ABE stack[11] = 0x20 * memory[stack[-4]:stack[-4] + 0x20] // @2ABF stack[12] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @2AC0 stack[13] = 0x20 + stack[-4] // @2AC1 stack[14] = 0x00 // } // Block ends with conditional jump to 0x2ade, if !(0x00 < 0x20 * memory[stack[-4]:stack[-4] + 0x20]) label_2ACC: // Incoming jump from 0x2ACB, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x2ACB, if not !(0x00 < 0x20 * memory[stack[-4]:stack[-4] + 0x20]) // Inputs[4] // { // @2ACC stack[-1] // @2ACD stack[-2] // @2ACF memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2AD1 stack[-3] // } 2ACC 80 DUP1 2ACD 82 DUP3 2ACE 01 ADD 2ACF 51 MLOAD 2AD0 81 DUP2 2AD1 84 DUP5 2AD2 01 ADD 2AD3 52 MSTORE 2AD4 60 PUSH1 0x20 2AD6 81 DUP2 2AD7 01 ADD 2AD8 90 SWAP1 2AD9 50 POP 2ADA 61 PUSH2 0x2ac3 2ADD 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2AD3 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2AD8 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x2ac3 label_2ADE: // Incoming jump from 0x2ACB, if !(stack[-1] < stack[-4]) // Incoming jump from 0x2ACB, if !(0x00 < 0x20 * memory[stack[-4]:stack[-4] + 0x20]) // Inputs[8] // { // @2AE3 stack[-5] // @2AE3 stack[-6] // @2AE5 stack[-7] // @2AE6 stack[-10] // @2AE9 stack[-8] // @2AEB stack[-11] // @2AEE memory[stack[-11]:stack[-11] + 0x20] // @2AF7 memory[stack[-11]:stack[-11] + 0x20] // } 2ADE 5B JUMPDEST 2ADF 50 POP 2AE0 50 POP 2AE1 50 POP 2AE2 50 POP 2AE3 90 SWAP1 2AE4 50 POP 2AE5 01 ADD 2AE6 83 DUP4 2AE7 81 DUP2 2AE8 03 SUB 2AE9 82 DUP3 2AEA 52 MSTORE 2AEB 84 DUP5 2AEC 81 DUP2 2AED 81 DUP2 2AEE 51 MLOAD 2AEF 81 DUP2 2AF0 52 MSTORE 2AF1 60 PUSH1 0x20 2AF3 01 ADD 2AF4 91 SWAP2 2AF5 50 POP 2AF6 80 DUP1 2AF7 51 MLOAD 2AF8 90 SWAP1 2AF9 60 PUSH1 0x20 2AFB 01 ADD 2AFC 90 SWAP1 2AFD 60 PUSH1 0x20 2AFF 02 MUL 2B00 80 DUP1 2B01 83 DUP4 2B02 83 DUP4 2B03 60 PUSH1 0x00 2B05 5B JUMPDEST 2B06 83 DUP4 2B07 81 DUP2 2B08 10 LT 2B09 15 ISZERO 2B0A 61 PUSH2 0x2b20 2B0D 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @2AEA memory[stack[-8]:stack[-8] + 0x20] = (stack[-5] + stack[-7]) - stack[-10] // @2AF0 memory[stack[-5] + stack[-7]:stack[-5] + stack[-7] + 0x20] = memory[stack[-11]:stack[-11] + 0x20] // @2AF4 stack[-7] = 0x20 + stack[-5] + stack[-7] // @2AFC stack[-6] = 0x20 + stack[-11] // @2AFF stack[-5] = 0x20 * memory[stack[-11]:stack[-11] + 0x20] // @2B00 stack[-4] = 0x20 * memory[stack[-11]:stack[-11] + 0x20] // @2B01 stack[-3] = 0x20 + stack[-5] + stack[-7] // @2B02 stack[-2] = 0x20 + stack[-11] // @2B03 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x2b20, if !(0x00 < 0x20 * memory[stack[-11]:stack[-11] + 0x20]) label_2B0E: // Incoming jump from 0x2B0D, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x2B0D, if not !(0x00 < 0x20 * memory[stack[-11]:stack[-11] + 0x20]) // Inputs[4] // { // @2B0E stack[-1] // @2B0F stack[-2] // @2B11 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2B13 stack[-3] // } 2B0E 80 DUP1 2B0F 82 DUP3 2B10 01 ADD 2B11 51 MLOAD 2B12 81 DUP2 2B13 84 DUP5 2B14 01 ADD 2B15 52 MSTORE 2B16 60 PUSH1 0x20 2B18 81 DUP2 2B19 01 ADD 2B1A 90 SWAP1 2B1B 50 POP 2B1C 61 PUSH2 0x2b05 2B1F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2B15 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2B1A stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x2b05 label_2B20: // Incoming jump from 0x2B0D, if !(stack[-1] < stack[-4]) // Incoming jump from 0x2B0D, if !(0x00 < 0x20 * memory[stack[-11]:stack[-11] + 0x20]) // Inputs[11] // { // @2B25 stack[-5] // @2B25 stack[-6] // @2B27 stack[-7] // @2B28 stack[-12] // @2B30 memory[0x40:0x60] // @2B35 stack[-15] // @2B35 stack[-13] // @2B35 stack[-14] // @2B35 stack[-16] // @2B35 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]] // @2B3B stack[-22] // } 2B20 5B JUMPDEST 2B21 50 POP 2B22 50 POP 2B23 50 POP 2B24 50 POP 2B25 90 SWAP1 2B26 50 POP 2B27 01 ADD 2B28 94 SWAP5 2B29 50 POP 2B2A 50 POP 2B2B 50 POP 2B2C 50 POP 2B2D 50 POP 2B2E 60 PUSH1 0x40 2B30 51 MLOAD 2B31 80 DUP1 2B32 91 SWAP2 2B33 03 SUB 2B34 90 SWAP1 2B35 A4 LOG4 2B36 50 POP 2B37 50 POP 2B38 50 POP 2B39 50 POP 2B3A 50 POP 2B3B 56 *JUMP // Stack delta = -22 // Outputs[1] { @2B35 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]], [stack[-13], stack[-14], stack[-15], stack[-16]]); } // Block ends with unconditional jump to stack[-22] label_2B3C: // Incoming call from 0x398A, returns to 0x398B // Incoming call from 0x17AC, returns to 0x17AD // Inputs[1] { @2B40 stack[-5] } 2B3C 5B JUMPDEST 2B3D 61 PUSH2 0x2b5b 2B40 85 DUP6 2B41 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2B56 16 AND 2B57 61 PUSH2 0x3440 2B5A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2B3D stack[0] = 0x2b5b // @2B56 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // } // Block ends with call to 0x3440, returns to 0x2B5B label_2B5B: // Incoming return from call to 0x3440 at 0x2B5A // Inputs[1] { @2B5C stack[-1] } 2B5B 5B JUMPDEST 2B5C 15 ISZERO 2B5D 61 PUSH2 0x2df2 2B60 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2df2, if !stack[-1] label_2B61: // Incoming jump from 0x2B60, if not !stack[-1] // Inputs[10] // { // @2B63 stack[-5] // @2B7F stack[-2] // @2B80 msg.sender // @2B81 stack[-6] // @2B82 stack[-4] // @2B83 stack[-3] // @2B84 stack[-1] // @2B87 memory[0x40:0x60] // @2C10 memory[stack[-4]:stack[-4] + 0x20] // @2C19 memory[stack[-4]:stack[-4] + 0x20] // } 2B61 60 PUSH1 0x00 2B63 85 DUP6 2B64 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2B79 16 AND 2B7A 63 PUSH4 0xbc197c81 2B7F 84 DUP5 2B80 33 CALLER 2B81 8A DUP11 2B82 89 DUP10 2B83 89 DUP10 2B84 88 DUP9 2B85 60 PUSH1 0x40 2B87 51 MLOAD 2B88 87 DUP8 2B89 63 PUSH4 0xffffffff 2B8E 16 AND 2B8F 60 PUSH1 0xe0 2B91 1B SHL 2B92 81 DUP2 2B93 52 MSTORE 2B94 60 PUSH1 0x04 2B96 01 ADD 2B97 80 DUP1 2B98 86 DUP7 2B99 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2BAE 16 AND 2BAF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2BC4 16 AND 2BC5 81 DUP2 2BC6 52 MSTORE 2BC7 60 PUSH1 0x20 2BC9 01 ADD 2BCA 85 DUP6 2BCB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2BE0 16 AND 2BE1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2BF6 16 AND 2BF7 81 DUP2 2BF8 52 MSTORE 2BF9 60 PUSH1 0x20 2BFB 01 ADD 2BFC 80 DUP1 2BFD 60 PUSH1 0x20 2BFF 01 ADD 2C00 80 DUP1 2C01 60 PUSH1 0x20 2C03 01 ADD 2C04 80 DUP1 2C05 60 PUSH1 0x20 2C07 01 ADD 2C08 84 DUP5 2C09 81 DUP2 2C0A 03 SUB 2C0B 84 DUP5 2C0C 52 MSTORE 2C0D 87 DUP8 2C0E 81 DUP2 2C0F 81 DUP2 2C10 51 MLOAD 2C11 81 DUP2 2C12 52 MSTORE 2C13 60 PUSH1 0x20 2C15 01 ADD 2C16 91 SWAP2 2C17 50 POP 2C18 80 DUP1 2C19 51 MLOAD 2C1A 90 SWAP1 2C1B 60 PUSH1 0x20 2C1D 01 ADD 2C1E 90 SWAP1 2C1F 60 PUSH1 0x20 2C21 02 MUL 2C22 80 DUP1 2C23 83 DUP4 2C24 83 DUP4 2C25 60 PUSH1 0x00 2C27 5B JUMPDEST 2C28 83 DUP4 2C29 81 DUP2 2C2A 10 LT 2C2B 15 ISZERO 2C2C 61 PUSH2 0x2c42 2C2F 57 *JUMPI // Stack delta = +20 // Outputs[25] // { // @2B61 stack[0] = 0x00 // @2B79 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @2B7A stack[2] = 0xbc197c81 // @2B7F stack[3] = stack[-2] // @2B80 stack[4] = msg.sender // @2B81 stack[5] = stack[-6] // @2B82 stack[6] = stack[-4] // @2B83 stack[7] = stack[-3] // @2B84 stack[8] = stack[-1] // @2B93 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xbc197c81) << 0xe0 // @2B96 stack[9] = 0x04 + memory[0x40:0x60] // @2BC6 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @2BF8 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @2BFB stack[10] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2BFF stack[11] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2C03 stack[12] = 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2C0C memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2C12 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-4]:stack[-4] + 0x20] // @2C16 stack[13] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2C1E stack[14] = 0x20 + stack[-4] // @2C21 stack[15] = 0x20 * memory[stack[-4]:stack[-4] + 0x20] // @2C22 stack[16] = 0x20 * memory[stack[-4]:stack[-4] + 0x20] // @2C23 stack[17] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2C24 stack[18] = 0x20 + stack[-4] // @2C25 stack[19] = 0x00 // } // Block ends with conditional jump to 0x2c42, if !(0x00 < 0x20 * memory[stack[-4]:stack[-4] + 0x20]) label_2C30: // Incoming jump from 0x2C2F, if not !(0x00 < 0x20 * memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x2C2F, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2C30 stack[-1] // @2C31 stack[-2] // @2C33 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2C35 stack[-3] // } 2C30 80 DUP1 2C31 82 DUP3 2C32 01 ADD 2C33 51 MLOAD 2C34 81 DUP2 2C35 84 DUP5 2C36 01 ADD 2C37 52 MSTORE 2C38 60 PUSH1 0x20 2C3A 81 DUP2 2C3B 01 ADD 2C3C 90 SWAP1 2C3D 50 POP 2C3E 61 PUSH2 0x2c27 2C41 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2C37 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2C3C stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x2c27 label_2C42: // Incoming jump from 0x2C2F, if !(0x00 < 0x20 * memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x2C2F, if !(stack[-1] < stack[-4]) // Inputs[8] // { // @2C47 stack[-5] // @2C47 stack[-6] // @2C49 stack[-7] // @2C4A stack[-11] // @2C4D stack[-9] // @2C4F stack[-13] // @2C52 memory[stack[-13]:stack[-13] + 0x20] // @2C5B memory[stack[-13]:stack[-13] + 0x20] // } 2C42 5B JUMPDEST 2C43 50 POP 2C44 50 POP 2C45 50 POP 2C46 50 POP 2C47 90 SWAP1 2C48 50 POP 2C49 01 ADD 2C4A 84 DUP5 2C4B 81 DUP2 2C4C 03 SUB 2C4D 83 DUP4 2C4E 52 MSTORE 2C4F 86 DUP7 2C50 81 DUP2 2C51 81 DUP2 2C52 51 MLOAD 2C53 81 DUP2 2C54 52 MSTORE 2C55 60 PUSH1 0x20 2C57 01 ADD 2C58 91 SWAP2 2C59 50 POP 2C5A 80 DUP1 2C5B 51 MLOAD 2C5C 90 SWAP1 2C5D 60 PUSH1 0x20 2C5F 01 ADD 2C60 90 SWAP1 2C61 60 PUSH1 0x20 2C63 02 MUL 2C64 80 DUP1 2C65 83 DUP4 2C66 83 DUP4 2C67 60 PUSH1 0x00 2C69 5B JUMPDEST 2C6A 83 DUP4 2C6B 81 DUP2 2C6C 10 LT 2C6D 15 ISZERO 2C6E 61 PUSH2 0x2c84 2C71 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @2C4E memory[stack[-9]:stack[-9] + 0x20] = (stack[-5] + stack[-7]) - stack[-11] // @2C54 memory[stack[-5] + stack[-7]:stack[-5] + stack[-7] + 0x20] = memory[stack[-13]:stack[-13] + 0x20] // @2C58 stack[-7] = 0x20 + stack[-5] + stack[-7] // @2C60 stack[-6] = 0x20 + stack[-13] // @2C63 stack[-5] = 0x20 * memory[stack[-13]:stack[-13] + 0x20] // @2C64 stack[-4] = 0x20 * memory[stack[-13]:stack[-13] + 0x20] // @2C65 stack[-3] = 0x20 + stack[-5] + stack[-7] // @2C66 stack[-2] = 0x20 + stack[-13] // @2C67 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x2c84, if !(0x00 < 0x20 * memory[stack[-13]:stack[-13] + 0x20]) label_2C72: // Incoming jump from 0x2C71, if not !(0x00 < 0x20 * memory[stack[-13]:stack[-13] + 0x20]) // Incoming jump from 0x2C71, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2C72 stack[-1] // @2C73 stack[-2] // @2C75 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2C77 stack[-3] // } 2C72 80 DUP1 2C73 82 DUP3 2C74 01 ADD 2C75 51 MLOAD 2C76 81 DUP2 2C77 84 DUP5 2C78 01 ADD 2C79 52 MSTORE 2C7A 60 PUSH1 0x20 2C7C 81 DUP2 2C7D 01 ADD 2C7E 90 SWAP1 2C7F 50 POP 2C80 61 PUSH2 0x2c69 2C83 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2C79 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2C7E stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x2c69 label_2C84: // Incoming jump from 0x2C71, if !(0x00 < 0x20 * memory[stack[-13]:stack[-13] + 0x20]) // Incoming jump from 0x2C71, if !(stack[-1] < stack[-4]) // Inputs[8] // { // @2C89 stack[-5] // @2C89 stack[-6] // @2C8B stack[-7] // @2C8C stack[-11] // @2C8F stack[-8] // @2C91 stack[-12] // @2C94 memory[stack[-12]:stack[-12] + 0x20] // @2C9D memory[stack[-12]:stack[-12] + 0x20] // } 2C84 5B JUMPDEST 2C85 50 POP 2C86 50 POP 2C87 50 POP 2C88 50 POP 2C89 90 SWAP1 2C8A 50 POP 2C8B 01 ADD 2C8C 84 DUP5 2C8D 81 DUP2 2C8E 03 SUB 2C8F 82 DUP3 2C90 52 MSTORE 2C91 85 DUP6 2C92 81 DUP2 2C93 81 DUP2 2C94 51 MLOAD 2C95 81 DUP2 2C96 52 MSTORE 2C97 60 PUSH1 0x20 2C99 01 ADD 2C9A 91 SWAP2 2C9B 50 POP 2C9C 80 DUP1 2C9D 51 MLOAD 2C9E 90 SWAP1 2C9F 60 PUSH1 0x20 2CA1 01 ADD 2CA2 90 SWAP1 2CA3 80 DUP1 2CA4 83 DUP4 2CA5 83 DUP4 2CA6 60 PUSH1 0x00 2CA8 5B JUMPDEST 2CA9 83 DUP4 2CAA 81 DUP2 2CAB 10 LT 2CAC 15 ISZERO 2CAD 61 PUSH2 0x2cc3 2CB0 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @2C90 memory[stack[-8]:stack[-8] + 0x20] = (stack[-5] + stack[-7]) - stack[-11] // @2C96 memory[stack[-5] + stack[-7]:stack[-5] + stack[-7] + 0x20] = memory[stack[-12]:stack[-12] + 0x20] // @2C9A stack[-7] = 0x20 + stack[-5] + stack[-7] // @2CA2 stack[-5] = memory[stack[-12]:stack[-12] + 0x20] // @2CA2 stack[-6] = 0x20 + stack[-12] // @2CA3 stack[-4] = memory[stack[-12]:stack[-12] + 0x20] // @2CA4 stack[-3] = 0x20 + stack[-5] + stack[-7] // @2CA5 stack[-2] = 0x20 + stack[-12] // @2CA6 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x2cc3, if !(0x00 < memory[stack[-12]:stack[-12] + 0x20]) label_2CB1: // Incoming jump from 0x2CB0, if not !(0x00 < memory[stack[-12]:stack[-12] + 0x20]) // Incoming jump from 0x2CB0, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2CB1 stack[-1] // @2CB2 stack[-2] // @2CB4 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2CB6 stack[-3] // } 2CB1 80 DUP1 2CB2 82 DUP3 2CB3 01 ADD 2CB4 51 MLOAD 2CB5 81 DUP2 2CB6 84 DUP5 2CB7 01 ADD 2CB8 52 MSTORE 2CB9 60 PUSH1 0x20 2CBB 81 DUP2 2CBC 01 ADD 2CBD 90 SWAP1 2CBE 50 POP 2CBF 61 PUSH2 0x2ca8 2CC2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2CB8 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2CBD stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x2ca8 label_2CC3: // Incoming jump from 0x2CB0, if !(0x00 < memory[stack[-12]:stack[-12] + 0x20]) // Incoming jump from 0x2CB0, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @2CC8 stack[-6] // @2CC8 stack[-5] // @2CCA stack[-7] // } 2CC3 5B JUMPDEST 2CC4 50 POP 2CC5 50 POP 2CC6 50 POP 2CC7 50 POP 2CC8 90 SWAP1 2CC9 50 POP 2CCA 90 SWAP1 2CCB 81 DUP2 2CCC 01 ADD 2CCD 90 SWAP1 2CCE 60 PUSH1 0x1f 2CD0 16 AND 2CD1 80 DUP1 2CD2 15 ISZERO 2CD3 61 PUSH2 0x2cf0 2CD6 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2CCD stack[-7] = stack[-5] + stack[-7] // @2CD0 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x2cf0, if !(0x1f & stack[-5]) label_2CD7: // Incoming jump from 0x2CD6, if not !(0x1f & stack[-5]) // Inputs[7] // { // @2CD7 stack[-1] // @2CD8 stack[-2] // @2CDB memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2CF2 stack[-11] // @2D00 memory[0x40:0x60] // @2D07 stack[-14] // @2D09 address(stack[-14]).code.length // } 2CD7 80 DUP1 2CD8 82 DUP3 2CD9 03 SUB 2CDA 80 DUP1 2CDB 51 MLOAD 2CDC 60 PUSH1 0x01 2CDE 83 DUP4 2CDF 60 PUSH1 0x20 2CE1 03 SUB 2CE2 61 PUSH2 0x0100 2CE5 0A EXP 2CE6 03 SUB 2CE7 19 NOT 2CE8 16 AND 2CE9 81 DUP2 2CEA 52 MSTORE 2CEB 60 PUSH1 0x20 2CED 01 ADD 2CEE 91 SWAP2 2CEF 50 POP 2CF0 5B JUMPDEST 2CF1 50 POP 2CF2 98 SWAP9 2CF3 50 POP 2CF4 50 POP 2CF5 50 POP 2CF6 50 POP 2CF7 50 POP 2CF8 50 POP 2CF9 50 POP 2CFA 50 POP 2CFB 50 POP 2CFC 60 PUSH1 0x20 2CFE 60 PUSH1 0x40 2D00 51 MLOAD 2D01 80 DUP1 2D02 83 DUP4 2D03 03 SUB 2D04 81 DUP2 2D05 60 PUSH1 0x00 2D07 88 DUP9 2D08 80 DUP1 2D09 3B EXTCODESIZE 2D0A 15 ISZERO 2D0B 80 DUP1 2D0C 15 ISZERO 2D0D 61 PUSH2 0x2d15 2D10 57 *JUMPI // Stack delta = -3 // Outputs[9] // { // @2CEA memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2CF2 stack[-11] = 0x20 + (stack[-2] - stack[-1]) // @2CFC stack[-10] = 0x20 // @2D00 stack[-9] = memory[0x40:0x60] // @2D03 stack[-8] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @2D04 stack[-7] = memory[0x40:0x60] // @2D05 stack[-6] = 0x00 // @2D07 stack[-5] = stack[-14] // @2D0A stack[-4] = !address(stack[-14]).code.length // } // Block ends with conditional jump to 0x2d15, if !!address(stack[-14]).code.length label_2D11: // Incoming jump from 0x2D10, if not !!address(stack[-14]).code.length // Incoming jump from 0x2D10, if not !!address(stack[-14]).code.length // Inputs[1] { @2D14 memory[0x00:0x00] } 2D11 60 PUSH1 0x00 2D13 80 DUP1 2D14 FD *REVERT // Stack delta = +0 // Outputs[1] { @2D14 revert(memory[0x00:0x00]); } // Block terminates label_2D15: // Incoming jump from 0x2D10, if !!address(stack[-14]).code.length // Incoming jump from 0x2D10, if !!address(stack[-14]).code.length // Inputs[9] // { // @2D17 stack[-9] // @2D18 stack[-7] // @2D18 stack[-3] // @2D18 stack[-2] // @2D18 stack[-6] // @2D18 stack[-4] // @2D18 memory[stack[-4]:stack[-4] + stack[-5]] // @2D18 address(stack[-2]).call.gas(stack[-9]).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2D18 stack[-5] // } 2D15 5B JUMPDEST 2D16 50 POP 2D17 87 DUP8 2D18 F1 CALL 2D19 15 ISZERO 2D1A 80 DUP1 2D1B 15 ISZERO 2D1C 61 PUSH2 0x2d29 2D1F 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @2D18 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(stack[-9]).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2D19 stack[-7] = !address(stack[-2]).call.gas(stack[-9]).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x2d29, if !!address(stack[-2]).call.gas(stack[-9]).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2D20: // Incoming jump from 0x2D1F, if not !!address(stack[-2]).call.gas(stack[-9]).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @2D20 returndata.length // @2D24 returndata[0x00:0x00 + returndata.length] // @2D25 returndata.length // @2D28 memory[0x00:0x00 + returndata.length] // } 2D20 3D RETURNDATASIZE 2D21 60 PUSH1 0x00 2D23 80 DUP1 2D24 3E RETURNDATACOPY 2D25 3D RETURNDATASIZE 2D26 60 PUSH1 0x00 2D28 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2D24 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2D28 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2D29: // Incoming jump from 0x2D1F, if !!address(stack[-2]).call.gas(stack[-9]).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @2D31 memory[0x40:0x60] // @2D32 returndata.length // } 2D29 5B JUMPDEST 2D2A 50 POP 2D2B 50 POP 2D2C 50 POP 2D2D 50 POP 2D2E 50 POP 2D2F 60 PUSH1 0x40 2D31 51 MLOAD 2D32 3D RETURNDATASIZE 2D33 60 PUSH1 0x20 2D35 81 DUP2 2D36 10 LT 2D37 15 ISZERO 2D38 61 PUSH2 0x2d40 2D3B 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @2D31 stack[-5] = memory[0x40:0x60] // @2D32 stack[-4] = returndata.length // } // Block ends with conditional jump to 0x2d40, if !(returndata.length < 0x20) label_2D3C: // Incoming jump from 0x2D3B, if not !(returndata.length < 0x20) // Inputs[1] { @2D3F memory[0x00:0x00] } 2D3C 60 PUSH1 0x00 2D3E 80 DUP1 2D3F FD *REVERT // Stack delta = +0 // Outputs[1] { @2D3F revert(memory[0x00:0x00]); } // Block terminates label_2D40: // Incoming jump from 0x2D3B, if !(returndata.length < 0x20) // Inputs[4] // { // @2D41 stack[-2] // @2D42 stack[-1] // @2D46 memory[stack[-2]:stack[-2] + 0x20] // @2D52 stack[-3] // } 2D40 5B JUMPDEST 2D41 81 DUP2 2D42 01 ADD 2D43 90 SWAP1 2D44 80 DUP1 2D45 80 DUP1 2D46 51 MLOAD 2D47 90 SWAP1 2D48 60 PUSH1 0x20 2D4A 01 ADD 2D4B 90 SWAP1 2D4C 92 SWAP3 2D4D 91 SWAP2 2D4E 90 SWAP1 2D4F 50 POP 2D50 50 POP 2D51 50 POP 2D52 90 SWAP1 2D53 50 POP 2D54 63 PUSH4 0xbc197c81 2D59 60 PUSH1 0xe0 2D5B 1B SHL 2D5C 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2D79 19 NOT 2D7A 16 AND 2D7B 81 DUP2 2D7C 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2D99 19 NOT 2D9A 16 AND 2D9B 14 EQ 2D9C 61 PUSH2 0x2df0 2D9F 57 *JUMPI // Stack delta = -2 // Outputs[1] { @2D52 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2df0, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xbc197c81 << 0xe0) label_2DA0: // Incoming jump from 0x2D9F, if not ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xbc197c81 << 0xe0) // Inputs[3] // { // @2DA2 memory[0x40:0x60] // @2DEA memory[0x40:0x60] // @2DEF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2DA0 60 PUSH1 0x40 2DA2 51 MLOAD 2DA3 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2DC4 81 DUP2 2DC5 52 MSTORE 2DC6 60 PUSH1 0x04 2DC8 01 ADD 2DC9 80 DUP1 2DCA 80 DUP1 2DCB 60 PUSH1 0x20 2DCD 01 ADD 2DCE 82 DUP3 2DCF 81 DUP2 2DD0 03 SUB 2DD1 82 DUP3 2DD2 52 MSTORE 2DD3 60 PUSH1 0x3f 2DD5 81 DUP2 2DD6 52 MSTORE 2DD7 60 PUSH1 0x20 2DD9 01 ADD 2DDA 80 DUP1 2DDB 61 PUSH2 0x4213 2DDE 60 PUSH1 0x3f 2DE0 91 SWAP2 2DE1 39 CODECOPY 2DE2 60 PUSH1 0x40 2DE4 01 ADD 2DE5 91 SWAP2 2DE6 50 POP 2DE7 50 POP 2DE8 60 PUSH1 0x40 2DEA 51 MLOAD 2DEB 80 DUP1 2DEC 91 SWAP2 2DED 03 SUB 2DEE 90 SWAP1 2DEF FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2DC5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2DD2 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2DD6 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x3f // @2DE1 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x3f] = code[0x4213:0x4252] // @2DEF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2DF0: // Incoming jump from 0x2D9F, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xbc197c81 << 0xe0) 2DF0 5B JUMPDEST 2DF1 50 POP // Stack delta = -1 // Block continues label_2DF2: // Incoming jump from 0x2B60, if !stack[-1] // Incoming jump from 0x2DF1 // Inputs[1] { @2DF9 stack[-7] } 2DF2 5B JUMPDEST 2DF3 50 POP 2DF4 50 POP 2DF5 50 POP 2DF6 50 POP 2DF7 50 POP 2DF8 50 POP 2DF9 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_2DFA: // Incoming jump from 0x222B // Incoming jump from 0x1B5D // Inputs[2] // { // @2DFE stack[-2] // @2DFF stack[-3] // } 2DFA 5B JUMPDEST 2DFB 61 PUSH2 0x2e04 2DFE 82 DUP3 2DFF 84 DUP5 2E00 61 PUSH2 0x2558 2E03 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2DFB stack[0] = 0x2e04 // @2DFE stack[1] = stack[-2] // @2DFF stack[2] = stack[-3] // } // Block ends with call to 0x2558, returns to 0x2E04 label_2E04: // Incoming return from call to 0x2558 at 0x2E03 // Inputs[1] { @2E08 stack[-1] } 2E04 5B JUMPDEST 2E05 61 PUSH2 0x2e59 2E08 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2e59, if stack[-1] label_2E09: // Incoming jump from 0x2E08, if not stack[-1] // Inputs[3] // { // @2E0B memory[0x40:0x60] // @2E53 memory[0x40:0x60] // @2E58 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2E09 60 PUSH1 0x40 2E0B 51 MLOAD 2E0C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2E2D 81 DUP2 2E2E 52 MSTORE 2E2F 60 PUSH1 0x04 2E31 01 ADD 2E32 80 DUP1 2E33 80 DUP1 2E34 60 PUSH1 0x20 2E36 01 ADD 2E37 82 DUP3 2E38 81 DUP2 2E39 03 SUB 2E3A 82 DUP3 2E3B 52 MSTORE 2E3C 60 PUSH1 0x3a 2E3E 81 DUP2 2E3F 52 MSTORE 2E40 60 PUSH1 0x20 2E42 01 ADD 2E43 80 DUP1 2E44 61 PUSH2 0x4086 2E47 60 PUSH1 0x3a 2E49 91 SWAP2 2E4A 39 CODECOPY 2E4B 60 PUSH1 0x40 2E4D 01 ADD 2E4E 91 SWAP2 2E4F 50 POP 2E50 50 POP 2E51 60 PUSH1 0x40 2E53 51 MLOAD 2E54 80 DUP1 2E55 91 SWAP2 2E56 03 SUB 2E57 90 SWAP1 2E58 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2E2E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2E3B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2E3F memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x3a // @2E4A memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x3a] = code[0x4086:0x40c0] // @2E58 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2E59: // Incoming jump from 0x2E08, if stack[-1] // Inputs[2] // { // @2E5A stack[-1] // @2E5E stack[-2] // } 2E59 5B JUMPDEST 2E5A 80 DUP1 2E5B 61 PUSH2 0x2e63 2E5E 83 DUP4 2E5F 61 PUSH2 0x26c4 2E62 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2E5A stack[0] = stack[-1] // @2E5B stack[1] = 0x2e63 // @2E5E stack[2] = stack[-2] // } // Block ends with call to 0x26c4, returns to 0x2E63 label_2E63: // Incoming return from call to 0x26C4 at 0x2E62 // Inputs[2] // { // @2E64 stack[-2] // @2E64 stack[-1] // } 2E63 5B JUMPDEST 2E64 10 LT 2E65 15 ISZERO 2E66 61 PUSH2 0x2eba 2E69 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2eba, if !(stack[-1] < stack[-2]) label_2E6A: // Incoming jump from 0x2E69, if not !(stack[-1] < stack[-2]) // Inputs[3] // { // @2E6C memory[0x40:0x60] // @2EB4 memory[0x40:0x60] // @2EB9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2E6A 60 PUSH1 0x40 2E6C 51 MLOAD 2E6D 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2E8E 81 DUP2 2E8F 52 MSTORE 2E90 60 PUSH1 0x04 2E92 01 ADD 2E93 80 DUP1 2E94 80 DUP1 2E95 60 PUSH1 0x20 2E97 01 ADD 2E98 82 DUP3 2E99 81 DUP2 2E9A 03 SUB 2E9B 82 DUP3 2E9C 52 MSTORE 2E9D 60 PUSH1 0x35 2E9F 81 DUP2 2EA0 52 MSTORE 2EA1 60 PUSH1 0x20 2EA3 01 ADD 2EA4 80 DUP1 2EA5 61 PUSH2 0x40c0 2EA8 60 PUSH1 0x35 2EAA 91 SWAP2 2EAB 39 CODECOPY 2EAC 60 PUSH1 0x40 2EAE 01 ADD 2EAF 91 SWAP2 2EB0 50 POP 2EB1 50 POP 2EB2 60 PUSH1 0x40 2EB4 51 MLOAD 2EB5 80 DUP1 2EB6 91 SWAP2 2EB7 03 SUB 2EB8 90 SWAP1 2EB9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2E8F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2E9C memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2EA0 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x35 // @2EAB memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x35] = code[0x40c0:0x40f5] // @2EB9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2EBA: // Incoming jump from 0x2E69, if !(stack[-1] < stack[-2]) // Inputs[1] { @2EBE stack[-4] } 2EBA 5B JUMPDEST 2EBB 50 POP 2EBC 50 POP 2EBD 50 POP 2EBE 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_2EBF: // Incoming call from 0x1B69, returns to 0x1B6A // Inputs[4] // { // @2EC3 stack[-4] // @2EC4 stack[-3] // @2EC5 stack[-2] // @2EC6 stack[-1] // } 2EBF 5B JUMPDEST 2EC0 61 PUSH2 0x2ecb 2EC3 84 DUP5 2EC4 84 DUP5 2EC5 84 DUP5 2EC6 84 DUP5 2EC7 61 PUSH2 0x3485 2ECA 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2EC0 stack[0] = 0x2ecb // @2EC3 stack[1] = stack[-4] // @2EC4 stack[2] = stack[-3] // @2EC5 stack[3] = stack[-2] // @2EC6 stack[4] = stack[-1] // } // Block ends with call to 0x3485, returns to 0x2ECB label_2ECB: // Incoming return from call to 0x3485 at 0x2ECA // Inputs[2] // { // @2ECE stack[-1] // @2ECF memory[stack[-1]:stack[-1] + 0x20] // } 2ECB 5B JUMPDEST 2ECC 60 PUSH1 0x01 2ECE 81 DUP2 2ECF 51 MLOAD 2ED0 11 GT 2ED1 15 ISZERO 2ED2 61 PUSH2 0x2ee0 2ED5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2ee0, if !(memory[stack[-1]:stack[-1] + 0x20] > 0x01) label_2ED6: // Incoming jump from 0x2ED5, if not !(memory[stack[-1]:stack[-1] + 0x20] > 0x01) // Inputs[2] // { // @2ED9 stack[-3] // @2EDA stack[-1] // } 2ED6 61 PUSH2 0x2edf 2ED9 83 DUP4 2EDA 82 DUP3 2EDB 61 PUSH2 0x2ee6 2EDE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2ED6 stack[0] = 0x2edf // @2ED9 stack[1] = stack[-3] // @2EDA stack[2] = stack[-1] // } // Block ends with call to 0x2ee6, returns to 0x2EDF label_2EDF: // Incoming return from call to 0x2EE6 at 0x2EDE 2EDF 5B JUMPDEST // Stack delta = +0 // Block continues label_2EE0: // Incoming jump from 0x2ED5, if !(memory[stack[-1]:stack[-1] + 0x20] > 0x01) // Incoming jump from 0x2EDF // Inputs[1] { @2EE5 stack[-5] } 2EE0 5B JUMPDEST 2EE1 50 POP 2EE2 50 POP 2EE3 50 POP 2EE4 50 POP 2EE5 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_2EE6: // Incoming call from 0x1C1B, returns to 0x1C1C // Incoming call from 0x2EDE, returns to 0x2EDF // Incoming jump from 0x2FF0 // Inputs[4] // { // @2EE7 stack[-1] // @2EEC stack[-2] // @2EFA memory[0x00:0x40] // @2EFD memory[stack[-1]:stack[-1] + 0x20] // } 2EE6 5B JUMPDEST 2EE7 80 DUP1 2EE8 60 PUSH1 0x08 2EEA 60 PUSH1 0x00 2EEC 84 DUP5 2EED 81 DUP2 2EEE 52 MSTORE 2EEF 60 PUSH1 0x20 2EF1 01 ADD 2EF2 90 SWAP1 2EF3 81 DUP2 2EF4 52 MSTORE 2EF5 60 PUSH1 0x20 2EF7 01 ADD 2EF8 60 PUSH1 0x00 2EFA 20 SHA3 2EFB 90 SWAP1 2EFC 80 DUP1 2EFD 51 MLOAD 2EFE 90 SWAP1 2EFF 60 PUSH1 0x20 2F01 01 ADD 2F02 90 SWAP1 2F03 61 PUSH2 0x2f0d 2F06 92 SWAP3 2F07 91 SWAP2 2F08 90 SWAP1 2F09 61 PUSH2 0x3efe 2F0C 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @2EEE memory[0x00:0x20] = stack[-2] // @2EF4 memory[0x20:0x40] = 0x08 // @2F06 stack[0] = 0x2f0d // @2F07 stack[1] = keccak256(memory[0x00:0x40]) // @2F08 stack[2] = 0x20 + stack[-1] // @2F08 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x3efe, returns to 0x2F0D label_2F0D: // Incoming return from call to 0x3EFE at 0x2F0C // Inputs[5] // { // @2F0F stack[-3] // @2F31 stack[-2] // @2F34 memory[0x40:0x60] // @2F42 memory[stack[-2]:stack[-2] + 0x20] // @2F4B memory[stack[-2]:stack[-2] + 0x20] // } 2F0D 5B JUMPDEST 2F0E 50 POP 2F0F 81 DUP2 2F10 7F PUSH32 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b 2F31 82 DUP3 2F32 60 PUSH1 0x40 2F34 51 MLOAD 2F35 80 DUP1 2F36 80 DUP1 2F37 60 PUSH1 0x20 2F39 01 ADD 2F3A 82 DUP3 2F3B 81 DUP2 2F3C 03 SUB 2F3D 82 DUP3 2F3E 52 MSTORE 2F3F 83 DUP4 2F40 81 DUP2 2F41 81 DUP2 2F42 51 MLOAD 2F43 81 DUP2 2F44 52 MSTORE 2F45 60 PUSH1 0x20 2F47 01 ADD 2F48 91 SWAP2 2F49 50 POP 2F4A 80 DUP1 2F4B 51 MLOAD 2F4C 90 SWAP1 2F4D 60 PUSH1 0x20 2F4F 01 ADD 2F50 90 SWAP1 2F51 80 DUP1 2F52 83 DUP4 2F53 83 DUP4 2F54 60 PUSH1 0x00 2F56 5B JUMPDEST 2F57 83 DUP4 2F58 81 DUP2 2F59 10 LT 2F5A 15 ISZERO 2F5B 61 PUSH2 0x2f71 2F5E 57 *JUMPI // Stack delta = +11 // Outputs[14] // { // @2F0F stack[-1] = stack[-3] // @2F10 stack[0] = 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b // @2F31 stack[1] = stack[-2] // @2F34 stack[2] = memory[0x40:0x60] // @2F35 stack[3] = memory[0x40:0x60] // @2F3E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @2F44 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @2F48 stack[4] = 0x20 + 0x20 + memory[0x40:0x60] // @2F50 stack[6] = memory[stack[-2]:stack[-2] + 0x20] // @2F50 stack[5] = 0x20 + stack[-2] // @2F51 stack[7] = memory[stack[-2]:stack[-2] + 0x20] // @2F52 stack[8] = 0x20 + 0x20 + memory[0x40:0x60] // @2F53 stack[9] = 0x20 + stack[-2] // @2F54 stack[10] = 0x00 // } // Block ends with conditional jump to 0x2f71, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_2F5F: // Incoming jump from 0x2F5E, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x2F5E, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2F5F stack[-1] // @2F60 stack[-2] // @2F62 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2F64 stack[-3] // } 2F5F 80 DUP1 2F60 82 DUP3 2F61 01 ADD 2F62 51 MLOAD 2F63 81 DUP2 2F64 84 DUP5 2F65 01 ADD 2F66 52 MSTORE 2F67 60 PUSH1 0x20 2F69 81 DUP2 2F6A 01 ADD 2F6B 90 SWAP1 2F6C 50 POP 2F6D 61 PUSH2 0x2f56 2F70 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2F66 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2F6B stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x2f56 label_2F71: // Incoming jump from 0x2F5E, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x2F5E, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @2F76 stack[-5] // @2F76 stack[-6] // @2F78 stack[-7] // } 2F71 5B JUMPDEST 2F72 50 POP 2F73 50 POP 2F74 50 POP 2F75 50 POP 2F76 90 SWAP1 2F77 50 POP 2F78 90 SWAP1 2F79 81 DUP2 2F7A 01 ADD 2F7B 90 SWAP1 2F7C 60 PUSH1 0x1f 2F7E 16 AND 2F7F 80 DUP1 2F80 15 ISZERO 2F81 61 PUSH2 0x2f9e 2F84 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2F7B stack[-7] = stack[-5] + stack[-7] // @2F7E stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x2f9e, if !(0x1f & stack[-5]) label_2F85: // Incoming jump from 0x2F84, if not !(0x1f & stack[-5]) // Inputs[9] // { // @2F85 stack[-1] // @2F86 stack[-2] // @2F89 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2FA0 stack[-5] // @2FA6 memory[0x40:0x60] // @2FAB stack[-7] // @2FAB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // @2FAB stack[-6] // @2FAE stack[-10] // } 2F85 80 DUP1 2F86 82 DUP3 2F87 03 SUB 2F88 80 DUP1 2F89 51 MLOAD 2F8A 60 PUSH1 0x01 2F8C 83 DUP4 2F8D 60 PUSH1 0x20 2F8F 03 SUB 2F90 61 PUSH2 0x0100 2F93 0A EXP 2F94 03 SUB 2F95 19 NOT 2F96 16 AND 2F97 81 DUP2 2F98 52 MSTORE 2F99 60 PUSH1 0x20 2F9B 01 ADD 2F9C 91 SWAP2 2F9D 50 POP 2F9E 5B JUMPDEST 2F9F 50 POP 2FA0 92 SWAP3 2FA1 50 POP 2FA2 50 POP 2FA3 50 POP 2FA4 60 PUSH1 0x40 2FA6 51 MLOAD 2FA7 80 DUP1 2FA8 91 SWAP2 2FA9 03 SUB 2FAA 90 SWAP1 2FAB A2 LOG2 2FAC 50 POP 2FAD 50 POP 2FAE 56 *JUMP // Stack delta = -10 // Outputs[2] // { // @2F98 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2FAB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]], [stack[-6], stack[-7]]); // } // Block ends with unconditional jump to stack[-10] label_2FAF: // Incoming call from 0x2245, returns to 0x2246 // Inputs[4] // { // @2FB3 stack[-4] // @2FB4 stack[-3] // @2FB5 stack[-2] // @2FB6 stack[-1] // } 2FAF 5B JUMPDEST 2FB0 61 PUSH2 0x2fbb 2FB3 84 DUP5 2FB4 84 DUP5 2FB5 84 DUP5 2FB6 84 DUP5 2FB7 61 PUSH2 0x361d 2FBA 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2FB0 stack[0] = 0x2fbb // @2FB3 stack[1] = stack[-4] // @2FB4 stack[2] = stack[-3] // @2FB5 stack[3] = stack[-2] // @2FB6 stack[4] = stack[-1] // } // Block ends with call to 0x361d, returns to 0x2FBB label_2FBB: // Incoming return from call to 0x361D at 0x2FBA // Inputs[2] // { // @2FBE stack[-1] // @2FBF memory[stack[-1]:stack[-1] + 0x20] // } 2FBB 5B JUMPDEST 2FBC 60 PUSH1 0x01 2FBE 81 DUP2 2FBF 51 MLOAD 2FC0 11 GT 2FC1 15 ISZERO 2FC2 61 PUSH2 0x3000 2FC5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3000, if !(memory[stack[-1]:stack[-1] + 0x20] > 0x01) label_2FC6: // Incoming jump from 0x2FC5, if not !(memory[stack[-1]:stack[-1] + 0x20] > 0x01) // Inputs[2] // { // @2FCC stack[-3] // @2FCD memory[stack[-3]:stack[-3] + 0x20] // } 2FC6 60 PUSH1 0x00 2FC8 80 DUP1 2FC9 90 SWAP1 2FCA 50 POP 2FCB 5B JUMPDEST 2FCC 83 DUP4 2FCD 51 MLOAD 2FCE 81 DUP2 2FCF 10 LT 2FD0 15 ISZERO 2FD1 61 PUSH2 0x2ffe 2FD4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2FC9 stack[0] = 0x00 } // Block ends with conditional jump to 0x2ffe, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_2FD5: // Incoming jump from 0x2FD4, if not !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x2FD4, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[3] // { // @2FD8 stack[-4] // @2FD9 stack[-1] // @2FDB memory[stack[-4]:stack[-4] + 0x20] // } 2FD5 61 PUSH2 0x2ff1 2FD8 84 DUP5 2FD9 82 DUP3 2FDA 81 DUP2 2FDB 51 MLOAD 2FDC 81 DUP2 2FDD 10 LT 2FDE 61 PUSH2 0x2fe3 2FE1 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2FD5 stack[0] = 0x2ff1 // @2FD8 stack[1] = stack[-4] // @2FD9 stack[2] = stack[-1] // } // Block ends with conditional call to 0x2fe3, returns to 0x2FF1, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] label_2FE2: // Incoming jump from 0x2FE1, if not stack[-1] < memory[stack[-4]:stack[-4] + 0x20] 2FE2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2FE2 assert(); } // Block terminates label_2FE3: // Incoming call from 0x2FE1, returns to 0x2FF1, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @2FE6 stack[-1] // @2FEA stack[-2] // @2FEB memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2FEC stack[-5] // } 2FE3 5B JUMPDEST 2FE4 60 PUSH1 0x20 2FE6 02 MUL 2FE7 60 PUSH1 0x20 2FE9 01 ADD 2FEA 01 ADD 2FEB 51 MLOAD 2FEC 83 DUP4 2FED 61 PUSH2 0x2ee6 2FF0 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2FEB stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2FEC stack[-1] = stack[-5] // } // Block ends with unconditional jump to 0x2ee6 label_2FF1: // Incoming return from call to 0x2FE3 at 0x2FE1 // Inputs[1] { @2FF2 stack[-1] } 2FF1 5B JUMPDEST 2FF2 80 DUP1 2FF3 80 DUP1 2FF4 60 PUSH1 0x01 2FF6 01 ADD 2FF7 91 SWAP2 2FF8 50 POP 2FF9 50 POP 2FFA 61 PUSH2 0x2fcb 2FFD 56 *JUMP // Stack delta = +0 // Outputs[1] { @2FF7 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x2fcb label_2FFE: // Incoming jump from 0x2FD4, if !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x2FD4, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) 2FFE 5B JUMPDEST 2FFF 50 POP // Stack delta = -1 // Block continues label_3000: // Incoming jump from 0x2FC5, if !(memory[stack[-1]:stack[-1] + 0x20] > 0x01) // Incoming jump from 0x2FFF // Inputs[1] { @3005 stack[-5] } 3000 5B JUMPDEST 3001 50 POP 3002 50 POP 3003 50 POP 3004 50 POP 3005 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_3006: // Incoming jump from 0x27CE // Incoming call from 0x26B8, returns to 0x26B9 // Incoming call from 0x2367, returns to 0x2368 // Incoming call from 0x2664, returns to 0x2665 // Inputs[3] // { // @300D stack[-1] // @3047 memory[0x00:0x40] // @304B storage[keccak256(memory[0x00:0x40])] // } 3006 5B JUMPDEST 3007 60 PUSH1 0x00 3009 60 PUSH1 0x0a 300B 60 PUSH1 0x00 300D 83 DUP4 300E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3023 16 AND 3024 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3039 16 AND 303A 81 DUP2 303B 52 MSTORE 303C 60 PUSH1 0x20 303E 01 ADD 303F 90 SWAP1 3040 81 DUP2 3041 52 MSTORE 3042 60 PUSH1 0x20 3044 01 ADD 3045 60 PUSH1 0x00 3047 20 SHA3 3048 60 PUSH1 0x00 304A 90 SWAP1 304B 54 SLOAD 304C 90 SWAP1 304D 61 PUSH2 0x0100 3050 0A EXP 3051 90 SWAP1 3052 04 DIV 3053 60 PUSH1 0xff 3055 16 AND 3056 15 ISZERO 3057 61 PUSH2 0x3063 305A 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @3007 stack[0] = 0x00 // @303B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @3041 memory[0x20:0x40] = 0x0a // } // Block ends with conditional jump to 0x3063, if !(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) label_305B: // Incoming jump from 0x305A, if not !(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) // Inputs[1] { @305D stack[-1] } 305B 60 PUSH1 0x01 305D 90 SWAP1 305E 50 POP 305F 61 PUSH2 0x3070 3062 56 *JUMP // Stack delta = +0 // Outputs[1] { @305D stack[-1] = 0x01 } // Block ends with unconditional jump to 0x3070 label_3063: // Incoming jump from 0x305A, if !(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) // Inputs[2] // { // @3067 stack[-3] // @3068 stack[-2] // } 3063 5B JUMPDEST 3064 61 PUSH2 0x306d 3067 83 DUP4 3068 83 DUP4 3069 61 PUSH2 0x3993 306C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3064 stack[0] = 0x306d // @3067 stack[1] = stack[-3] // @3068 stack[2] = stack[-2] // } // Block ends with call to 0x3993, returns to 0x306D label_306D: // Incoming return from call to 0x3993 at 0x306C // Inputs[2] // { // @306E stack[-2] // @306E stack[-1] // } 306D 5B JUMPDEST 306E 90 SWAP1 306F 50 POP // Stack delta = -1 // Outputs[1] { @306E stack[-2] = stack[-1] } // Block continues label_3070: // Incoming jump from 0x3062 // Incoming jump from 0x306F // Inputs[3] // { // @3071 stack[-1] // @3071 stack[-4] // @3072 stack[-3] // } 3070 5B JUMPDEST 3071 92 SWAP3 3072 91 SWAP2 3073 50 POP 3074 50 POP 3075 56 *JUMP // Stack delta = -3 // Outputs[1] { @3071 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_3076: // Incoming call from 0x237F, returns to 0x2380 // Inputs[6] // { // @307D stack[-2] // @30B7 memory[0x00:0x40] // @30BA stack[-1] // @30F4 memory[0x00:0x40] // @30F8 storage[keccak256(memory[0x00:0x40])] // @3105 stack[-3] // } 3076 5B JUMPDEST 3077 60 PUSH1 0x00 3079 60 PUSH1 0x01 307B 60 PUSH1 0x00 307D 84 DUP5 307E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3093 16 AND 3094 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 30A9 16 AND 30AA 81 DUP2 30AB 52 MSTORE 30AC 60 PUSH1 0x20 30AE 01 ADD 30AF 90 SWAP1 30B0 81 DUP2 30B1 52 MSTORE 30B2 60 PUSH1 0x20 30B4 01 ADD 30B5 60 PUSH1 0x00 30B7 20 SHA3 30B8 60 PUSH1 0x00 30BA 83 DUP4 30BB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 30D0 16 AND 30D1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 30E6 16 AND 30E7 81 DUP2 30E8 52 MSTORE 30E9 60 PUSH1 0x20 30EB 01 ADD 30EC 90 SWAP1 30ED 81 DUP2 30EE 52 MSTORE 30EF 60 PUSH1 0x20 30F1 01 ADD 30F2 60 PUSH1 0x00 30F4 20 SHA3 30F5 60 PUSH1 0x00 30F7 90 SWAP1 30F8 54 SLOAD 30F9 90 SWAP1 30FA 61 PUSH2 0x0100 30FD 0A EXP 30FE 90 SWAP1 30FF 04 DIV 3100 60 PUSH1 0xff 3102 16 AND 3103 90 SWAP1 3104 50 POP 3105 92 SWAP3 3106 91 SWAP2 3107 50 POP 3108 50 POP 3109 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @30AB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @30B1 memory[0x20:0x40] = 0x01 // @30E8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @30EE memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @3105 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_310A: // Incoming jump from 0x28CC // Incoming call from 0x3A35, returns to 0x3A36 // Incoming jump from 0x26E8 // Incoming call from 0x23B6, returns to 0x23B7 // Inputs[2] // { // @310D stack[-2] // @310E stack[-1] // } 310A 5B JUMPDEST 310B 60 PUSH1 0x00 310D 82 DUP3 310E 82 DUP3 310F 11 GT 3110 15 ISZERO 3111 61 PUSH2 0x3182 3114 57 *JUMPI // Stack delta = +1 // Outputs[1] { @310B stack[0] = 0x00 } // Block ends with conditional jump to 0x3182, if !(stack[-1] > stack[-2]) label_3115: // Incoming jump from 0x3114, if not !(stack[-1] > stack[-2]) // Inputs[3] // { // @3117 memory[0x40:0x60] // @317C memory[0x40:0x60] // @3181 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 3115 60 PUSH1 0x40 3117 51 MLOAD 3118 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3139 81 DUP2 313A 52 MSTORE 313B 60 PUSH1 0x04 313D 01 ADD 313E 80 DUP1 313F 80 DUP1 3140 60 PUSH1 0x20 3142 01 ADD 3143 82 DUP3 3144 81 DUP2 3145 03 SUB 3146 82 DUP3 3147 52 MSTORE 3148 60 PUSH1 0x17 314A 81 DUP2 314B 52 MSTORE 314C 60 PUSH1 0x20 314E 01 ADD 314F 80 DUP1 3150 7F PUSH32 0x536166654d617468237375623a20554e444552464c4f57000000000000000000 3171 81 DUP2 3172 52 MSTORE 3173 50 POP 3174 60 PUSH1 0x20 3176 01 ADD 3177 91 SWAP2 3178 50 POP 3179 50 POP 317A 60 PUSH1 0x40 317C 51 MLOAD 317D 80 DUP1 317E 91 SWAP2 317F 03 SUB 3180 90 SWAP1 3181 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @313A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3147 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @314B memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x17 // @3172 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x536166654d617468237375623a20554e444552464c4f57000000000000000000 // @3181 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3182: // Incoming jump from 0x3114, if !(stack[-1] > stack[-2]) // Inputs[4] // { // @3185 stack[-2] // @3186 stack[-3] // @318B stack[-1] // @318E stack[-4] // } 3182 5B JUMPDEST 3183 60 PUSH1 0x00 3185 82 DUP3 3186 84 DUP5 3187 03 SUB 3188 90 SWAP1 3189 50 POP 318A 80 DUP1 318B 91 SWAP2 318C 50 POP 318D 50 POP 318E 92 SWAP3 318F 91 SWAP2 3190 50 POP 3191 50 POP 3192 56 *JUMP // Stack delta = -3 // Outputs[1] { @318E stack[-4] = stack[-3] - stack[-2] } // Block ends with unconditional jump to stack[-4] label_3193: // Incoming call from 0x23E5, returns to 0x23E6 // Incoming call from 0x23D2, returns to 0x23D3 // Inputs[2] // { // @3194 stack[-5] // @31AB msg.sender // } 3193 5B JUMPDEST 3194 84 DUP5 3195 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 31AA 16 AND 31AB 33 CALLER 31AC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 31C1 16 AND 31C2 14 EQ 31C3 80 DUP1 31C4 61 PUSH2 0x31d3 31C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @31C2 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] } // Block ends with conditional jump to 0x31d3, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] label_31C8: // Incoming jump from 0x31C7, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // Inputs[2] // { // @31CC stack[-6] // @31CD msg.sender // } 31C8 50 POP 31C9 61 PUSH2 0x31d2 31CC 85 DUP6 31CD 33 CALLER 31CE 61 PUSH2 0x235c 31D1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @31C9 stack[-1] = 0x31d2 // @31CC stack[0] = stack[-6] // @31CD stack[1] = msg.sender // } // Block ends with call to 0x235c, returns to 0x31D2 label_31D2: // Incoming return from call to 0x235C at 0x31D1 31D2 5B JUMPDEST // Stack delta = +0 // Block continues label_31D3: // Incoming jump from 0x31D2 // Incoming jump from 0x31C7, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // Inputs[1] { @31D7 stack[-1] } 31D3 5B JUMPDEST 31D4 61 PUSH2 0x3228 31D7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x3228, if stack[-1] label_31D8: // Incoming jump from 0x31D7, if not stack[-1] // Inputs[3] // { // @31DA memory[0x40:0x60] // @3222 memory[0x40:0x60] // @3227 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 31D8 60 PUSH1 0x40 31DA 51 MLOAD 31DB 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 31FC 81 DUP2 31FD 52 MSTORE 31FE 60 PUSH1 0x04 3200 01 ADD 3201 80 DUP1 3202 80 DUP1 3203 60 PUSH1 0x20 3205 01 ADD 3206 82 DUP3 3207 81 DUP2 3208 03 SUB 3209 82 DUP3 320A 52 MSTORE 320B 60 PUSH1 0x2a 320D 81 DUP2 320E 52 MSTORE 320F 60 PUSH1 0x20 3211 01 ADD 3212 80 DUP1 3213 61 PUSH2 0x4025 3216 60 PUSH1 0x2a 3218 91 SWAP2 3219 39 CODECOPY 321A 60 PUSH1 0x40 321C 01 ADD 321D 91 SWAP2 321E 50 POP 321F 50 POP 3220 60 PUSH1 0x40 3222 51 MLOAD 3223 80 DUP1 3224 91 SWAP2 3225 03 SUB 3226 90 SWAP1 3227 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @31FD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @320A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @320E memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2a // @3219 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2a] = code[0x4025:0x404f] // @3227 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3228: // Incoming jump from 0x31D7, if stack[-1] // Inputs[1] { @3241 stack[-4] } 3228 5B JUMPDEST 3229 60 PUSH1 0x00 322B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3240 16 AND 3241 84 DUP5 3242 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3257 16 AND 3258 14 EQ 3259 15 ISZERO 325A 61 PUSH2 0x32ae 325D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x32ae, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_325E: // Incoming jump from 0x325D, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @3260 memory[0x40:0x60] // @32A8 memory[0x40:0x60] // @32AD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 325E 60 PUSH1 0x40 3260 51 MLOAD 3261 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3282 81 DUP2 3283 52 MSTORE 3284 60 PUSH1 0x04 3286 01 ADD 3287 80 DUP1 3288 80 DUP1 3289 60 PUSH1 0x20 328B 01 ADD 328C 82 DUP3 328D 81 DUP2 328E 03 SUB 328F 82 DUP3 3290 52 MSTORE 3291 60 PUSH1 0x2b 3293 81 DUP2 3294 52 MSTORE 3295 60 PUSH1 0x20 3297 01 ADD 3298 80 DUP1 3299 61 PUSH2 0x3fa4 329C 60 PUSH1 0x2b 329E 91 SWAP2 329F 39 CODECOPY 32A0 60 PUSH1 0x40 32A2 01 ADD 32A3 91 SWAP2 32A4 50 POP 32A5 50 POP 32A6 60 PUSH1 0x40 32A8 51 MLOAD 32A9 80 DUP1 32AA 91 SWAP2 32AB 03 SUB 32AC 90 SWAP1 32AD FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3283 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3290 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @3294 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2b // @329F memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2b] = code[0x3fa4:0x3fcf] // @32AD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_32AE: // Incoming jump from 0x325D, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[4] // { // @32B2 stack[-5] // @32B3 stack[-4] // @32B4 stack[-3] // @32B5 stack[-2] // } 32AE 5B JUMPDEST 32AF 61 PUSH2 0x32ba 32B2 85 DUP6 32B3 85 DUP6 32B4 85 DUP6 32B5 85 DUP6 32B6 61 PUSH2 0x39d4 32B9 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @32AF stack[0] = 0x32ba // @32B2 stack[1] = stack[-5] // @32B3 stack[2] = stack[-4] // @32B4 stack[3] = stack[-3] // @32B5 stack[4] = stack[-2] // } // Block ends with call to 0x39d4, returns to 0x32BA label_32BA: // Incoming return from call to 0x39D4 at 0x32B9 // Inputs[6] // { // @32BE stack[-5] // @32BF stack[-4] // @32C0 stack[-3] // @32C1 stack[-2] // @32C2 msg.gas // @32C3 stack[-1] // } 32BA 5B JUMPDEST 32BB 61 PUSH2 0x32c8 32BE 85 DUP6 32BF 85 DUP6 32C0 85 DUP6 32C1 85 DUP6 32C2 5A GAS 32C3 86 DUP7 32C4 61 PUSH2 0x3bc8 32C7 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @32BB stack[0] = 0x32c8 // @32BE stack[1] = stack[-5] // @32BF stack[2] = stack[-4] // @32C0 stack[3] = stack[-3] // @32C1 stack[4] = stack[-2] // @32C2 stack[5] = msg.gas // @32C3 stack[6] = stack[-1] // } // Block ends with call to 0x3bc8, returns to 0x32C8 label_32C8: // Incoming return from call to 0x3BC8 at 0x32C7 // Inputs[1] { @32CE stack[-6] } 32C8 5B JUMPDEST 32C9 50 POP 32CA 50 POP 32CB 50 POP 32CC 50 POP 32CD 50 POP 32CE 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_32CF: // Incoming call from 0x245C, returns to 0x245D // Inputs[1] { @32E8 stack[-1] } 32CF 5B JUMPDEST 32D0 60 PUSH1 0x00 32D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 32E7 16 AND 32E8 81 DUP2 32E9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 32FE 16 AND 32FF 14 EQ 3300 15 ISZERO 3301 61 PUSH2 0x3355 3304 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3355, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_3305: // Incoming jump from 0x3304, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @3307 memory[0x40:0x60] // @334F memory[0x40:0x60] // @3354 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 3305 60 PUSH1 0x40 3307 51 MLOAD 3308 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3329 81 DUP2 332A 52 MSTORE 332B 60 PUSH1 0x04 332D 01 ADD 332E 80 DUP1 332F 80 DUP1 3330 60 PUSH1 0x20 3332 01 ADD 3333 82 DUP3 3334 81 DUP2 3335 03 SUB 3336 82 DUP3 3337 52 MSTORE 3338 60 PUSH1 0x26 333A 81 DUP2 333B 52 MSTORE 333C 60 PUSH1 0x20 333E 01 ADD 333F 80 DUP1 3340 61 PUSH2 0x3fcf 3343 60 PUSH1 0x26 3345 91 SWAP2 3346 39 CODECOPY 3347 60 PUSH1 0x40 3349 01 ADD 334A 91 SWAP2 334B 50 POP 334C 50 POP 334D 60 PUSH1 0x40 334F 51 MLOAD 3350 80 DUP1 3351 91 SWAP2 3352 03 SUB 3353 90 SWAP1 3354 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @332A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3337 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @333B memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x26 // @3346 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x26] = code[0x3fcf:0x3ff5] // @3354 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3355: // Incoming jump from 0x3304, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[7] // { // @3356 stack[-1] // @3372 storage[0x02] // @33C9 memory[0x40:0x60] // @33CC memory[0x40:0x60] // @33D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @33DC storage[0x02] // @3414 stack[-2] // } 3355 5B JUMPDEST 3356 80 DUP1 3357 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 336C 16 AND 336D 60 PUSH1 0x02 336F 60 PUSH1 0x00 3371 90 SWAP1 3372 54 SLOAD 3373 90 SWAP1 3374 61 PUSH2 0x0100 3377 0A EXP 3378 90 SWAP1 3379 04 DIV 337A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 338F 16 AND 3390 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 33A5 16 AND 33A6 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 33C7 60 PUSH1 0x40 33C9 51 MLOAD 33CA 60 PUSH1 0x40 33CC 51 MLOAD 33CD 80 DUP1 33CE 91 SWAP2 33CF 03 SUB 33D0 90 SWAP1 33D1 A3 LOG3 33D2 80 DUP1 33D3 60 PUSH1 0x02 33D5 60 PUSH1 0x00 33D7 61 PUSH2 0x0100 33DA 0A EXP 33DB 81 DUP2 33DC 54 SLOAD 33DD 81 DUP2 33DE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 33F3 02 MUL 33F4 19 NOT 33F5 16 AND 33F6 90 SWAP1 33F7 83 DUP4 33F8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 340D 16 AND 340E 02 MUL 340F 17 OR 3410 90 SWAP1 3411 55 SSTORE 3412 50 POP 3413 50 POP 3414 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @33D1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x02] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // @3411 storage[0x02] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x02]) // } // Block ends with unconditional jump to stack[-2] label_3415: // Incoming call from 0x3E0E, returns to 0x3E0F // Incoming call from 0x2677, returns to 0x2678 // Inputs[2] // { // @3420 stack[-1] // @3425 stack[-2] // } 3415 5B JUMPDEST 3416 60 PUSH1 0x00 3418 60 PUSH1 0x28 341A 60 PUSH1 0x38 341C 01 ADD 341D 60 PUSH1 0xff 341F 16 AND 3420 82 DUP3 3421 90 SWAP1 3422 1C SHR 3423 90 SWAP1 3424 50 POP 3425 91 SWAP2 3426 90 SWAP1 3427 50 POP 3428 56 *JUMP // Stack delta = -1 // Outputs[1] { @3425 stack[-2] = stack[-1] >> (0xff & 0x38 + 0x28) } // Block ends with unconditional jump to stack[-2] label_3429: // Incoming call from 0x26DA, returns to 0x26DB // Inputs[2] // { // @3438 stack[-1] // @343C stack[-2] // } 3429 5B JUMPDEST 342A 60 PUSH1 0x00 342C 60 PUSH1 0x01 342E 60 PUSH1 0x28 3430 60 PUSH1 0xff 3432 16 AND 3433 60 PUSH1 0x01 3435 90 SWAP1 3436 1B SHL 3437 03 SUB 3438 82 DUP3 3439 16 AND 343A 90 SWAP1 343B 50 POP 343C 91 SWAP2 343D 90 SWAP1 343E 50 POP 343F 56 *JUMP // Stack delta = -1 // Outputs[1] { @343C stack[-2] = stack[-1] & (0x01 << (0xff & 0x28)) - 0x01 } // Block ends with unconditional jump to stack[-2] label_3440: // Incoming call from 0x3BE6, returns to 0x3BE7 // Incoming call from 0x2B5A, returns to 0x2B5B // Inputs[2] // { // @3444 stack[-1] // @3445 keccak256(address(stack[-1]).code) // } 3440 5B JUMPDEST 3441 60 PUSH1 0x00 3443 80 DUP1 3444 82 DUP3 3445 3F EXTCODEHASH 3446 90 SWAP1 3447 50 POP 3448 60 PUSH1 0x00 344A 80 DUP1 344B 1B SHL 344C 81 DUP2 344D 14 EQ 344E 15 ISZERO 344F 80 DUP1 3450 15 ISZERO 3451 61 PUSH2 0x347d 3454 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3441 stack[0] = 0x00 // @3446 stack[1] = keccak256(address(stack[-1]).code) // @344E stack[2] = !(keccak256(address(stack[-1]).code) == 0x00 << 0x00) // } // Block ends with conditional jump to 0x347d, if !!(keccak256(address(stack[-1]).code) == 0x00 << 0x00) label_3455: // Incoming jump from 0x3454, if not !!(keccak256(address(stack[-1]).code) == 0x00 << 0x00) // Inputs[4] // { // @347A stack[-2] // @347E stack[-3] // @3481 stack[-5] // @3482 stack[-4] // } 3455 50 POP 3456 7F PUSH32 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 3477 60 PUSH1 0x00 3479 1B SHL 347A 81 DUP2 347B 14 EQ 347C 15 ISZERO 347D 5B JUMPDEST 347E 91 SWAP2 347F 50 POP 3480 50 POP 3481 91 SWAP2 3482 90 SWAP1 3483 50 POP 3484 56 *JUMP // Stack delta = -4 // Outputs[1] { @3481 stack[-5] = !(stack[-2] == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 << 0x00) } // Block ends with unconditional jump to stack[-5] label_3485: // Incoming call from 0x2ECA, returns to 0x2ECB // Inputs[6] // { // @3489 stack[-2] // @348D stack[-4] // @34C7 memory[0x00:0x40] // @34CA stack[-3] // @34D8 memory[0x00:0x40] // @34D9 storage[keccak256(memory[0x00:0x40])] // } 3485 5B JUMPDEST 3486 61 PUSH2 0x34e7 3489 82 DUP3 348A 60 PUSH1 0x00 348C 80 DUP1 348D 87 DUP8 348E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 34A3 16 AND 34A4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 34B9 16 AND 34BA 81 DUP2 34BB 52 MSTORE 34BC 60 PUSH1 0x20 34BE 01 ADD 34BF 90 SWAP1 34C0 81 DUP2 34C1 52 MSTORE 34C2 60 PUSH1 0x20 34C4 01 ADD 34C5 60 PUSH1 0x00 34C7 20 SHA3 34C8 60 PUSH1 0x00 34CA 86 DUP7 34CB 81 DUP2 34CC 52 MSTORE 34CD 60 PUSH1 0x20 34CF 01 ADD 34D0 90 SWAP1 34D1 81 DUP2 34D2 52 MSTORE 34D3 60 PUSH1 0x20 34D5 01 ADD 34D6 60 PUSH1 0x00 34D8 20 SHA3 34D9 54 SLOAD 34DA 61 PUSH2 0x26f0 34DD 90 SWAP1 34DE 91 SWAP2 34DF 90 SWAP1 34E0 63 PUSH4 0xffffffff 34E5 16 AND 34E6 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @3486 stack[0] = 0x34e7 // @34BB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @34C1 memory[0x20:0x40] = 0x00 // @34CC memory[0x00:0x20] = stack[-3] // @34D2 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @34DE stack[1] = storage[keccak256(memory[0x00:0x40])] // @34DF stack[2] = stack[-2] // } // Block ends with call to 0xffffffff & 0x26f0, returns to 0x34E7 label_34E7: // Incoming return from call to 0x26F0 at 0x34E6 // Inputs[8] // { // @34EB stack[-5] // @3525 memory[0x00:0x40] // @3528 stack[-4] // @3536 memory[0x00:0x40] // @3537 stack[-1] // @353E stack[-3] // @3551 memory[0x00:0x40] // @3552 storage[keccak256(memory[0x00:0x40])] // } 34E7 5B JUMPDEST 34E8 60 PUSH1 0x00 34EA 80 DUP1 34EB 86 DUP7 34EC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3501 16 AND 3502 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3517 16 AND 3518 81 DUP2 3519 52 MSTORE 351A 60 PUSH1 0x20 351C 01 ADD 351D 90 SWAP1 351E 81 DUP2 351F 52 MSTORE 3520 60 PUSH1 0x20 3522 01 ADD 3523 60 PUSH1 0x00 3525 20 SHA3 3526 60 PUSH1 0x00 3528 85 DUP6 3529 81 DUP2 352A 52 MSTORE 352B 60 PUSH1 0x20 352D 01 ADD 352E 90 SWAP1 352F 81 DUP2 3530 52 MSTORE 3531 60 PUSH1 0x20 3533 01 ADD 3534 60 PUSH1 0x00 3536 20 SHA3 3537 81 DUP2 3538 90 SWAP1 3539 55 SSTORE 353A 50 POP 353B 61 PUSH2 0x3560 353E 82 DUP3 353F 60 PUSH1 0x06 3541 60 PUSH1 0x00 3543 86 DUP7 3544 81 DUP2 3545 52 MSTORE 3546 60 PUSH1 0x20 3548 01 ADD 3549 90 SWAP1 354A 81 DUP2 354B 52 MSTORE 354C 60 PUSH1 0x20 354E 01 ADD 354F 60 PUSH1 0x00 3551 20 SHA3 3552 54 SLOAD 3553 61 PUSH2 0x26f0 3556 90 SWAP1 3557 91 SWAP2 3558 90 SWAP1 3559 63 PUSH4 0xffffffff 355E 16 AND 355F 56 *JUMP // Stack delta = +2 // Outputs[10] // { // @3519 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @351F memory[0x20:0x40] = 0x00 // @352A memory[0x00:0x20] = stack[-4] // @3530 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @3539 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @353B stack[-1] = 0x3560 // @3545 memory[0x00:0x20] = stack[-4] // @354B memory[0x20:0x40] = 0x06 // @3557 stack[0] = storage[keccak256(memory[0x00:0x40])] // @3558 stack[1] = stack[-3] // } // Block ends with call to 0xffffffff & 0x26f0, returns to 0x3560 label_3560: // Incoming return from call to 0x26F0 at 0x355F // Inputs[3] // { // @3565 stack[-4] // @3573 memory[0x00:0x40] // @3574 stack[-1] // } 3560 5B JUMPDEST 3561 60 PUSH1 0x06 3563 60 PUSH1 0x00 3565 85 DUP6 3566 81 DUP2 3567 52 MSTORE 3568 60 PUSH1 0x20 356A 01 ADD 356B 90 SWAP1 356C 81 DUP2 356D 52 MSTORE 356E 60 PUSH1 0x20 3570 01 ADD 3571 60 PUSH1 0x00 3573 20 SHA3 3574 81 DUP2 3575 90 SWAP1 3576 55 SSTORE 3577 50 POP 3578 60 PUSH1 0x00 357A 61 PUSH2 0x3582 357D 84 DUP5 357E 61 PUSH2 0x3e04 3581 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @3567 memory[0x00:0x20] = stack[-4] // @356D memory[0x20:0x40] = 0x06 // @3576 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @3578 stack[-1] = 0x00 // @357A stack[0] = 0x3582 // @357D stack[1] = stack[-4] // } // Block ends with call to 0x3e04, returns to 0x3582 label_3582: // Incoming return from call to 0x3E04 at 0x3581 // Inputs[11] // { // @3583 stack[-2] // @3583 stack[-1] // @3585 stack[-6] // @35B3 msg.sender // @35EB stack[-5] // @35EC stack[-4] // @35EF memory[0x40:0x60] // @3603 memory[0x40:0x60] // @3608 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @3610 msg.gas // @3611 stack[-3] // } 3582 5B JUMPDEST 3583 90 SWAP1 3584 50 POP 3585 84 DUP5 3586 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 359B 16 AND 359C 81 DUP2 359D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 35B2 16 AND 35B3 33 CALLER 35B4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 35C9 16 AND 35CA 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 35EB 87 DUP8 35EC 87 DUP8 35ED 60 PUSH1 0x40 35EF 51 MLOAD 35F0 80 DUP1 35F1 83 DUP4 35F2 81 DUP2 35F3 52 MSTORE 35F4 60 PUSH1 0x20 35F6 01 ADD 35F7 82 DUP3 35F8 81 DUP2 35F9 52 MSTORE 35FA 60 PUSH1 0x20 35FC 01 ADD 35FD 92 SWAP3 35FE 50 POP 35FF 50 POP 3600 50 POP 3601 60 PUSH1 0x40 3603 51 MLOAD 3604 80 DUP1 3605 91 SWAP2 3606 03 SUB 3607 90 SWAP1 3608 A4 LOG4 3609 61 PUSH2 0x3616 360C 81 DUP2 360D 86 DUP7 360E 86 DUP7 360F 86 DUP7 3610 5A GAS 3611 87 DUP8 3612 61 PUSH2 0x3bc8 3615 56 *JUMP // Stack delta = +6 // Outputs[11] // { // @3583 stack[-2] = stack[-1] // @35F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-5] // @35F9 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-4] // @3608 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62, msg.sender, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff]); // @3609 stack[-1] = 0x3616 // @360C stack[0] = stack[-1] // @360D stack[1] = stack[-6] // @360E stack[2] = stack[-5] // @360F stack[3] = stack[-4] // @3610 stack[4] = msg.gas // @3611 stack[5] = stack[-3] // } // Block ends with call to 0x3bc8, returns to 0x3616 label_3616: // Incoming return from call to 0x3BC8 at 0x3615 // Inputs[1] { @361C stack[-6] } 3616 5B JUMPDEST 3617 50 POP 3618 50 POP 3619 50 POP 361A 50 POP 361B 50 POP 361C 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_361D: // Incoming call from 0x2FBA, returns to 0x2FBB // Inputs[4] // { // @361E stack[-2] // @361F memory[stack[-2]:stack[-2] + 0x20] // @3620 stack[-3] // @3621 memory[stack[-3]:stack[-3] + 0x20] // } 361D 5B JUMPDEST 361E 81 DUP2 361F 51 MLOAD 3620 83 DUP4 3621 51 MLOAD 3622 14 EQ 3623 61 PUSH2 0x3677 3626 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3677, if memory[stack[-3]:stack[-3] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] label_3627: // Incoming jump from 0x3626, if not memory[stack[-3]:stack[-3] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @3629 memory[0x40:0x60] // @3671 memory[0x40:0x60] // @3676 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 3627 60 PUSH1 0x40 3629 51 MLOAD 362A 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 364B 81 DUP2 364C 52 MSTORE 364D 60 PUSH1 0x04 364F 01 ADD 3650 80 DUP1 3651 80 DUP1 3652 60 PUSH1 0x20 3654 01 ADD 3655 82 DUP3 3656 81 DUP2 3657 03 SUB 3658 82 DUP3 3659 52 MSTORE 365A 60 PUSH1 0x30 365C 81 DUP2 365D 52 MSTORE 365E 60 PUSH1 0x20 3660 01 ADD 3661 80 DUP1 3662 61 PUSH2 0x4158 3665 60 PUSH1 0x30 3667 91 SWAP2 3668 39 CODECOPY 3669 60 PUSH1 0x40 366B 01 ADD 366C 91 SWAP2 366D 50 POP 366E 50 POP 366F 60 PUSH1 0x40 3671 51 MLOAD 3672 80 DUP1 3673 91 SWAP2 3674 03 SUB 3675 90 SWAP1 3676 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @364C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3659 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @365D memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x30 // @3668 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x30] = code[0x4158:0x4188] // @3676 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3677: // Incoming jump from 0x3626, if memory[stack[-3]:stack[-3] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @367A stack[-3] // @367B memory[stack[-3]:stack[-3] + 0x20] // @3687 memory[stack[-3]:stack[-3] + 0x20] // } 3677 5B JUMPDEST 3678 60 PUSH1 0x00 367A 83 DUP4 367B 51 MLOAD 367C 90 SWAP1 367D 50 POP 367E 60 PUSH1 0x00 3680 61 PUSH2 0x369c 3683 85 DUP6 3684 60 PUSH1 0x00 3686 81 DUP2 3687 51 MLOAD 3688 81 DUP2 3689 10 LT 368A 61 PUSH2 0x368f 368D 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @367C stack[0] = memory[stack[-3]:stack[-3] + 0x20] // @367E stack[1] = 0x00 // @3680 stack[2] = 0x369c // @3683 stack[3] = stack[-3] // @3684 stack[4] = 0x00 // } // Block ends with conditional call to 0x368f, returns to 0x369C, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] label_368E: // Incoming jump from 0x368D, if not 0x00 < memory[stack[-3]:stack[-3] + 0x20] 368E FE *ASSERT // Stack delta = +0 // Outputs[1] { @368E assert(); } // Block terminates label_368F: // Incoming call from 0x368D, returns to 0x369C, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[3] // { // @3692 stack[-1] // @3696 stack[-2] // @3697 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 368F 5B JUMPDEST 3690 60 PUSH1 0x20 3692 02 MUL 3693 60 PUSH1 0x20 3695 01 ADD 3696 01 ADD 3697 51 MLOAD 3698 61 PUSH2 0x3e04 369B 56 *JUMP // Stack delta = -1 // Outputs[1] { @3697 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x3e04 label_369C: // Incoming return from call to 0x368F at 0x368D // Inputs[3] // { // @369D stack[-1] // @369D stack[-2] // @36A5 stack[-3] // } 369C 5B JUMPDEST 369D 90 SWAP1 369E 50 POP 369F 60 PUSH1 0x00 36A1 80 DUP1 36A2 90 SWAP1 36A3 50 POP 36A4 5B JUMPDEST 36A5 82 DUP3 36A6 81 DUP2 36A7 10 LT 36A8 15 ISZERO 36A9 61 PUSH2 0x3876 36AC 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @369D stack[-2] = stack[-1] // @36A2 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x3876, if !(0x00 < stack[-3]) label_36AD: // Incoming jump from 0x36AC, if not !(stack[-1] < stack[-3]) // Incoming jump from 0x36AC, if not !(0x00 < stack[-3]) // Inputs[3] // { // @36AF stack[-6] // @36B0 stack[-1] // @36B2 memory[stack[-6]:stack[-6] + 0x20] // } 36AD 60 PUSH1 0x00 36AF 86 DUP7 36B0 82 DUP3 36B1 81 DUP2 36B2 51 MLOAD 36B3 81 DUP2 36B4 10 LT 36B5 61 PUSH2 0x36ba 36B8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @36AD stack[0] = 0x00 // @36AF stack[1] = stack[-6] // @36B0 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x36ba, if stack[-1] < memory[stack[-6]:stack[-6] + 0x20] label_36B9: // Incoming jump from 0x36B8, if not stack[-1] < memory[stack[-6]:stack[-6] + 0x20] 36B9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @36B9 assert(); } // Block terminates label_36BA: // Incoming jump from 0x36B8, if stack[-1] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[5] // { // @36BD stack[-1] // @36C1 stack[-2] // @36C2 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @36C3 stack[-3] // @36C5 stack[-5] // } 36BA 5B JUMPDEST 36BB 60 PUSH1 0x20 36BD 02 MUL 36BE 60 PUSH1 0x20 36C0 01 ADD 36C1 01 ADD 36C2 51 MLOAD 36C3 90 SWAP1 36C4 50 POP 36C5 82 DUP3 36C6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 36DB 16 AND 36DC 61 PUSH2 0x36e4 36DF 82 DUP3 36E0 61 PUSH2 0x3e04 36E3 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @36C3 stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @36DB stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @36DC stack[-1] = 0x36e4 // @36DF stack[0] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } // Block ends with call to 0x3e04, returns to 0x36E4 label_36E4: // Incoming return from call to 0x3E04 at 0x36E3 // Inputs[2] // { // @36FA stack[-1] // @36FB stack[-2] // } 36E4 5B JUMPDEST 36E5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 36FA 16 AND 36FB 14 EQ 36FC 61 PUSH2 0x3750 36FF 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x3750, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_3700: // Incoming jump from 0x36FF, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @3702 memory[0x40:0x60] // @374A memory[0x40:0x60] // @374F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 3700 60 PUSH1 0x40 3702 51 MLOAD 3703 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3724 81 DUP2 3725 52 MSTORE 3726 60 PUSH1 0x04 3728 01 ADD 3729 80 DUP1 372A 80 DUP1 372B 60 PUSH1 0x20 372D 01 ADD 372E 82 DUP3 372F 81 DUP2 3730 03 SUB 3731 82 DUP3 3732 52 MSTORE 3733 60 PUSH1 0x37 3735 81 DUP2 3736 52 MSTORE 3737 60 PUSH1 0x20 3739 01 ADD 373A 80 DUP1 373B 61 PUSH2 0x404f 373E 60 PUSH1 0x37 3740 91 SWAP2 3741 39 CODECOPY 3742 60 PUSH1 0x40 3744 01 ADD 3745 91 SWAP2 3746 50 POP 3747 50 POP 3748 60 PUSH1 0x40 374A 51 MLOAD 374B 80 DUP1 374C 91 SWAP2 374D 03 SUB 374E 90 SWAP1 374F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3725 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3732 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @3736 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x37 // @3741 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x37] = code[0x404f:0x4086] // @374F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3750: // Incoming jump from 0x36FF, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @3754 stack[-6] // @3755 stack[-2] // @3757 memory[stack[-6]:stack[-6] + 0x20] // } 3750 5B JUMPDEST 3751 61 PUSH2 0x37c5 3754 86 DUP7 3755 83 DUP4 3756 81 DUP2 3757 51 MLOAD 3758 81 DUP2 3759 10 LT 375A 61 PUSH2 0x375f 375D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3751 stack[0] = 0x37c5 // @3754 stack[1] = stack[-6] // @3755 stack[2] = stack[-2] // } // Block ends with conditional call to 0x375f, returns to 0x37C5, if stack[-2] < memory[stack[-6]:stack[-6] + 0x20] label_375E: // Incoming jump from 0x375D, if not stack[-2] < memory[stack[-6]:stack[-6] + 0x20] 375E FE *ASSERT // Stack delta = +0 // Outputs[1] { @375E assert(); } // Block terminates label_375F: // Incoming call from 0x375D, returns to 0x37C5, if stack[-2] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[8] // { // @3762 stack[-1] // @3766 stack[-2] // @3767 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @376B stack[-11] // @37A5 memory[0x00:0x40] // @37A8 stack[-4] // @37B6 memory[0x00:0x40] // @37B7 storage[keccak256(memory[0x00:0x40])] // } 375F 5B JUMPDEST 3760 60 PUSH1 0x20 3762 02 MUL 3763 60 PUSH1 0x20 3765 01 ADD 3766 01 ADD 3767 51 MLOAD 3768 60 PUSH1 0x00 376A 80 DUP1 376B 8B DUP12 376C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3781 16 AND 3782 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3797 16 AND 3798 81 DUP2 3799 52 MSTORE 379A 60 PUSH1 0x20 379C 01 ADD 379D 90 SWAP1 379E 81 DUP2 379F 52 MSTORE 37A0 60 PUSH1 0x20 37A2 01 ADD 37A3 60 PUSH1 0x00 37A5 20 SHA3 37A6 60 PUSH1 0x00 37A8 84 DUP5 37A9 81 DUP2 37AA 52 MSTORE 37AB 60 PUSH1 0x20 37AD 01 ADD 37AE 90 SWAP1 37AF 81 DUP2 37B0 52 MSTORE 37B1 60 PUSH1 0x20 37B3 01 ADD 37B4 60 PUSH1 0x00 37B6 20 SHA3 37B7 54 SLOAD 37B8 61 PUSH2 0x26f0 37BB 90 SWAP1 37BC 91 SWAP2 37BD 90 SWAP1 37BE 63 PUSH4 0xffffffff 37C3 16 AND 37C4 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @3799 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-11] // @379F memory[0x20:0x40] = 0x00 // @37AA memory[0x00:0x20] = stack[-4] // @37B0 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @37BC stack[-2] = storage[keccak256(memory[0x00:0x40])] // @37BD stack[-1] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0xffffffff & 0x26f0 label_37C5: // Incoming return from call to 0x375F at 0x375D // Inputs[8] // { // @37C9 stack[-9] // @3803 memory[0x00:0x40] // @3806 stack[-2] // @3814 memory[0x00:0x40] // @3815 stack[-1] // @381C stack[-7] // @381D stack[-3] // @381F memory[stack[-7]:stack[-7] + 0x20] // } 37C5 5B JUMPDEST 37C6 60 PUSH1 0x00 37C8 80 DUP1 37C9 8A DUP11 37CA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 37DF 16 AND 37E0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 37F5 16 AND 37F6 81 DUP2 37F7 52 MSTORE 37F8 60 PUSH1 0x20 37FA 01 ADD 37FB 90 SWAP1 37FC 81 DUP2 37FD 52 MSTORE 37FE 60 PUSH1 0x20 3800 01 ADD 3801 60 PUSH1 0x00 3803 20 SHA3 3804 60 PUSH1 0x00 3806 83 DUP4 3807 81 DUP2 3808 52 MSTORE 3809 60 PUSH1 0x20 380B 01 ADD 380C 90 SWAP1 380D 81 DUP2 380E 52 MSTORE 380F 60 PUSH1 0x20 3811 01 ADD 3812 60 PUSH1 0x00 3814 20 SHA3 3815 81 DUP2 3816 90 SWAP1 3817 55 SSTORE 3818 50 POP 3819 61 PUSH2 0x3851 381C 86 DUP7 381D 83 DUP4 381E 81 DUP2 381F 51 MLOAD 3820 81 DUP2 3821 10 LT 3822 61 PUSH2 0x3827 3825 57 *JUMPI // Stack delta = +2 // Outputs[8] // { // @37F7 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-9] // @37FD memory[0x20:0x40] = 0x00 // @3808 memory[0x00:0x20] = stack[-2] // @380E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @3817 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @3819 stack[-1] = 0x3851 // @381C stack[0] = stack[-7] // @381D stack[1] = stack[-3] // } // Block ends with conditional call to 0x3827, returns to 0x3851, if stack[-3] < memory[stack[-7]:stack[-7] + 0x20] label_3826: // Incoming jump from 0x3825, if not stack[-3] < memory[stack[-7]:stack[-7] + 0x20] 3826 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3826 assert(); } // Block terminates label_3827: // Incoming call from 0x3825, returns to 0x3851, if stack[-3] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[6] // { // @382A stack[-1] // @382E stack[-2] // @382F memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @3834 stack[-4] // @3842 memory[0x00:0x40] // @3843 storage[keccak256(memory[0x00:0x40])] // } 3827 5B JUMPDEST 3828 60 PUSH1 0x20 382A 02 MUL 382B 60 PUSH1 0x20 382D 01 ADD 382E 01 ADD 382F 51 MLOAD 3830 60 PUSH1 0x06 3832 60 PUSH1 0x00 3834 84 DUP5 3835 81 DUP2 3836 52 MSTORE 3837 60 PUSH1 0x20 3839 01 ADD 383A 90 SWAP1 383B 81 DUP2 383C 52 MSTORE 383D 60 PUSH1 0x20 383F 01 ADD 3840 60 PUSH1 0x00 3842 20 SHA3 3843 54 SLOAD 3844 61 PUSH2 0x26f0 3847 90 SWAP1 3848 91 SWAP2 3849 90 SWAP1 384A 63 PUSH4 0xffffffff 384F 16 AND 3850 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @3836 memory[0x00:0x20] = stack[-4] // @383C memory[0x20:0x40] = 0x06 // @3848 stack[-2] = storage[keccak256(memory[0x00:0x40])] // @3849 stack[-1] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0xffffffff & 0x26f0 label_3851: // Incoming return from call to 0x3827 at 0x3825 // Inputs[4] // { // @3856 stack[-2] // @3864 memory[0x00:0x40] // @3865 stack[-1] // @386A stack[-3] // } 3851 5B JUMPDEST 3852 60 PUSH1 0x06 3854 60 PUSH1 0x00 3856 83 DUP4 3857 81 DUP2 3858 52 MSTORE 3859 60 PUSH1 0x20 385B 01 ADD 385C 90 SWAP1 385D 81 DUP2 385E 52 MSTORE 385F 60 PUSH1 0x20 3861 01 ADD 3862 60 PUSH1 0x00 3864 20 SHA3 3865 81 DUP2 3866 90 SWAP1 3867 55 SSTORE 3868 50 POP 3869 50 POP 386A 80 DUP1 386B 80 DUP1 386C 60 PUSH1 0x01 386E 01 ADD 386F 91 SWAP2 3870 50 POP 3871 50 POP 3872 61 PUSH2 0x36a4 3875 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @3858 memory[0x00:0x20] = stack[-2] // @385E memory[0x20:0x40] = 0x06 // @3867 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @386F stack[-3] = 0x01 + stack[-3] // } // Block ends with unconditional jump to 0x36a4 label_3876: // Incoming jump from 0x36AC, if !(stack[-1] < stack[-3]) // Incoming jump from 0x36AC, if !(0x00 < stack[-3]) // Inputs[8] // { // @3878 stack[-7] // @388F stack[-2] // @38A6 msg.sender // @38DE stack[-6] // @38DF stack[-5] // @38E2 memory[0x40:0x60] // @38F4 memory[stack[-6]:stack[-6] + 0x20] // @38FD memory[stack[-6]:stack[-6] + 0x20] // } 3876 5B JUMPDEST 3877 50 POP 3878 85 DUP6 3879 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 388E 16 AND 388F 81 DUP2 3890 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 38A5 16 AND 38A6 33 CALLER 38A7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 38BC 16 AND 38BD 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 38DE 88 DUP9 38DF 88 DUP9 38E0 60 PUSH1 0x40 38E2 51 MLOAD 38E3 80 DUP1 38E4 80 DUP1 38E5 60 PUSH1 0x20 38E7 01 ADD 38E8 80 DUP1 38E9 60 PUSH1 0x20 38EB 01 ADD 38EC 83 DUP4 38ED 81 DUP2 38EE 03 SUB 38EF 83 DUP4 38F0 52 MSTORE 38F1 85 DUP6 38F2 81 DUP2 38F3 81 DUP2 38F4 51 MLOAD 38F5 81 DUP2 38F6 52 MSTORE 38F7 60 PUSH1 0x20 38F9 01 ADD 38FA 91 SWAP2 38FB 50 POP 38FC 80 DUP1 38FD 51 MLOAD 38FE 90 SWAP1 38FF 60 PUSH1 0x20 3901 01 ADD 3902 90 SWAP1 3903 60 PUSH1 0x20 3905 02 MUL 3906 80 DUP1 3907 83 DUP4 3908 83 DUP4 3909 60 PUSH1 0x00 390B 5B JUMPDEST 390C 83 DUP4 390D 81 DUP2 390E 10 LT 390F 15 ISZERO 3910 61 PUSH2 0x3926 3913 57 *JUMPI // Stack delta = +15 // Outputs[18] // { // @388E stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @38A5 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @38BC stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @38BD stack[2] = 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb // @38DE stack[3] = stack[-6] // @38DF stack[4] = stack[-5] // @38E2 stack[5] = memory[0x40:0x60] // @38E3 stack[6] = memory[0x40:0x60] // @38E7 stack[7] = 0x20 + memory[0x40:0x60] // @38F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @38F6 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-6]:stack[-6] + 0x20] // @38FA stack[8] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @3902 stack[9] = 0x20 + stack[-6] // @3905 stack[10] = 0x20 * memory[stack[-6]:stack[-6] + 0x20] // @3906 stack[11] = 0x20 * memory[stack[-6]:stack[-6] + 0x20] // @3907 stack[12] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @3908 stack[13] = 0x20 + stack[-6] // @3909 stack[14] = 0x00 // } // Block ends with conditional jump to 0x3926, if !(0x00 < 0x20 * memory[stack[-6]:stack[-6] + 0x20]) label_3914: // Incoming jump from 0x3913, if not !(0x00 < 0x20 * memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x3913, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @3914 stack[-1] // @3915 stack[-2] // @3917 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @3919 stack[-3] // } 3914 80 DUP1 3915 82 DUP3 3916 01 ADD 3917 51 MLOAD 3918 81 DUP2 3919 84 DUP5 391A 01 ADD 391B 52 MSTORE 391C 60 PUSH1 0x20 391E 81 DUP2 391F 01 ADD 3920 90 SWAP1 3921 50 POP 3922 61 PUSH2 0x390b 3925 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @391B memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @3920 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x390b label_3926: // Incoming jump from 0x3913, if !(0x00 < 0x20 * memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x3913, if !(stack[-1] < stack[-4]) // Inputs[8] // { // @392B stack[-5] // @392B stack[-6] // @392D stack[-7] // @392E stack[-10] // @3931 stack[-8] // @3933 stack[-11] // @3936 memory[stack[-11]:stack[-11] + 0x20] // @393F memory[stack[-11]:stack[-11] + 0x20] // } 3926 5B JUMPDEST 3927 50 POP 3928 50 POP 3929 50 POP 392A 50 POP 392B 90 SWAP1 392C 50 POP 392D 01 ADD 392E 83 DUP4 392F 81 DUP2 3930 03 SUB 3931 82 DUP3 3932 52 MSTORE 3933 84 DUP5 3934 81 DUP2 3935 81 DUP2 3936 51 MLOAD 3937 81 DUP2 3938 52 MSTORE 3939 60 PUSH1 0x20 393B 01 ADD 393C 91 SWAP2 393D 50 POP 393E 80 DUP1 393F 51 MLOAD 3940 90 SWAP1 3941 60 PUSH1 0x20 3943 01 ADD 3944 90 SWAP1 3945 60 PUSH1 0x20 3947 02 MUL 3948 80 DUP1 3949 83 DUP4 394A 83 DUP4 394B 60 PUSH1 0x00 394D 5B JUMPDEST 394E 83 DUP4 394F 81 DUP2 3950 10 LT 3951 15 ISZERO 3952 61 PUSH2 0x3968 3955 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @3932 memory[stack[-8]:stack[-8] + 0x20] = (stack[-5] + stack[-7]) - stack[-10] // @3938 memory[stack[-5] + stack[-7]:stack[-5] + stack[-7] + 0x20] = memory[stack[-11]:stack[-11] + 0x20] // @393C stack[-7] = 0x20 + stack[-5] + stack[-7] // @3944 stack[-6] = 0x20 + stack[-11] // @3947 stack[-5] = 0x20 * memory[stack[-11]:stack[-11] + 0x20] // @3948 stack[-4] = 0x20 * memory[stack[-11]:stack[-11] + 0x20] // @3949 stack[-3] = 0x20 + stack[-5] + stack[-7] // @394A stack[-2] = 0x20 + stack[-11] // @394B stack[-1] = 0x00 // } // Block ends with conditional jump to 0x3968, if !(0x00 < 0x20 * memory[stack[-11]:stack[-11] + 0x20]) label_3956: // Incoming jump from 0x3955, if not !(0x00 < 0x20 * memory[stack[-11]:stack[-11] + 0x20]) // Incoming jump from 0x3955, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @3956 stack[-1] // @3957 stack[-2] // @3959 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @395B stack[-3] // } 3956 80 DUP1 3957 82 DUP3 3958 01 ADD 3959 51 MLOAD 395A 81 DUP2 395B 84 DUP5 395C 01 ADD 395D 52 MSTORE 395E 60 PUSH1 0x20 3960 81 DUP2 3961 01 ADD 3962 90 SWAP1 3963 50 POP 3964 61 PUSH2 0x394d 3967 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @395D memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @3962 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x394d label_3968: // Incoming jump from 0x3955, if !(0x00 < 0x20 * memory[stack[-11]:stack[-11] + 0x20]) // Incoming jump from 0x3955, if !(stack[-1] < stack[-4]) // Inputs[16] // { // @396D stack[-5] // @396D stack[-6] // @396F stack[-7] // @3970 stack[-12] // @3978 memory[0x40:0x60] // @397D memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]] // @397D stack[-13] // @397D stack[-14] // @397D stack[-15] // @397D stack[-16] // @3981 stack[-17] // @3982 stack[-22] // @3983 stack[-21] // @3984 stack[-20] // @3985 msg.gas // @3986 stack[-19] // } 3968 5B JUMPDEST 3969 50 POP 396A 50 POP 396B 50 POP 396C 50 POP 396D 90 SWAP1 396E 50 POP 396F 01 ADD 3970 94 SWAP5 3971 50 POP 3972 50 POP 3973 50 POP 3974 50 POP 3975 50 POP 3976 60 PUSH1 0x40 3978 51 MLOAD 3979 80 DUP1 397A 91 SWAP2 397B 03 SUB 397C 90 SWAP1 397D A4 LOG4 397E 61 PUSH2 0x398b 3981 81 DUP2 3982 87 DUP8 3983 87 DUP8 3984 87 DUP8 3985 5A GAS 3986 88 DUP9 3987 61 PUSH2 0x2b3c 398A 56 *JUMP // Stack delta = -9 // Outputs[8] // { // @397D log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]], [stack[-13], stack[-14], stack[-15], stack[-16]]); // @397E stack[-16] = 0x398b // @3981 stack[-15] = stack[-17] // @3982 stack[-14] = stack[-22] // @3983 stack[-13] = stack[-21] // @3984 stack[-12] = stack[-20] // @3985 stack[-11] = msg.gas // @3986 stack[-10] = stack[-19] // } // Block ends with call to 0x2b3c, returns to 0x398B label_398B: // Incoming return from call to 0x2B3C at 0x398A // Inputs[1] { @3992 stack[-7] } 398B 5B JUMPDEST 398C 50 POP 398D 50 POP 398E 50 POP 398F 50 POP 3990 50 POP 3991 50 POP 3992 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_3993: // Incoming call from 0x306C, returns to 0x306D // Inputs[2] // { // @3996 stack[-1] // @39B0 stack[-2] // } 3993 5B JUMPDEST 3994 60 PUSH1 0x00 3996 81 DUP2 3997 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 39AC 16 AND 39AD 61 PUSH2 0x39b5 39B0 84 DUP5 39B1 61 PUSH2 0x3e16 39B4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3994 stack[0] = 0x00 // @39AC stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @39AD stack[2] = 0x39b5 // @39B0 stack[3] = stack[-2] // } // Block ends with call to 0x3e16, returns to 0x39B5 label_39B5: // Incoming return from call to 0x3E16 at 0x39B4 // Inputs[5] // { // @39CB stack[-1] // @39CC stack[-2] // @39CD stack[-3] // @39CF stack[-6] // @39D0 stack[-5] // } 39B5 5B JUMPDEST 39B6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 39CB 16 AND 39CC 14 EQ 39CD 90 SWAP1 39CE 50 POP 39CF 92 SWAP3 39D0 91 SWAP2 39D1 50 POP 39D2 50 POP 39D3 56 *JUMP // Stack delta = -5 // Outputs[1] { @39CF stack[-6] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-6] label_39D4: // Incoming call from 0x32B9, returns to 0x32BA // Inputs[6] // { // @39D8 stack[-1] // @39DC stack[-4] // @3A16 memory[0x00:0x40] // @3A19 stack[-2] // @3A27 memory[0x00:0x40] // @3A28 storage[keccak256(memory[0x00:0x40])] // } 39D4 5B JUMPDEST 39D5 61 PUSH2 0x3a36 39D8 81 DUP2 39D9 60 PUSH1 0x00 39DB 80 DUP1 39DC 87 DUP8 39DD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 39F2 16 AND 39F3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3A08 16 AND 3A09 81 DUP2 3A0A 52 MSTORE 3A0B 60 PUSH1 0x20 3A0D 01 ADD 3A0E 90 SWAP1 3A0F 81 DUP2 3A10 52 MSTORE 3A11 60 PUSH1 0x20 3A13 01 ADD 3A14 60 PUSH1 0x00 3A16 20 SHA3 3A17 60 PUSH1 0x00 3A19 85 DUP6 3A1A 81 DUP2 3A1B 52 MSTORE 3A1C 60 PUSH1 0x20 3A1E 01 ADD 3A1F 90 SWAP1 3A20 81 DUP2 3A21 52 MSTORE 3A22 60 PUSH1 0x20 3A24 01 ADD 3A25 60 PUSH1 0x00 3A27 20 SHA3 3A28 54 SLOAD 3A29 61 PUSH2 0x310a 3A2C 90 SWAP1 3A2D 91 SWAP2 3A2E 90 SWAP1 3A2F 63 PUSH4 0xffffffff 3A34 16 AND 3A35 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @39D5 stack[0] = 0x3a36 // @3A0A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @3A10 memory[0x20:0x40] = 0x00 // @3A1B memory[0x00:0x20] = stack[-2] // @3A21 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @3A2D stack[1] = storage[keccak256(memory[0x00:0x40])] // @3A2E stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x310a, returns to 0x3A36 label_3A36: // Incoming return from call to 0x310A at 0x3A35 // Inputs[10] // { // @3A3A stack[-5] // @3A74 memory[0x00:0x40] // @3A77 stack[-3] // @3A85 memory[0x00:0x40] // @3A86 stack[-1] // @3A8D stack[-2] // @3A91 stack[-4] // @3ACB memory[0x00:0x40] // @3ADC memory[0x00:0x40] // @3ADD storage[keccak256(memory[0x00:0x40])] // } 3A36 5B JUMPDEST 3A37 60 PUSH1 0x00 3A39 80 DUP1 3A3A 86 DUP7 3A3B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3A50 16 AND 3A51 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3A66 16 AND 3A67 81 DUP2 3A68 52 MSTORE 3A69 60 PUSH1 0x20 3A6B 01 ADD 3A6C 90 SWAP1 3A6D 81 DUP2 3A6E 52 MSTORE 3A6F 60 PUSH1 0x20 3A71 01 ADD 3A72 60 PUSH1 0x00 3A74 20 SHA3 3A75 60 PUSH1 0x00 3A77 84 DUP5 3A78 81 DUP2 3A79 52 MSTORE 3A7A 60 PUSH1 0x20 3A7C 01 ADD 3A7D 90 SWAP1 3A7E 81 DUP2 3A7F 52 MSTORE 3A80 60 PUSH1 0x20 3A82 01 ADD 3A83 60 PUSH1 0x00 3A85 20 SHA3 3A86 81 DUP2 3A87 90 SWAP1 3A88 55 SSTORE 3A89 50 POP 3A8A 61 PUSH2 0x3aeb 3A8D 81 DUP2 3A8E 60 PUSH1 0x00 3A90 80 DUP1 3A91 86 DUP7 3A92 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3AA7 16 AND 3AA8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3ABD 16 AND 3ABE 81 DUP2 3ABF 52 MSTORE 3AC0 60 PUSH1 0x20 3AC2 01 ADD 3AC3 90 SWAP1 3AC4 81 DUP2 3AC5 52 MSTORE 3AC6 60 PUSH1 0x20 3AC8 01 ADD 3AC9 60 PUSH1 0x00 3ACB 20 SHA3 3ACC 60 PUSH1 0x00 3ACE 85 DUP6 3ACF 81 DUP2 3AD0 52 MSTORE 3AD1 60 PUSH1 0x20 3AD3 01 ADD 3AD4 90 SWAP1 3AD5 81 DUP2 3AD6 52 MSTORE 3AD7 60 PUSH1 0x20 3AD9 01 ADD 3ADA 60 PUSH1 0x00 3ADC 20 SHA3 3ADD 54 SLOAD 3ADE 61 PUSH2 0x26f0 3AE1 90 SWAP1 3AE2 91 SWAP2 3AE3 90 SWAP1 3AE4 63 PUSH4 0xffffffff 3AE9 16 AND 3AEA 56 *JUMP // Stack delta = +2 // Outputs[12] // { // @3A68 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @3A6E memory[0x20:0x40] = 0x00 // @3A79 memory[0x00:0x20] = stack[-3] // @3A7F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @3A88 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @3A8A stack[-1] = 0x3aeb // @3ABF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @3AC5 memory[0x20:0x40] = 0x00 // @3AD0 memory[0x00:0x20] = stack[-3] // @3AD6 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @3AE2 stack[0] = storage[keccak256(memory[0x00:0x40])] // @3AE3 stack[1] = stack[-2] // } // Block ends with call to 0xffffffff & 0x26f0, returns to 0x3AEB label_3AEB: // Incoming return from call to 0x26F0 at 0x3AEA // Inputs[12] // { // @3AEF stack[-4] // @3B29 memory[0x00:0x40] // @3B2C stack[-3] // @3B3A memory[0x00:0x40] // @3B3B stack[-1] // @3B56 stack[-5] // @3B6D msg.sender // @3BA6 stack[-2] // @3BA9 memory[0x40:0x60] // @3BBD memory[0x40:0x60] // @3BC2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @3BC7 stack[-6] // } 3AEB 5B JUMPDEST 3AEC 60 PUSH1 0x00 3AEE 80 DUP1 3AEF 85 DUP6 3AF0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3B05 16 AND 3B06 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3B1B 16 AND 3B1C 81 DUP2 3B1D 52 MSTORE 3B1E 60 PUSH1 0x20 3B20 01 ADD 3B21 90 SWAP1 3B22 81 DUP2 3B23 52 MSTORE 3B24 60 PUSH1 0x20 3B26 01 ADD 3B27 60 PUSH1 0x00 3B29 20 SHA3 3B2A 60 PUSH1 0x00 3B2C 84 DUP5 3B2D 81 DUP2 3B2E 52 MSTORE 3B2F 60 PUSH1 0x20 3B31 01 ADD 3B32 90 SWAP1 3B33 81 DUP2 3B34 52 MSTORE 3B35 60 PUSH1 0x20 3B37 01 ADD 3B38 60 PUSH1 0x00 3B3A 20 SHA3 3B3B 81 DUP2 3B3C 90 SWAP1 3B3D 55 SSTORE 3B3E 50 POP 3B3F 82 DUP3 3B40 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3B55 16 AND 3B56 84 DUP5 3B57 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3B6C 16 AND 3B6D 33 CALLER 3B6E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3B83 16 AND 3B84 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 3BA5 85 DUP6 3BA6 85 DUP6 3BA7 60 PUSH1 0x40 3BA9 51 MLOAD 3BAA 80 DUP1 3BAB 83 DUP4 3BAC 81 DUP2 3BAD 52 MSTORE 3BAE 60 PUSH1 0x20 3BB0 01 ADD 3BB1 82 DUP3 3BB2 81 DUP2 3BB3 52 MSTORE 3BB4 60 PUSH1 0x20 3BB6 01 ADD 3BB7 92 SWAP3 3BB8 50 POP 3BB9 50 POP 3BBA 50 POP 3BBB 60 PUSH1 0x40 3BBD 51 MLOAD 3BBE 80 DUP1 3BBF 91 SWAP2 3BC0 03 SUB 3BC1 90 SWAP1 3BC2 A4 LOG4 3BC3 50 POP 3BC4 50 POP 3BC5 50 POP 3BC6 50 POP 3BC7 56 *JUMP // Stack delta = -6 // Outputs[8] // { // @3B1D memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @3B23 memory[0x20:0x40] = 0x00 // @3B2E memory[0x00:0x20] = stack[-3] // @3B34 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @3B3D storage[keccak256(memory[0x00:0x40])] = stack[-1] // @3BAD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @3BB3 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-2] // @3BC2 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62, msg.sender, stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-6] label_3BC8: // Incoming call from 0x32C7, returns to 0x32C8 // Incoming call from 0x3615, returns to 0x3616 // Inputs[1] { @3BCC stack[-5] } 3BC8 5B JUMPDEST 3BC9 61 PUSH2 0x3be7 3BCC 85 DUP6 3BCD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3BE2 16 AND 3BE3 61 PUSH2 0x3440 3BE6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3BC9 stack[0] = 0x3be7 // @3BE2 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // } // Block ends with call to 0x3440, returns to 0x3BE7 label_3BE7: // Incoming return from call to 0x3440 at 0x3BE6 // Inputs[1] { @3BE8 stack[-1] } 3BE7 5B JUMPDEST 3BE8 15 ISZERO 3BE9 61 PUSH2 0x3dfc 3BEC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x3dfc, if !stack[-1] label_3BED: // Incoming jump from 0x3BEC, if not !stack[-1] // Inputs[10] // { // @3BEF stack[-5] // @3C0B stack[-2] // @3C0C msg.sender // @3C0D stack[-6] // @3C0E stack[-4] // @3C0F stack[-3] // @3C10 stack[-1] // @3C13 memory[0x40:0x60] // @3CA0 memory[stack[-1]:stack[-1] + 0x20] // @3CA9 memory[stack[-1]:stack[-1] + 0x20] // } 3BED 60 PUSH1 0x00 3BEF 85 DUP6 3BF0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3C05 16 AND 3C06 63 PUSH4 0xf23a6e61 3C0B 84 DUP5 3C0C 33 CALLER 3C0D 8A DUP11 3C0E 89 DUP10 3C0F 89 DUP10 3C10 88 DUP9 3C11 60 PUSH1 0x40 3C13 51 MLOAD 3C14 87 DUP8 3C15 63 PUSH4 0xffffffff 3C1A 16 AND 3C1B 60 PUSH1 0xe0 3C1D 1B SHL 3C1E 81 DUP2 3C1F 52 MSTORE 3C20 60 PUSH1 0x04 3C22 01 ADD 3C23 80 DUP1 3C24 86 DUP7 3C25 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3C3A 16 AND 3C3B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3C50 16 AND 3C51 81 DUP2 3C52 52 MSTORE 3C53 60 PUSH1 0x20 3C55 01 ADD 3C56 85 DUP6 3C57 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3C6C 16 AND 3C6D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3C82 16 AND 3C83 81 DUP2 3C84 52 MSTORE 3C85 60 PUSH1 0x20 3C87 01 ADD 3C88 84 DUP5 3C89 81 DUP2 3C8A 52 MSTORE 3C8B 60 PUSH1 0x20 3C8D 01 ADD 3C8E 83 DUP4 3C8F 81 DUP2 3C90 52 MSTORE 3C91 60 PUSH1 0x20 3C93 01 ADD 3C94 80 DUP1 3C95 60 PUSH1 0x20 3C97 01 ADD 3C98 82 DUP3 3C99 81 DUP2 3C9A 03 SUB 3C9B 82 DUP3 3C9C 52 MSTORE 3C9D 83 DUP4 3C9E 81 DUP2 3C9F 81 DUP2 3CA0 51 MLOAD 3CA1 81 DUP2 3CA2 52 MSTORE 3CA3 60 PUSH1 0x20 3CA5 01 ADD 3CA6 91 SWAP2 3CA7 50 POP 3CA8 80 DUP1 3CA9 51 MLOAD 3CAA 90 SWAP1 3CAB 60 PUSH1 0x20 3CAD 01 ADD 3CAE 90 SWAP1 3CAF 80 DUP1 3CB0 83 DUP4 3CB1 83 DUP4 3CB2 60 PUSH1 0x00 3CB4 5B JUMPDEST 3CB5 83 DUP4 3CB6 81 DUP2 3CB7 10 LT 3CB8 15 ISZERO 3CB9 61 PUSH2 0x3ccf 3CBC 57 *JUMPI // Stack delta = +18 // Outputs[25] // { // @3BED stack[0] = 0x00 // @3C05 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @3C06 stack[2] = 0xf23a6e61 // @3C0B stack[3] = stack[-2] // @3C0C stack[4] = msg.sender // @3C0D stack[5] = stack[-6] // @3C0E stack[6] = stack[-4] // @3C0F stack[7] = stack[-3] // @3C10 stack[8] = stack[-1] // @3C1F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xf23a6e61) << 0xe0 // @3C22 stack[9] = 0x04 + memory[0x40:0x60] // @3C52 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @3C84 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @3C8A memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-4] // @3C90 memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-3] // @3C93 stack[10] = 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @3C9C memory[0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @3CA2 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @3CA6 stack[11] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @3CAE stack[12] = 0x20 + stack[-1] // @3CAE stack[13] = memory[stack[-1]:stack[-1] + 0x20] // @3CAF stack[14] = memory[stack[-1]:stack[-1] + 0x20] // @3CB0 stack[15] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @3CB1 stack[16] = 0x20 + stack[-1] // @3CB2 stack[17] = 0x00 // } // Block ends with conditional jump to 0x3ccf, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_3CBD: // Incoming jump from 0x3CBC, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x3CBC, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @3CBD stack[-1] // @3CBE stack[-2] // @3CC0 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @3CC2 stack[-3] // } 3CBD 80 DUP1 3CBE 82 DUP3 3CBF 01 ADD 3CC0 51 MLOAD 3CC1 81 DUP2 3CC2 84 DUP5 3CC3 01 ADD 3CC4 52 MSTORE 3CC5 60 PUSH1 0x20 3CC7 81 DUP2 3CC8 01 ADD 3CC9 90 SWAP1 3CCA 50 POP 3CCB 61 PUSH2 0x3cb4 3CCE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3CC4 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @3CC9 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x3cb4 label_3CCF: // Incoming jump from 0x3CBC, if !(stack[-1] < stack[-4]) // Incoming jump from 0x3CBC, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @3CD4 stack[-6] // @3CD4 stack[-5] // @3CD6 stack[-7] // } 3CCF 5B JUMPDEST 3CD0 50 POP 3CD1 50 POP 3CD2 50 POP 3CD3 50 POP 3CD4 90 SWAP1 3CD5 50 POP 3CD6 90 SWAP1 3CD7 81 DUP2 3CD8 01 ADD 3CD9 90 SWAP1 3CDA 60 PUSH1 0x1f 3CDC 16 AND 3CDD 80 DUP1 3CDE 15 ISZERO 3CDF 61 PUSH2 0x3cfc 3CE2 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @3CD9 stack[-7] = stack[-5] + stack[-7] // @3CDC stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x3cfc, if !(0x1f & stack[-5]) label_3CE3: // Incoming jump from 0x3CE2, if not !(0x1f & stack[-5]) // Inputs[7] // { // @3CE3 stack[-1] // @3CE4 stack[-2] // @3CE7 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @3CFE stack[-9] // @3D0A memory[0x40:0x60] // @3D11 stack[-12] // @3D13 address(stack[-12]).code.length // } 3CE3 80 DUP1 3CE4 82 DUP3 3CE5 03 SUB 3CE6 80 DUP1 3CE7 51 MLOAD 3CE8 60 PUSH1 0x01 3CEA 83 DUP4 3CEB 60 PUSH1 0x20 3CED 03 SUB 3CEE 61 PUSH2 0x0100 3CF1 0A EXP 3CF2 03 SUB 3CF3 19 NOT 3CF4 16 AND 3CF5 81 DUP2 3CF6 52 MSTORE 3CF7 60 PUSH1 0x20 3CF9 01 ADD 3CFA 91 SWAP2 3CFB 50 POP 3CFC 5B JUMPDEST 3CFD 50 POP 3CFE 96 SWAP7 3CFF 50 POP 3D00 50 POP 3D01 50 POP 3D02 50 POP 3D03 50 POP 3D04 50 POP 3D05 50 POP 3D06 60 PUSH1 0x20 3D08 60 PUSH1 0x40 3D0A 51 MLOAD 3D0B 80 DUP1 3D0C 83 DUP4 3D0D 03 SUB 3D0E 81 DUP2 3D0F 60 PUSH1 0x00 3D11 88 DUP9 3D12 80 DUP1 3D13 3B EXTCODESIZE 3D14 15 ISZERO 3D15 80 DUP1 3D16 15 ISZERO 3D17 61 PUSH2 0x3d1f 3D1A 57 *JUMPI // Stack delta = -1 // Outputs[9] // { // @3CF6 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @3CFE stack[-9] = 0x20 + (stack[-2] - stack[-1]) // @3D06 stack[-8] = 0x20 // @3D0A stack[-7] = memory[0x40:0x60] // @3D0D stack[-6] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @3D0E stack[-5] = memory[0x40:0x60] // @3D0F stack[-4] = 0x00 // @3D11 stack[-3] = stack[-12] // @3D14 stack[-2] = !address(stack[-12]).code.length // } // Block ends with conditional jump to 0x3d1f, if !!address(stack[-12]).code.length label_3D1B: // Incoming jump from 0x3D1A, if not !!address(stack[-12]).code.length // Incoming jump from 0x3D1A, if not !!address(stack[-12]).code.length // Inputs[1] { @3D1E memory[0x00:0x00] } 3D1B 60 PUSH1 0x00 3D1D 80 DUP1 3D1E FD *REVERT // Stack delta = +0 // Outputs[1] { @3D1E revert(memory[0x00:0x00]); } // Block terminates label_3D1F: // Incoming jump from 0x3D1A, if !!address(stack[-12]).code.length // Incoming jump from 0x3D1A, if !!address(stack[-12]).code.length // Inputs[9] // { // @3D21 stack[-9] // @3D22 stack[-3] // @3D22 memory[stack[-4]:stack[-4] + stack[-5]] // @3D22 stack[-7] // @3D22 stack[-2] // @3D22 stack[-6] // @3D22 stack[-4] // @3D22 address(stack[-2]).call.gas(stack[-9]).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @3D22 stack[-5] // } 3D1F 5B JUMPDEST 3D20 50 POP 3D21 87 DUP8 3D22 F1 CALL 3D23 15 ISZERO 3D24 80 DUP1 3D25 15 ISZERO 3D26 61 PUSH2 0x3d33 3D29 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @3D22 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(stack[-9]).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @3D23 stack[-7] = !address(stack[-2]).call.gas(stack[-9]).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x3d33, if !!address(stack[-2]).call.gas(stack[-9]).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_3D2A: // Incoming jump from 0x3D29, if not !!address(stack[-2]).call.gas(stack[-9]).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @3D2A returndata.length // @3D2E returndata[0x00:0x00 + returndata.length] // @3D2F returndata.length // @3D32 memory[0x00:0x00 + returndata.length] // } 3D2A 3D RETURNDATASIZE 3D2B 60 PUSH1 0x00 3D2D 80 DUP1 3D2E 3E RETURNDATACOPY 3D2F 3D RETURNDATASIZE 3D30 60 PUSH1 0x00 3D32 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3D2E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @3D32 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_3D33: // Incoming jump from 0x3D29, if !!address(stack[-2]).call.gas(stack[-9]).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @3D3B memory[0x40:0x60] // @3D3C returndata.length // } 3D33 5B JUMPDEST 3D34 50 POP 3D35 50 POP 3D36 50 POP 3D37 50 POP 3D38 50 POP 3D39 60 PUSH1 0x40 3D3B 51 MLOAD 3D3C 3D RETURNDATASIZE 3D3D 60 PUSH1 0x20 3D3F 81 DUP2 3D40 10 LT 3D41 15 ISZERO 3D42 61 PUSH2 0x3d4a 3D45 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @3D3B stack[-5] = memory[0x40:0x60] // @3D3C stack[-4] = returndata.length // } // Block ends with conditional jump to 0x3d4a, if !(returndata.length < 0x20) label_3D46: // Incoming jump from 0x3D45, if not !(returndata.length < 0x20) // Inputs[1] { @3D49 memory[0x00:0x00] } 3D46 60 PUSH1 0x00 3D48 80 DUP1 3D49 FD *REVERT // Stack delta = +0 // Outputs[1] { @3D49 revert(memory[0x00:0x00]); } // Block terminates label_3D4A: // Incoming jump from 0x3D45, if !(returndata.length < 0x20) // Inputs[4] // { // @3D4B stack[-2] // @3D4C stack[-1] // @3D50 memory[stack[-2]:stack[-2] + 0x20] // @3D5C stack[-3] // } 3D4A 5B JUMPDEST 3D4B 81 DUP2 3D4C 01 ADD 3D4D 90 SWAP1 3D4E 80 DUP1 3D4F 80 DUP1 3D50 51 MLOAD 3D51 90 SWAP1 3D52 60 PUSH1 0x20 3D54 01 ADD 3D55 90 SWAP1 3D56 92 SWAP3 3D57 91 SWAP2 3D58 90 SWAP1 3D59 50 POP 3D5A 50 POP 3D5B 50 POP 3D5C 90 SWAP1 3D5D 50 POP 3D5E 63 PUSH4 0xf23a6e61 3D63 60 PUSH1 0xe0 3D65 1B SHL 3D66 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 3D83 19 NOT 3D84 16 AND 3D85 81 DUP2 3D86 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 3DA3 19 NOT 3DA4 16 AND 3DA5 14 EQ 3DA6 61 PUSH2 0x3dfa 3DA9 57 *JUMPI // Stack delta = -2 // Outputs[1] { @3D5C stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x3dfa, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xf23a6e61 << 0xe0) label_3DAA: // Incoming jump from 0x3DA9, if not ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xf23a6e61 << 0xe0) // Inputs[3] // { // @3DAC memory[0x40:0x60] // @3DF4 memory[0x40:0x60] // @3DF9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 3DAA 60 PUSH1 0x40 3DAC 51 MLOAD 3DAD 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3DCE 81 DUP2 3DCF 52 MSTORE 3DD0 60 PUSH1 0x04 3DD2 01 ADD 3DD3 80 DUP1 3DD4 80 DUP1 3DD5 60 PUSH1 0x20 3DD7 01 ADD 3DD8 82 DUP3 3DD9 81 DUP2 3DDA 03 SUB 3DDB 82 DUP3 3DDC 52 MSTORE 3DDD 60 PUSH1 0x3a 3DDF 81 DUP2 3DE0 52 MSTORE 3DE1 60 PUSH1 0x20 3DE3 01 ADD 3DE4 80 DUP1 3DE5 61 PUSH2 0x4252 3DE8 60 PUSH1 0x3a 3DEA 91 SWAP2 3DEB 39 CODECOPY 3DEC 60 PUSH1 0x40 3DEE 01 ADD 3DEF 91 SWAP2 3DF0 50 POP 3DF1 50 POP 3DF2 60 PUSH1 0x40 3DF4 51 MLOAD 3DF5 80 DUP1 3DF6 91 SWAP2 3DF7 03 SUB 3DF8 90 SWAP1 3DF9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3DCF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3DDC memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @3DE0 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x3a // @3DEB memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x3a] = code[0x4252:0x428c] // @3DF9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3DFA: // Incoming jump from 0x3DA9, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xf23a6e61 << 0xe0) 3DFA 5B JUMPDEST 3DFB 50 POP // Stack delta = -1 // Block continues label_3DFC: // Incoming jump from 0x3DFB // Incoming jump from 0x3BEC, if !stack[-1] // Inputs[1] { @3E03 stack[-7] } 3DFC 5B JUMPDEST 3DFD 50 POP 3DFE 50 POP 3DFF 50 POP 3E00 50 POP 3E01 50 POP 3E02 50 POP 3E03 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_3E04: // Incoming jump from 0x369B // Incoming call from 0x3581, returns to 0x3582 // Incoming call from 0x36E3, returns to 0x36E4 // Inputs[1] { @3E0A stack[-1] } 3E04 5B JUMPDEST 3E05 60 PUSH1 0x00 3E07 61 PUSH2 0x3e0f 3E0A 82 DUP3 3E0B 61 PUSH2 0x3415 3E0E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3E05 stack[0] = 0x00 // @3E07 stack[1] = 0x3e0f // @3E0A stack[2] = stack[-1] // } // Block ends with call to 0x3415, returns to 0x3E0F label_3E0F: // Incoming return from call to 0x3415 at 0x3E0E // Inputs[4] // { // @3E10 stack[-2] // @3E10 stack[-1] // @3E12 stack[-4] // @3E13 stack[-3] // } 3E0F 5B JUMPDEST 3E10 90 SWAP1 3E11 50 POP 3E12 91 SWAP2 3E13 90 SWAP1 3E14 50 POP 3E15 56 *JUMP // Stack delta = -3 // Outputs[1] { @3E12 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_3E16: // Incoming call from 0x39B4, returns to 0x39B5 // Inputs[5] // { // @3E1F storage[0x03] // @3E5B stack[-1] // @3E5E memory[0x40:0x60] // @3EA8 memory[0x40:0x60] // @3EAF address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] / 0x0100 ** 0x00).code.length // } 3E16 5B JUMPDEST 3E17 60 PUSH1 0x00 3E19 80 DUP1 3E1A 60 PUSH1 0x03 3E1C 60 PUSH1 0x00 3E1E 90 SWAP1 3E1F 54 SLOAD 3E20 90 SWAP1 3E21 61 PUSH2 0x0100 3E24 0A EXP 3E25 90 SWAP1 3E26 04 DIV 3E27 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3E3C 16 AND 3E3D 90 SWAP1 3E3E 50 POP 3E3F 80 DUP1 3E40 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3E55 16 AND 3E56 63 PUSH4 0xc4552791 3E5B 84 DUP5 3E5C 60 PUSH1 0x40 3E5E 51 MLOAD 3E5F 82 DUP3 3E60 63 PUSH4 0xffffffff 3E65 16 AND 3E66 60 PUSH1 0xe0 3E68 1B SHL 3E69 81 DUP2 3E6A 52 MSTORE 3E6B 60 PUSH1 0x04 3E6D 01 ADD 3E6E 80 DUP1 3E6F 82 DUP3 3E70 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3E85 16 AND 3E86 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3E9B 16 AND 3E9C 81 DUP2 3E9D 52 MSTORE 3E9E 60 PUSH1 0x20 3EA0 01 ADD 3EA1 91 SWAP2 3EA2 50 POP 3EA3 50 POP 3EA4 60 PUSH1 0x20 3EA6 60 PUSH1 0x40 3EA8 51 MLOAD 3EA9 80 DUP1 3EAA 83 DUP4 3EAB 03 SUB 3EAC 81 DUP2 3EAD 86 DUP7 3EAE 80 DUP1 3EAF 3B EXTCODESIZE 3EB0 15 ISZERO 3EB1 80 DUP1 3EB2 15 ISZERO 3EB3 61 PUSH2 0x3ebb 3EB6 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @3E17 stack[0] = 0x00 // @3E3D stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] / 0x0100 ** 0x00 // @3E55 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] / 0x0100 ** 0x00 // @3E56 stack[3] = 0xc4552791 // @3E6A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xc4552791) << 0xe0 // @3E9D memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @3EA1 stack[4] = 0x20 + 0x04 + memory[0x40:0x60] // @3EA4 stack[5] = 0x20 // @3EA8 stack[6] = memory[0x40:0x60] // @3EAB stack[7] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @3EAC stack[8] = memory[0x40:0x60] // @3EAD stack[9] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] / 0x0100 ** 0x00 // @3EB0 stack[10] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x3ebb, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] / 0x0100 ** 0x00).code.length label_3EB7: // Incoming jump from 0x3EB6, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] / 0x0100 ** 0x00).code.length // Inputs[1] { @3EBA memory[0x00:0x00] } 3EB7 60 PUSH1 0x00 3EB9 80 DUP1 3EBA FD *REVERT // Stack delta = +0 // Outputs[1] { @3EBA revert(memory[0x00:0x00]); } // Block terminates label_3EBB: // Incoming jump from 0x3EB6, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] / 0x0100 ** 0x00).code.length // Inputs[8] // { // @3EBD msg.gas // @3EBE stack[-3] // @3EBE address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3EBE memory[stack[-3]:stack[-3] + stack[-4]] // @3EBE stack[-6] // @3EBE stack[-4] // @3EBE stack[-5] // @3EBE stack[-2] // } 3EBB 5B JUMPDEST 3EBC 50 POP 3EBD 5A GAS 3EBE FA STATICCALL 3EBF 15 ISZERO 3EC0 80 DUP1 3EC1 15 ISZERO 3EC2 61 PUSH2 0x3ecf 3EC5 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @3EBE memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3EBF stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x3ecf, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_3EC6: // Incoming jump from 0x3EC5, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @3EC6 returndata.length // @3ECA returndata[0x00:0x00 + returndata.length] // @3ECB returndata.length // @3ECE memory[0x00:0x00 + returndata.length] // } 3EC6 3D RETURNDATASIZE 3EC7 60 PUSH1 0x00 3EC9 80 DUP1 3ECA 3E RETURNDATACOPY 3ECB 3D RETURNDATASIZE 3ECC 60 PUSH1 0x00 3ECE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3ECA memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @3ECE revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_3ECF: // Incoming jump from 0x3EC5, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @3ED6 memory[0x40:0x60] // @3ED7 returndata.length // } 3ECF 5B JUMPDEST 3ED0 50 POP 3ED1 50 POP 3ED2 50 POP 3ED3 50 POP 3ED4 60 PUSH1 0x40 3ED6 51 MLOAD 3ED7 3D RETURNDATASIZE 3ED8 60 PUSH1 0x20 3EDA 81 DUP2 3EDB 10 LT 3EDC 15 ISZERO 3EDD 61 PUSH2 0x3ee5 3EE0 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3ED6 stack[-4] = memory[0x40:0x60] // @3ED7 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x3ee5, if !(returndata.length < 0x20) label_3EE1: // Incoming jump from 0x3EE0, if not !(returndata.length < 0x20) // Inputs[1] { @3EE4 memory[0x00:0x00] } 3EE1 60 PUSH1 0x00 3EE3 80 DUP1 3EE4 FD *REVERT // Stack delta = +0 // Outputs[1] { @3EE4 revert(memory[0x00:0x00]); } // Block terminates label_3EE5: // Incoming jump from 0x3EE0, if !(returndata.length < 0x20) // Inputs[6] // { // @3EE6 stack[-2] // @3EE7 stack[-1] // @3EEB memory[stack[-2]:stack[-2] + 0x20] // @3EF7 stack[-4] // @3EFA stack[-6] // @3EFB stack[-5] // } 3EE5 5B JUMPDEST 3EE6 81 DUP2 3EE7 01 ADD 3EE8 90 SWAP1 3EE9 80 DUP1 3EEA 80 DUP1 3EEB 51 MLOAD 3EEC 90 SWAP1 3EED 60 PUSH1 0x20 3EEF 01 ADD 3EF0 90 SWAP1 3EF1 92 SWAP3 3EF2 91 SWAP2 3EF3 90 SWAP1 3EF4 50 POP 3EF5 50 POP 3EF6 50 POP 3EF7 91 SWAP2 3EF8 50 POP 3EF9 50 POP 3EFA 91 SWAP2 3EFB 90 SWAP1 3EFC 50 POP 3EFD 56 *JUMP // Stack delta = -5 // Outputs[1] { @3EFA stack[-6] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-6] label_3EFE: // Incoming call from 0x1673, returns to 0x1674 // Incoming call from 0x2F0C, returns to 0x2F0D // Inputs[5] // { // @3EFF stack[-3] // @3F01 storage[stack[-3]] // @3F1B memory[0x00:0x20] // @3F26 stack[-2] // @3F27 stack[-1] // } 3EFE 5B JUMPDEST 3EFF 82 DUP3 3F00 80 DUP1 3F01 54 SLOAD 3F02 60 PUSH1 0x01 3F04 81 DUP2 3F05 60 PUSH1 0x01 3F07 16 AND 3F08 15 ISZERO 3F09 61 PUSH2 0x0100 3F0C 02 MUL 3F0D 03 SUB 3F0E 16 AND 3F0F 60 PUSH1 0x02 3F11 90 SWAP1 3F12 04 DIV 3F13 90 SWAP1 3F14 60 PUSH1 0x00 3F16 52 MSTORE 3F17 60 PUSH1 0x20 3F19 60 PUSH1 0x00 3F1B 20 SHA3 3F1C 90 SWAP1 3F1D 60 PUSH1 0x1f 3F1F 01 ADD 3F20 60 PUSH1 0x20 3F22 90 SWAP1 3F23 04 DIV 3F24 81 DUP2 3F25 01 ADD 3F26 92 SWAP3 3F27 82 DUP3 3F28 60 PUSH1 0x1f 3F2A 10 LT 3F2B 61 PUSH2 0x3f3f 3F2E 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @3F16 memory[0x00:0x20] = stack[-3] // @3F1C stack[0] = keccak256(memory[0x00:0x20]) // @3F26 stack[1] = stack[-2] // @3F26 stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x3f3f, if 0x1f < stack[-1] label_3F2F: // Incoming jump from 0x3F2E, if not 0x1f < stack[-1] // Inputs[4] // { // @3F2F stack[-1] // @3F30 memory[stack[-1]:stack[-1] + 0x20] // @3F35 stack[-3] // @3F39 stack[-5] // } 3F2F 80 DUP1 3F30 51 MLOAD 3F31 60 PUSH1 0xff 3F33 19 NOT 3F34 16 AND 3F35 83 DUP4 3F36 80 DUP1 3F37 01 ADD 3F38 17 OR 3F39 85 DUP6 3F3A 55 SSTORE 3F3B 61 PUSH2 0x3f6d 3F3E 56 *JUMP // Stack delta = +0 // Outputs[1] { @3F3A storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x3f6d label_3F3F: // Incoming jump from 0x3F2E, if 0x1f < stack[-1] // Inputs[2] // { // @3F40 stack[-3] // @3F46 stack[-5] // } 3F3F 5B JUMPDEST 3F40 82 DUP3 3F41 80 DUP1 3F42 01 ADD 3F43 60 PUSH1 0x01 3F45 01 ADD 3F46 85 DUP6 3F47 55 SSTORE 3F48 82 DUP3 3F49 15 ISZERO 3F4A 61 PUSH2 0x3f6d 3F4D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3F47 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x3f6d, if !stack[-3] label_3F4E: // Incoming jump from 0x3F4D, if not !stack[-3] // Inputs[2] // { // @3F4E stack[-3] // @3F4E stack[-1] // } 3F4E 91 SWAP2 3F4F 82 DUP3 3F50 01 ADD 3F51 5B JUMPDEST 3F52 82 DUP3 3F53 81 DUP2 3F54 11 GT 3F55 15 ISZERO 3F56 61 PUSH2 0x3f6c 3F59 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @3F4E stack[-3] = stack[-1] // @3F50 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x3f6c, if !(stack[-1] + stack[-3] > stack[-1]) label_3F5A: // Incoming jump from 0x3F59, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x3F59, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @3F5A stack[-3] // @3F5B memory[stack[-3]:stack[-3] + 0x20] // @3F5C stack[-2] // @3F5E stack[-1] // } 3F5A 82 DUP3 3F5B 51 MLOAD 3F5C 82 DUP3 3F5D 55 SSTORE 3F5E 91 SWAP2 3F5F 60 PUSH1 0x20 3F61 01 ADD 3F62 91 SWAP2 3F63 90 SWAP1 3F64 60 PUSH1 0x01 3F66 01 ADD 3F67 90 SWAP1 3F68 61 PUSH2 0x3f51 3F6B 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @3F5D storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @3F62 stack[-3] = 0x20 + stack[-3] // @3F67 stack[-2] = 0x01 + stack[-2] // @3F67 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x3f51 label_3F6C: // Incoming jump from 0x3F59, if !(stack[-1] > stack[-3]) // Incoming jump from 0x3F59, if !(stack[-1] + stack[-3] > stack[-1]) 3F6C 5B JUMPDEST // Stack delta = +0 // Block continues label_3F6D: // Incoming jump from 0x3F6C // Incoming jump from 0x3F3E // Incoming jump from 0x3F4D, if !stack[-3] // Inputs[3] // { // @3F6F stack[-2] // @3F6F stack[-3] // @3F74 stack[-4] // } 3F6D 5B JUMPDEST 3F6E 50 POP 3F6F 90 SWAP1 3F70 50 POP 3F71 61 PUSH2 0x3f7a 3F74 91 SWAP2 3F75 90 SWAP1 3F76 61 PUSH2 0x3f7e 3F79 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @3F74 stack[-4] = 0x3f7a // @3F75 stack[-2] = stack[-2] // @3F75 stack[-3] = stack[-4] // } // Block ends with call to 0x3f7e, returns to 0x3F7A label_3F7A: // Incoming return from call to 0x3F7E at 0x3F79 // Inputs[2] // { // @3F7C stack[-3] // @3F7C stack[-2] // } 3F7A 5B JUMPDEST 3F7B 50 POP 3F7C 90 SWAP1 3F7D 56 *JUMP // Stack delta = -2 // Outputs[1] { @3F7C stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_3F7E: // Incoming call from 0x3F79, returns to 0x3F7A // Inputs[2] // { // @3F82 stack[-2] // @3F83 stack[-1] // } 3F7E 5B JUMPDEST 3F7F 61 PUSH2 0x3fa0 3F82 91 SWAP2 3F83 90 SWAP1 3F84 5B JUMPDEST 3F85 80 DUP1 3F86 82 DUP3 3F87 11 GT 3F88 15 ISZERO 3F89 61 PUSH2 0x3f9c 3F8C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @3F82 stack[-2] = 0x3fa0 // @3F83 stack[-1] = stack[-2] // @3F83 stack[0] = stack[-1] // } // Block ends with conditional call to 0x3f9c, returns to 0x3FA0, if !(stack[-2] > stack[-1]) label_3F8D: // Incoming jump from 0x3F8C, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x3F8C, if not !(stack[-2] > stack[-1]) // Inputs[1] { @3F8F stack[-1] } 3F8D 60 PUSH1 0x00 3F8F 81 DUP2 3F90 60 PUSH1 0x00 3F92 90 SWAP1 3F93 55 SSTORE 3F94 50 POP 3F95 60 PUSH1 0x01 3F97 01 ADD 3F98 61 PUSH2 0x3f84 3F9B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3F93 storage[stack[-1]] = 0x00 // @3F97 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x3f84 label_3F9C: // Incoming call from 0x3F8C, returns to 0x3FA0, if !(stack[-2] > stack[-1]) // Incoming jump from 0x3F8C, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @3F9E stack[-3] // @3F9E stack[-2] // } 3F9C 5B JUMPDEST 3F9D 50 POP 3F9E 90 SWAP1 3F9F 56 *JUMP // Stack delta = -2 // Outputs[1] { @3F9E stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_3FA0: // Incoming return from call to 0x3F9C at 0x3F8C // Inputs[2] // { // @3FA1 stack[-1] // @3FA1 stack[-2] // } 3FA0 5B JUMPDEST 3FA1 90 SWAP1 3FA2 56 *JUMP // Stack delta = -1 // Outputs[1] { @3FA1 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] 3FA3 FE *ASSERT 3FA4 45 GASLIMIT 3FA5 52 MSTORE 3FA6 43 NUMBER 3FA7 31 BALANCE 3FA8 31 BALANCE 3FA9 35 CALLDATALOAD 3FAA 35 CALLDATALOAD 3FAB 23 23 3FAC 73 PUSH20 0x6166655472616e7366657246726f6d3a20494e56 3FC1 41 COINBASE 3FC2 4C 4C 3FC3 49 49 3FC4 44 DIFFICULTY 3FC5 5F PUSH0 3FC6 52 MSTORE 3FC7 45 GASLIMIT 3FC8 43 NUMBER 3FC9 49 49 3FCA 50 POP 3FCB 49 49 3FCC 45 GASLIMIT 3FCD 4E 4E 3FCE 54 SLOAD 3FCF 4F 4F 3FD0 77 PUSH24 0x6e61626c653a206e6577206f776e65722069732074686520 3FE9 7A PUSH27 0x65726f20616464726573734173736574436f6e7472616374536861 4005 72 PUSH19 0x65642373657443726561746f723a20494e5641 4019 4C 4C 401A 49 49 401B 44 DIFFICULTY 401C 5F PUSH0 401D 41 COINBASE 401E 44 DIFFICULTY 401F 44 DIFFICULTY 4020 52 MSTORE 4021 45 GASLIMIT 4022 53 MSTORE8 4023 53 MSTORE8 4024 2E 2E 4025 45 GASLIMIT 4026 52 MSTORE 4027 43 NUMBER 4028 31 BALANCE 4029 31 BALANCE 402A 35 CALLDATALOAD 402B 35 CALLDATALOAD 402C 23 23 402D 73 PUSH20 0x6166655472616e7366657246726f6d3a20494e56 4042 41 COINBASE 4043 4C 4C 4044 49 49 4045 44 DIFFICULTY 4046 5F PUSH0 4047 4F 4F 4048 50 POP 4049 45 GASLIMIT 404A 52 MSTORE 404B 41 COINBASE 404C 54 SLOAD 404D 4F 4F 404E 52 MSTORE 404F 45 GASLIMIT 4050 52 MSTORE 4051 43 NUMBER 4052 31 BALANCE 4053 31 BALANCE 4054 35 CALLDATALOAD 4055 35 CALLDATALOAD 4056 54 SLOAD 4057 72 PUSH19 0x616461626c652362617463684d696e743a204d 406B 55 SSTORE 406C 4C 4C 406D 54 SLOAD 406E 49 49 406F 50 POP 4070 4C 4C 4071 45 GASLIMIT 4072 5F PUSH0 4073 4F 4F 4074 52 MSTORE 4075 49 49 4076 47 SELFBALANCE 4077 49 49 4078 4E 4E 4079 53 MSTORE8 407A 5F PUSH0 407B 4E 4E 407C 4F 4F 407D 54 SLOAD 407E 5F PUSH0 407F 41 COINBASE 4080 4C 4C 4081 4C 4C 4082 4F 4F 4083 57 *JUMPI 4084 45 GASLIMIT 4085 44 DIFFICULTY 4086 41 COINBASE 4087 73 PUSH20 0x736574436f6e7472616374536861726564235f72 409C 65 PUSH6 0x71756972654d 40A3 69 PUSH10 0x6e7461626c653a204f4e 40AE 4C 4C 40AF 59 MSIZE 40B0 5F PUSH0 40B1 43 NUMBER 40B2 52 MSTORE 40B3 45 GASLIMIT 40B4 41 COINBASE 40B5 54 SLOAD 40B6 4F 4F 40B7 52 MSTORE 40B8 5F PUSH0 40B9 41 COINBASE 40BA 4C 4C 40BB 4C 4C 40BC 4F 4F 40BD 57 *JUMPI 40BE 45 GASLIMIT 40BF 44 DIFFICULTY 40C0 41 COINBASE 40C1 73 PUSH20 0x736574436f6e7472616374536861726564235f72 40D6 65 PUSH6 0x71756972654d 40DD 69 PUSH10 0x6e7461626c653a205355 40E8 50 POP 40E9 50 POP 40EA 4C 4C 40EB 59 MSIZE 40EC 5F PUSH0 40ED 45 GASLIMIT 40EE 58 PC 40EF 43 NUMBER 40F0 45 GASLIMIT 40F1 45 GASLIMIT 40F2 44 DIFFICULTY 40F3 45 GASLIMIT 40F4 44 DIFFICULTY 40F5 45 GASLIMIT 40F6 52 MSTORE 40F7 43 NUMBER 40F8 31 BALANCE 40F9 31 BALANCE 40FA 35 CALLDATALOAD 40FB 35 CALLDATALOAD 40FC 54 SLOAD 40FD 72 PUSH19 0x616461626c65236f6e6c794f776e65723a2043 4111 41 COINBASE 4112 4C 4C 4113 4C 4C 4114 45 GASLIMIT 4115 52 MSTORE 4116 5F PUSH0 4117 49 49 4118 53 MSTORE8 4119 5F PUSH0 411A 4E 4E 411B 4F 4F 411C 54 SLOAD 411D 5F PUSH0 411E 4F 4F 411F 57 *JUMPI 4120 4E 4E 4121 45 GASLIMIT 4122 52 MSTORE 4123 45 GASLIMIT 4124 52 MSTORE 4125 43 NUMBER 4126 31 BALANCE 4127 31 BALANCE 4128 35 CALLDATALOAD 4129 35 CALLDATALOAD 412A 23 23 412B 5F PUSH0 412C 73 PUSH20 0x61666542617463685472616e7366657246726f6d 4141 3A GASPRICE 4142 20 SHA3 4143 49 49 4144 4E 4E 4145 56 *JUMP 4146 41 COINBASE 4147 4C 4C 4148 49 49 4149 44 DIFFICULTY 414A 5F PUSH0 414B 41 COINBASE 414C 52 MSTORE 414D 52 MSTORE 414E 41 COINBASE 414F 59 MSIZE 4150 53 MSTORE8 4151 5F PUSH0 4152 4C 4C 4153 45 GASLIMIT 4154 4E 4E 4155 47 SELFBALANCE 4156 54 SLOAD 4157 48 BASEFEE 4158 45 GASLIMIT 4159 52 MSTORE 415A 43 NUMBER 415B 31 BALANCE 415C 31 BALANCE 415D 35 CALLDATALOAD 415E 35 CALLDATALOAD 415F 54 SLOAD 4160 72 PUSH19 0x616461626c652362617463684d696e743a2049 4174 4E 4E 4175 56 *JUMP 4176 41 COINBASE 4177 4C 4C 4178 49 49 4179 44 DIFFICULTY 417A 5F PUSH0 417B 41 COINBASE 417C 52 MSTORE 417D 52 MSTORE 417E 41 COINBASE 417F 59 MSIZE 4180 53 MSTORE8 4181 5F PUSH0 4182 4C 4C 4183 45 GASLIMIT 4184 4E 4E 4185 47 SELFBALANCE 4186 54 SLOAD 4187 48 BASEFEE 4188 45 GASLIMIT 4189 52 MSTORE 418A 43 NUMBER 418B 31 BALANCE 418C 31 BALANCE 418D 35 CALLDATALOAD 418E 35 CALLDATALOAD 418F 23 23 4190 73 PUSH20 0x61666542617463685472616e7366657246726f6d 41A5 3A GASPRICE 41A6 20 SHA3 41A7 49 49 41A8 4E 4E 41A9 56 *JUMP 41AA 41 COINBASE 41AB 4C 4C 41AC 49 49 41AD 44 DIFFICULTY 41AE 5F PUSH0 41AF 52 MSTORE 41B0 45 GASLIMIT 41B1 43 NUMBER 41B2 49 49 41B3 50 POP 41B4 49 49 41B5 45 GASLIMIT 41B6 4E 4E 41B7 54 SLOAD 41B8 45 GASLIMIT 41B9 52 MSTORE 41BA 43 NUMBER 41BB 31 BALANCE 41BC 31 BALANCE 41BD 35 CALLDATALOAD 41BE 35 CALLDATALOAD 41BF 23 23 41C0 62 PUSH3 0x616c61 41C4 6E PUSH15 0x63654f6642617463683a20494e5641 41D4 4C 4C 41D5 49 49 41D6 44 DIFFICULTY 41D7 5F PUSH0 41D8 41 COINBASE 41D9 52 MSTORE 41DA 52 MSTORE 41DB 41 COINBASE 41DC 59 MSIZE 41DD 5F PUSH0 41DE 4C 4C 41DF 45 GASLIMIT 41E0 4E 4E 41E1 47 SELFBALANCE 41E2 54 SLOAD 41E3 48 BASEFEE 41E4 45 GASLIMIT 41E5 52 MSTORE 41E6 43 NUMBER 41E7 31 BALANCE 41E8 31 BALANCE 41E9 35 CALLDATALOAD 41EA 35 CALLDATALOAD 41EB 23 23 41EC 73 PUSH20 0x61666542617463685472616e7366657246726f6d 4201 3A GASPRICE 4202 20 SHA3 4203 49 49 4204 4E 4E 4205 56 *JUMP 4206 41 COINBASE 4207 4C 4C 4208 49 49 4209 44 DIFFICULTY 420A 5F PUSH0 420B 4F 4F 420C 50 POP 420D 45 GASLIMIT 420E 52 MSTORE 420F 41 COINBASE 4210 54 SLOAD 4211 4F 4F 4212 52 MSTORE 4213 45 GASLIMIT 4214 52 MSTORE 4215 43 NUMBER 4216 31 BALANCE 4217 31 BALANCE 4218 35 CALLDATALOAD 4219 35 CALLDATALOAD 421A 23 23 421B 5F PUSH0 421C 63 PUSH4 0x616c6c6f 4221 6E PUSH15 0x455243313135354261746368526563 4231 65 PUSH6 0x697665643a20 4238 49 49 4239 4E 4E 423A 56 *JUMP 423B 41 COINBASE 423C 4C 4C 423D 49 49 423E 44 DIFFICULTY 423F 5F PUSH0 4240 4F 4F 4241 4E 4E 4242 5F PUSH0 4243 52 MSTORE 4244 45 GASLIMIT 4245 43 NUMBER 4246 45 GASLIMIT 4247 49 49 4248 56 *JUMP 4249 45 GASLIMIT 424A 5F PUSH0 424B 4D 4D 424C 45 GASLIMIT 424D 53 MSTORE8 424E 53 MSTORE8 424F 41 COINBASE 4250 47 SELFBALANCE 4251 45 GASLIMIT 4252 45 GASLIMIT 4253 52 MSTORE 4254 43 NUMBER 4255 31 BALANCE 4256 31 BALANCE 4257 35 CALLDATALOAD 4258 35 CALLDATALOAD 4259 23 23 425A 5F PUSH0 425B 63 PUSH4 0x616c6c6f 4260 6E PUSH15 0x455243313135355265636569766564 4270 3A GASPRICE 4271 20 SHA3 4272 49 49 4273 4E 4E 4274 56 *JUMP 4275 41 COINBASE 4276 4C 4C 4277 49 49 4278 44 DIFFICULTY 4279 5F PUSH0 427A 4F 4F 427B 4E 4E 427C 5F PUSH0 427D 52 MSTORE 427E 45 GASLIMIT 427F 43 NUMBER 4280 45 GASLIMIT 4281 49 49 4282 56 *JUMP 4283 45 GASLIMIT 4284 5F PUSH0 4285 4D 4D 4286 45 GASLIMIT 4287 53 MSTORE8 4288 53 MSTORE8 4289 41 COINBASE 428A 47 SELFBALANCE 428B 45 GASLIMIT 428C 41 COINBASE 428D 73 PUSH20 0x736574436f6e7472616374536861726564236372 42A2 65 PUSH6 0x61746f724f6e 42A9 6C PUSH13 0x793a204f4e4c595f4352454154 42B7 4F 4F 42B8 52 MSTORE 42B9 5F PUSH0 42BA 41 COINBASE 42BB 4C 4C 42BC 4C 4C 42BD 4F 4F 42BE 57 *JUMPI 42BF 45 GASLIMIT 42C0 44 DIFFICULTY 42C1 A2 LOG2 42C2 65 PUSH6 0x627a7a723158 42C9 20 SHA3 42CA 28 28 42CB F3 *RETURN 42CC E5 E5 42CD 29 29 42CE F4 DELEGATECALL 42CF DF DF 42D0 F9 F9 42D1 E1 E1 42D2 21 21 42D3 7E PUSH31 0x9c5fa3987610b4f138495f1f8d6516748e8ab795168d64736f6c6343000511 42F3 00 *STOP 42F4 32 ORIGIN