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 0x01c4 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01c4, 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 0x6352211e 0026 11 GT 0027 61 PUSH2 0x00f9 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00f9, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xb88d4fde 0031 11 GT 0032 61 PUSH2 0x0097 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0097, if 0xb88d4fde > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xb88d4fde > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xe0dd8cb8 003C 11 GT 003D 61 PUSH2 0x0071 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xe0dd8cb8 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xe0dd8cb8 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xe0dd8cb8 0047 14 EQ 0048 61 PUSH2 0x03b7 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b7, if 0xe0dd8cb8 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xe0dd8cb8 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xe64710e6 0052 14 EQ 0053 61 PUSH2 0x03ca 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ca, if 0xe64710e6 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xe64710e6 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xe8502697 005D 14 EQ 005E 61 PUSH2 0x03d3 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d3, if 0xe8502697 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xe8502697 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xe985e9c5 0068 14 EQ 0069 61 PUSH2 0x03e6 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e6, if 0xe985e9c5 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0070 memory[0x00:0x00] } 006D 60 PUSH1 0x00 006F 80 DUP1 0070 FD *REVERT // Stack delta = +0 // Outputs[1] { @0070 revert(memory[0x00:0x00]); } // Block terminates label_0071: // Incoming jump from 0x0040, if 0xe0dd8cb8 > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0xb88d4fde 0078 14 EQ 0079 61 PUSH2 0x0388 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0388, if 0xb88d4fde == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xb88d4fde == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xc87b56dd 0083 14 EQ 0084 61 PUSH2 0x039b 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039b, if 0xc87b56dd == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xca34adf0 008E 14 EQ 008F 61 PUSH2 0x03ae 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ae, if 0xca34adf0 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xca34adf0 == stack[-1] // Inputs[1] { @0096 memory[0x00:0x00] } 0093 60 PUSH1 0x00 0095 80 DUP1 0096 FD *REVERT // Stack delta = +0 // Outputs[1] { @0096 revert(memory[0x00:0x00]); } // Block terminates label_0097: // Incoming jump from 0x0035, if 0xb88d4fde > stack[-1] // Inputs[1] { @0098 stack[-1] } 0097 5B JUMPDEST 0098 80 DUP1 0099 63 PUSH4 0x75794a3c 009E 11 GT 009F 61 PUSH2 0x00d3 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d3, if 0x75794a3c > stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x75794a3c > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0x75794a3c 00A9 14 EQ 00AA 61 PUSH2 0x0351 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0351, if 0x75794a3c == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x75794a3c == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x8da5cb5b 00B4 14 EQ 00B5 61 PUSH2 0x035a 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x035a, if 0x8da5cb5b == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x95d89b41 00BF 14 EQ 00C0 61 PUSH2 0x036d 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036d, if 0x95d89b41 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0xa22cb465 00CA 14 EQ 00CB 61 PUSH2 0x0375 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0375, if 0xa22cb465 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00D2 memory[0x00:0x00] } 00CF 60 PUSH1 0x00 00D1 80 DUP1 00D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D2 revert(memory[0x00:0x00]); } // Block terminates label_00D3: // Incoming jump from 0x00A2, if 0x75794a3c > stack[-1] // Inputs[1] { @00D4 stack[-1] } 00D3 5B JUMPDEST 00D4 80 DUP1 00D5 63 PUSH4 0x6352211e 00DA 14 EQ 00DB 61 PUSH2 0x0323 00DE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0323, if 0x6352211e == stack[-1] label_00DF: // Incoming jump from 0x00DE, if not 0x6352211e == stack[-1] // Inputs[1] { @00DF stack[-1] } 00DF 80 DUP1 00E0 63 PUSH4 0x6c0360eb 00E5 14 EQ 00E6 61 PUSH2 0x0336 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0336, if 0x6c0360eb == stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x6c0360eb == stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0x70a08231 00F0 14 EQ 00F1 61 PUSH2 0x033e 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033e, if 0x70a08231 == stack[-1] label_00F5: // Incoming jump from 0x00F4, if not 0x70a08231 == stack[-1] // Inputs[1] { @00F8 memory[0x00:0x00] } 00F5 60 PUSH1 0x00 00F7 80 DUP1 00F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F8 revert(memory[0x00:0x00]); } // Block terminates label_00F9: // Incoming jump from 0x002A, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00FA stack[-1] } 00F9 5B JUMPDEST 00FA 80 DUP1 00FB 63 PUSH4 0x2d6e71b6 0100 11 GT 0101 61 PUSH2 0x0166 0104 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0166, if 0x2d6e71b6 > stack[-1] label_0105: // Incoming jump from 0x0104, if not 0x2d6e71b6 > stack[-1] // Inputs[1] { @0105 stack[-1] } 0105 80 DUP1 0106 63 PUSH4 0x42842e0e 010B 11 GT 010C 61 PUSH2 0x0140 010F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0140, if 0x42842e0e > stack[-1] label_0110: // Incoming jump from 0x010F, if not 0x42842e0e > stack[-1] // Inputs[1] { @0110 stack[-1] } 0110 80 DUP1 0111 63 PUSH4 0x42842e0e 0116 14 EQ 0117 61 PUSH2 0x02d7 011A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d7, if 0x42842e0e == stack[-1] label_011B: // Incoming jump from 0x011A, if not 0x42842e0e == stack[-1] // Inputs[1] { @011B stack[-1] } 011B 80 DUP1 011C 63 PUSH4 0x51c4998e 0121 14 EQ 0122 61 PUSH2 0x02ea 0125 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ea, if 0x51c4998e == stack[-1] label_0126: // Incoming jump from 0x0125, if not 0x51c4998e == stack[-1] // Inputs[1] { @0126 stack[-1] } 0126 80 DUP1 0127 63 PUSH4 0x55f804b3 012C 14 EQ 012D 61 PUSH2 0x02fd 0130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02fd, if 0x55f804b3 == stack[-1] label_0131: // Incoming jump from 0x0130, if not 0x55f804b3 == stack[-1] // Inputs[1] { @0131 stack[-1] } 0131 80 DUP1 0132 63 PUSH4 0x57b8d528 0137 14 EQ 0138 61 PUSH2 0x0310 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0310, if 0x57b8d528 == stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x57b8d528 == stack[-1] // Inputs[1] { @013F memory[0x00:0x00] } 013C 60 PUSH1 0x00 013E 80 DUP1 013F FD *REVERT // Stack delta = +0 // Outputs[1] { @013F revert(memory[0x00:0x00]); } // Block terminates label_0140: // Incoming jump from 0x010F, if 0x42842e0e > stack[-1] // Inputs[1] { @0141 stack[-1] } 0140 5B JUMPDEST 0141 80 DUP1 0142 63 PUSH4 0x2d6e71b6 0147 14 EQ 0148 61 PUSH2 0x0299 014B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0299, if 0x2d6e71b6 == stack[-1] label_014C: // Incoming jump from 0x014B, if not 0x2d6e71b6 == stack[-1] // Inputs[1] { @014C stack[-1] } 014C 80 DUP1 014D 63 PUSH4 0x32cb6b0c 0152 14 EQ 0153 61 PUSH2 0x02ac 0156 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ac, if 0x32cb6b0c == stack[-1] label_0157: // Incoming jump from 0x0156, if not 0x32cb6b0c == stack[-1] // Inputs[1] { @0157 stack[-1] } 0157 80 DUP1 0158 63 PUSH4 0x38e21cce 015D 14 EQ 015E 61 PUSH2 0x02b4 0161 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b4, if 0x38e21cce == stack[-1] label_0162: // Incoming jump from 0x0161, if not 0x38e21cce == stack[-1] // Inputs[1] { @0165 memory[0x00:0x00] } 0162 60 PUSH1 0x00 0164 80 DUP1 0165 FD *REVERT // Stack delta = +0 // Outputs[1] { @0165 revert(memory[0x00:0x00]); } // Block terminates label_0166: // Incoming jump from 0x0104, if 0x2d6e71b6 > stack[-1] // Inputs[1] { @0167 stack[-1] } 0166 5B JUMPDEST 0167 80 DUP1 0168 63 PUSH4 0x095ea7b3 016D 11 GT 016E 61 PUSH2 0x01a2 0171 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a2, if 0x095ea7b3 > stack[-1] label_0172: // Incoming jump from 0x0171, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @0172 stack[-1] } 0172 80 DUP1 0173 63 PUSH4 0x095ea7b3 0178 14 EQ 0179 61 PUSH2 0x0247 017C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0247, if 0x095ea7b3 == stack[-1] label_017D: // Incoming jump from 0x017C, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @017D stack[-1] } 017D 80 DUP1 017E 63 PUSH4 0x13af4035 0183 14 EQ 0184 61 PUSH2 0x025c 0187 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x025c, if 0x13af4035 == stack[-1] label_0188: // Incoming jump from 0x0187, if not 0x13af4035 == stack[-1] // Inputs[1] { @0188 stack[-1] } 0188 80 DUP1 0189 63 PUSH4 0x15a55347 018E 14 EQ 018F 61 PUSH2 0x026f 0192 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026f, if 0x15a55347 == stack[-1] label_0193: // Incoming jump from 0x0192, if not 0x15a55347 == stack[-1] // Inputs[1] { @0193 stack[-1] } 0193 80 DUP1 0194 63 PUSH4 0x23b872dd 0199 14 EQ 019A 61 PUSH2 0x0286 019D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0286, if 0x23b872dd == stack[-1] label_019E: // Incoming jump from 0x019D, if not 0x23b872dd == stack[-1] // Inputs[1] { @01A1 memory[0x00:0x00] } 019E 60 PUSH1 0x00 01A0 80 DUP1 01A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @01A1 revert(memory[0x00:0x00]); } // Block terminates label_01A2: // Incoming jump from 0x0171, if 0x095ea7b3 > stack[-1] // Inputs[1] { @01A3 stack[-1] } 01A2 5B JUMPDEST 01A3 80 DUP1 01A4 63 PUSH4 0x01ffc9a7 01A9 14 EQ 01AA 61 PUSH2 0x01c9 01AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c9, if 0x01ffc9a7 == stack[-1] label_01AE: // Incoming jump from 0x01AD, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01AE stack[-1] } 01AE 80 DUP1 01AF 63 PUSH4 0x06fdde03 01B4 14 EQ 01B5 61 PUSH2 0x01f1 01B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f1, if 0x06fdde03 == stack[-1] label_01B9: // Incoming jump from 0x01B8, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01B9 stack[-1] } 01B9 80 DUP1 01BA 63 PUSH4 0x081812fc 01BF 14 EQ 01C0 61 PUSH2 0x0206 01C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0206, if 0x081812fc == stack[-1] label_01C4: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x01C3, if not 0x081812fc == stack[-1] // Inputs[1] { @01C8 memory[0x00:0x00] } 01C4 5B JUMPDEST 01C5 60 PUSH1 0x00 01C7 80 DUP1 01C8 FD *REVERT // Stack delta = +0 // Outputs[1] { @01C8 revert(memory[0x00:0x00]); } // Block terminates label_01C9: // Incoming jump from 0x01AD, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01D0 msg.data.length } 01C9 5B JUMPDEST 01CA 61 PUSH2 0x01dc 01CD 61 PUSH2 0x01d7 01D0 36 CALLDATASIZE 01D1 60 PUSH1 0x04 01D3 61 PUSH2 0x1180 01D6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01CA stack[0] = 0x01dc // @01CD stack[1] = 0x01d7 // @01D0 stack[2] = msg.data.length // @01D1 stack[3] = 0x04 // } // Block ends with call to 0x1180, returns to 0x01D7 label_01D7: // Incoming return from call to 0x1180 at 0x01D6 01D7 5B JUMPDEST 01D8 61 PUSH2 0x0414 01DB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0414 label_01DC: // Incoming return from call to 0x01D7 at 0x01D6 // Incoming return from call to 0x03F4 at 0x03F3 // Incoming return from call to 0x02C2 at 0x02C1 // Inputs[2] // { // @01DF memory[0x40:0x60] // @01E0 stack[-1] // } 01DC 5B JUMPDEST 01DD 60 PUSH1 0x40 01DF 51 MLOAD 01E0 90 SWAP1 01E1 15 ISZERO 01E2 15 ISZERO 01E3 81 DUP2 01E4 52 MSTORE 01E5 60 PUSH1 0x20 01E7 01 ADD // Stack delta = +0 // Outputs[2] // { // @01E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @01E7 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_01E8: // Incoming return from call to 0x11D4 at 0x0205 // Incoming jump from 0x01E7 // Incoming jump from 0x0285 // Incoming jump from 0x0246 // Inputs[3] // { // @01EB memory[0x40:0x60] // @01ED stack[-1] // @01F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01E8 5B JUMPDEST 01E9 60 PUSH1 0x40 01EB 51 MLOAD 01EC 80 DUP1 01ED 91 SWAP2 01EE 03 SUB 01EF 90 SWAP1 01F0 F3 *RETURN // Stack delta = -1 // Outputs[1] { @01F0 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01F1: // Incoming jump from 0x01B8, if 0x06fdde03 == stack[-1] 01F1 5B JUMPDEST 01F2 61 PUSH2 0x01f9 01F5 61 PUSH2 0x0466 01F8 56 *JUMP // Stack delta = +1 // Outputs[1] { @01F2 stack[0] = 0x01f9 } // Block ends with call to 0x0466, returns to 0x01F9 label_01F9: // Incoming return from call to 0x0ACF at 0x033D // Incoming return from call to 0x0B3F at 0x0374 // Incoming return from call to 0x03A9 at 0x03A8 // Incoming return from call to 0x03A9 at 0x03A8 // Incoming return from call to 0x0466 at 0x01F8 // Inputs[2] // { // @01FC memory[0x40:0x60] // @0200 stack[-1] // } 01F9 5B JUMPDEST 01FA 60 PUSH1 0x40 01FC 51 MLOAD 01FD 61 PUSH2 0x01e8 0200 91 SWAP2 0201 90 SWAP1 0202 61 PUSH2 0x11d4 0205 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0200 stack[-1] = 0x01e8 // @0201 stack[1] = memory[0x40:0x60] // @0201 stack[0] = stack[-1] // } // Block ends with call to 0x11d4, returns to 0x01E8 label_0206: // Incoming jump from 0x01C3, if 0x081812fc == stack[-1] // Inputs[1] { @020D msg.data.length } 0206 5B JUMPDEST 0207 61 PUSH2 0x022f 020A 61 PUSH2 0x0214 020D 36 CALLDATASIZE 020E 60 PUSH1 0x04 0210 61 PUSH2 0x1207 0213 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0207 stack[0] = 0x022f // @020A stack[1] = 0x0214 // @020D stack[2] = msg.data.length // @020E stack[3] = 0x04 // } // Block ends with call to 0x1207, returns to 0x0214 label_0214: // Incoming return from call to 0x1207 at 0x0213 // Inputs[4] // { // @021C stack[-1] // @0222 memory[0x00:0x40] // @0223 storage[keccak256(memory[0x00:0x40])] // @022D stack[-2] // } 0214 5B JUMPDEST 0215 60 PUSH1 0x04 0217 60 PUSH1 0x20 0219 52 MSTORE 021A 60 PUSH1 0x00 021C 90 SWAP1 021D 81 DUP2 021E 52 MSTORE 021F 60 PUSH1 0x40 0221 90 SWAP1 0222 20 SHA3 0223 54 SLOAD 0224 60 PUSH1 0x01 0226 60 PUSH1 0x01 0228 60 PUSH1 0xa0 022A 1B SHL 022B 03 SUB 022C 16 AND 022D 81 DUP2 022E 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0219 memory[0x20:0x40] = 0x04 // @021E memory[0x00:0x20] = stack[-1] // @022C stack[-1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_022F: // Incoming jump from 0x036C // Incoming return from call to 0x0214 at 0x0213 // Incoming return from call to 0x0331 at 0x0330 // Inputs[2] // { // @0232 memory[0x40:0x60] // @023C stack[-1] // } 022F 5B JUMPDEST 0230 60 PUSH1 0x40 0232 51 MLOAD 0233 60 PUSH1 0x01 0235 60 PUSH1 0x01 0237 60 PUSH1 0xa0 0239 1B SHL 023A 03 SUB 023B 90 SWAP1 023C 91 SWAP2 023D 16 AND 023E 81 DUP2 023F 52 MSTORE 0240 60 PUSH1 0x20 0242 01 ADD 0243 61 PUSH2 0x01e8 0246 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @023F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0242 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01e8 label_0247: // Incoming jump from 0x017C, if 0x095ea7b3 == stack[-1] // Inputs[1] { @024E msg.data.length } 0247 5B JUMPDEST 0248 61 PUSH2 0x025a 024B 61 PUSH2 0x0255 024E 36 CALLDATASIZE 024F 60 PUSH1 0x04 0251 61 PUSH2 0x1237 0254 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0248 stack[0] = 0x025a // @024B stack[1] = 0x0255 // @024E stack[2] = msg.data.length // @024F stack[3] = 0x04 // } // Block ends with call to 0x1237, returns to 0x0255 label_0255: // Incoming return from call to 0x1237 at 0x0254 0255 5B JUMPDEST 0256 61 PUSH2 0x04f4 0259 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04f4 label_025A: // Incoming return from call to 0x026A at 0x0269 // Incoming return from call to 0x031E at 0x031D // Incoming return from call to 0x0255 at 0x0254 // Incoming return from call to 0x0383 at 0x0382 // Incoming return from call to 0x02A7 at 0x02A6 // Incoming return from call to 0x02E5 at 0x02E4 // Incoming return from call to 0x02F8 at 0x02F7 // Incoming return from call to 0x0396 at 0x0395 // Incoming return from call to 0x03E1 at 0x03E0 // Incoming return from call to 0x03C5 at 0x03C4 // Incoming return from call to 0x0294 at 0x0293 025A 5B JUMPDEST 025B 00 *STOP // Stack delta = +0 // Outputs[1] { @025B stop(); } // Block terminates label_025C: // Incoming jump from 0x0187, if 0x13af4035 == stack[-1] // Inputs[1] { @0263 msg.data.length } 025C 5B JUMPDEST 025D 61 PUSH2 0x025a 0260 61 PUSH2 0x026a 0263 36 CALLDATASIZE 0264 60 PUSH1 0x04 0266 61 PUSH2 0x1261 0269 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @025D stack[0] = 0x025a // @0260 stack[1] = 0x026a // @0263 stack[2] = msg.data.length // @0264 stack[3] = 0x04 // } // Block ends with call to 0x1261, returns to 0x026A label_026A: // Incoming return from call to 0x1261 at 0x0269 026A 5B JUMPDEST 026B 61 PUSH2 0x05db 026E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05db label_026F: // Incoming jump from 0x0192, if 0x15a55347 == stack[-1] // Inputs[1] { @0275 storage[0x09] } 026F 5B JUMPDEST 0270 61 PUSH2 0x0278 0273 60 PUSH1 0x09 0275 54 SLOAD 0276 81 DUP2 0277 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0270 stack[0] = 0x0278 // @0275 stack[1] = storage[0x09] // } // Block ends with unconditional jump to 0x0278 label_0278: // Incoming return from call to 0x034C at 0x034B // Incoming jump from 0x0359 // Incoming jump from 0x0277 // Incoming jump from 0x02B3 // Incoming jump from 0x03B6 // Incoming jump from 0x03D2 // Inputs[2] // { // @027B memory[0x40:0x60] // @027C stack[-1] // } 0278 5B JUMPDEST 0279 60 PUSH1 0x40 027B 51 MLOAD 027C 90 SWAP1 027D 81 DUP2 027E 52 MSTORE 027F 60 PUSH1 0x20 0281 01 ADD 0282 61 PUSH2 0x01e8 0285 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @027E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0281 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01e8 label_0286: // Incoming jump from 0x019D, if 0x23b872dd == stack[-1] // Inputs[1] { @028D msg.data.length } 0286 5B JUMPDEST 0287 61 PUSH2 0x025a 028A 61 PUSH2 0x0294 028D 36 CALLDATASIZE 028E 60 PUSH1 0x04 0290 61 PUSH2 0x127c 0293 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0287 stack[0] = 0x025a // @028A stack[1] = 0x0294 // @028D stack[2] = msg.data.length // @028E stack[3] = 0x04 // } // Block ends with call to 0x127c, returns to 0x0294 label_0294: // Incoming return from call to 0x127C at 0x0293 0294 5B JUMPDEST 0295 61 PUSH2 0x0651 0298 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0651 label_0299: // Incoming jump from 0x014B, if 0x2d6e71b6 == stack[-1] // Inputs[1] { @02A0 msg.data.length } 0299 5B JUMPDEST 029A 61 PUSH2 0x025a 029D 61 PUSH2 0x02a7 02A0 36 CALLDATASIZE 02A1 60 PUSH1 0x04 02A3 61 PUSH2 0x1207 02A6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @029A stack[0] = 0x025a // @029D stack[1] = 0x02a7 // @02A0 stack[2] = msg.data.length // @02A1 stack[3] = 0x04 // } // Block ends with call to 0x1207, returns to 0x02A7 label_02A7: // Incoming return from call to 0x1207 at 0x02A6 02A7 5B JUMPDEST 02A8 61 PUSH2 0x0818 02AB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0818 label_02AC: // Incoming jump from 0x0156, if 0x32cb6b0c == stack[-1] 02AC 5B JUMPDEST 02AD 61 PUSH2 0x0278 02B0 60 PUSH1 0x45 02B2 81 DUP2 02B3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02AD stack[0] = 0x0278 // @02B0 stack[1] = 0x45 // } // Block ends with unconditional jump to 0x0278 label_02B4: // Incoming jump from 0x0161, if 0x38e21cce == stack[-1] // Inputs[1] { @02BB msg.data.length } 02B4 5B JUMPDEST 02B5 61 PUSH2 0x01dc 02B8 61 PUSH2 0x02c2 02BB 36 CALLDATASIZE 02BC 60 PUSH1 0x04 02BE 61 PUSH2 0x1261 02C1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02B5 stack[0] = 0x01dc // @02B8 stack[1] = 0x02c2 // @02BB stack[2] = msg.data.length // @02BC stack[3] = 0x04 // } // Block ends with call to 0x1261, returns to 0x02C2 label_02C2: // Incoming return from call to 0x1261 at 0x02C1 // Inputs[4] // { // @02CA stack[-1] // @02D0 memory[0x00:0x40] // @02D1 storage[keccak256(memory[0x00:0x40])] // @02D5 stack[-2] // } 02C2 5B JUMPDEST 02C3 60 PUSH1 0x0a 02C5 60 PUSH1 0x20 02C7 52 MSTORE 02C8 60 PUSH1 0x00 02CA 90 SWAP1 02CB 81 DUP2 02CC 52 MSTORE 02CD 60 PUSH1 0x40 02CF 90 SWAP1 02D0 20 SHA3 02D1 54 SLOAD 02D2 60 PUSH1 0xff 02D4 16 AND 02D5 81 DUP2 02D6 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @02C7 memory[0x20:0x40] = 0x0a // @02CC memory[0x00:0x20] = stack[-1] // @02D4 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_02D7: // Incoming jump from 0x011A, if 0x42842e0e == stack[-1] // Inputs[1] { @02DE msg.data.length } 02D7 5B JUMPDEST 02D8 61 PUSH2 0x025a 02DB 61 PUSH2 0x02e5 02DE 36 CALLDATASIZE 02DF 60 PUSH1 0x04 02E1 61 PUSH2 0x127c 02E4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02D8 stack[0] = 0x025a // @02DB stack[1] = 0x02e5 // @02DE stack[2] = msg.data.length // @02DF stack[3] = 0x04 // } // Block ends with call to 0x127c, returns to 0x02E5 label_02E5: // Incoming return from call to 0x127C at 0x02E4 02E5 5B JUMPDEST 02E6 61 PUSH2 0x0847 02E9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0847 label_02EA: // Incoming jump from 0x0125, if 0x51c4998e == stack[-1] // Inputs[1] { @02F1 msg.data.length } 02EA 5B JUMPDEST 02EB 61 PUSH2 0x025a 02EE 61 PUSH2 0x02f8 02F1 36 CALLDATASIZE 02F2 60 PUSH1 0x04 02F4 61 PUSH2 0x1207 02F7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02EB stack[0] = 0x025a // @02EE stack[1] = 0x02f8 // @02F1 stack[2] = msg.data.length // @02F2 stack[3] = 0x04 // } // Block ends with call to 0x1207, returns to 0x02F8 label_02F8: // Incoming return from call to 0x1207 at 0x02F7 02F8 5B JUMPDEST 02F9 61 PUSH2 0x093f 02FC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x093f label_02FD: // Incoming jump from 0x0130, if 0x55f804b3 == stack[-1] // Inputs[1] { @0304 msg.data.length } 02FD 5B JUMPDEST 02FE 61 PUSH2 0x025a 0301 61 PUSH2 0x030b 0304 36 CALLDATASIZE 0305 60 PUSH1 0x04 0307 61 PUSH2 0x12ce 030A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02FE stack[0] = 0x025a // @0301 stack[1] = 0x030b // @0304 stack[2] = msg.data.length // @0305 stack[3] = 0x04 // } // Block ends with call to 0x12ce, returns to 0x030B label_030B: // Incoming return from call to 0x12CE at 0x030A 030B 5B JUMPDEST 030C 61 PUSH2 0x096e 030F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x096e label_0310: // Incoming jump from 0x013B, if 0x57b8d528 == stack[-1] // Inputs[1] { @0317 msg.data.length } 0310 5B JUMPDEST 0311 61 PUSH2 0x025a 0314 61 PUSH2 0x031e 0317 36 CALLDATASIZE 0318 60 PUSH1 0x04 031A 61 PUSH2 0x137f 031D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0311 stack[0] = 0x025a // @0314 stack[1] = 0x031e // @0317 stack[2] = msg.data.length // @0318 stack[3] = 0x04 // } // Block ends with call to 0x137f, returns to 0x031E label_031E: // Incoming return from call to 0x137F at 0x031D 031E 5B JUMPDEST 031F 61 PUSH2 0x09af 0322 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09af label_0323: // Incoming jump from 0x00DE, if 0x6352211e == stack[-1] // Inputs[1] { @032A msg.data.length } 0323 5B JUMPDEST 0324 61 PUSH2 0x022f 0327 61 PUSH2 0x0331 032A 36 CALLDATASIZE 032B 60 PUSH1 0x04 032D 61 PUSH2 0x1207 0330 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0324 stack[0] = 0x022f // @0327 stack[1] = 0x0331 // @032A stack[2] = msg.data.length // @032B stack[3] = 0x04 // } // Block ends with call to 0x1207, returns to 0x0331 label_0331: // Incoming return from call to 0x1207 at 0x0330 0331 5B JUMPDEST 0332 61 PUSH2 0x0a78 0335 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a78 label_0336: // Incoming jump from 0x00E9, if 0x6c0360eb == stack[-1] 0336 5B JUMPDEST 0337 61 PUSH2 0x01f9 033A 61 PUSH2 0x0acf 033D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0337 stack[0] = 0x01f9 } // Block ends with call to 0x0acf, returns to 0x01F9 label_033E: // Incoming jump from 0x00F4, if 0x70a08231 == stack[-1] // Inputs[1] { @0345 msg.data.length } 033E 5B JUMPDEST 033F 61 PUSH2 0x0278 0342 61 PUSH2 0x034c 0345 36 CALLDATASIZE 0346 60 PUSH1 0x04 0348 61 PUSH2 0x1261 034B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @033F stack[0] = 0x0278 // @0342 stack[1] = 0x034c // @0345 stack[2] = msg.data.length // @0346 stack[3] = 0x04 // } // Block ends with call to 0x1261, returns to 0x034C label_034C: // Incoming return from call to 0x1261 at 0x034B 034C 5B JUMPDEST 034D 61 PUSH2 0x0adc 0350 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0adc label_0351: // Incoming jump from 0x00AD, if 0x75794a3c == stack[-1] // Inputs[1] { @0357 storage[0x08] } 0351 5B JUMPDEST 0352 61 PUSH2 0x0278 0355 60 PUSH1 0x08 0357 54 SLOAD 0358 81 DUP2 0359 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0352 stack[0] = 0x0278 // @0357 stack[1] = storage[0x08] // } // Block ends with unconditional jump to 0x0278 label_035A: // Incoming jump from 0x00B8, if 0x8da5cb5b == stack[-1] // Inputs[1] { @035D storage[0x06] } 035A 5B JUMPDEST 035B 60 PUSH1 0x06 035D 54 SLOAD 035E 61 PUSH2 0x022f 0361 90 SWAP1 0362 60 PUSH1 0x01 0364 60 PUSH1 0x01 0366 60 PUSH1 0xa0 0368 1B SHL 0369 03 SUB 036A 16 AND 036B 81 DUP2 036C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0361 stack[0] = 0x022f // @036A stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x06] // } // Block ends with unconditional jump to 0x022f label_036D: // Incoming jump from 0x00C3, if 0x95d89b41 == stack[-1] 036D 5B JUMPDEST 036E 61 PUSH2 0x01f9 0371 61 PUSH2 0x0b3f 0374 56 *JUMP // Stack delta = +1 // Outputs[1] { @036E stack[0] = 0x01f9 } // Block ends with call to 0x0b3f, returns to 0x01F9 label_0375: // Incoming jump from 0x00CE, if 0xa22cb465 == stack[-1] // Inputs[1] { @037C msg.data.length } 0375 5B JUMPDEST 0376 61 PUSH2 0x025a 0379 61 PUSH2 0x0383 037C 36 CALLDATASIZE 037D 60 PUSH1 0x04 037F 61 PUSH2 0x13f4 0382 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0376 stack[0] = 0x025a // @0379 stack[1] = 0x0383 // @037C stack[2] = msg.data.length // @037D stack[3] = 0x04 // } // Block ends with call to 0x13f4, returns to 0x0383 label_0383: // Incoming return from call to 0x13F4 at 0x0382 0383 5B JUMPDEST 0384 61 PUSH2 0x0b4c 0387 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b4c label_0388: // Incoming jump from 0x007C, if 0xb88d4fde == stack[-1] // Inputs[1] { @038F msg.data.length } 0388 5B JUMPDEST 0389 61 PUSH2 0x025a 038C 61 PUSH2 0x0396 038F 36 CALLDATASIZE 0390 60 PUSH1 0x04 0392 61 PUSH2 0x1430 0395 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0389 stack[0] = 0x025a // @038C stack[1] = 0x0396 // @038F stack[2] = msg.data.length // @0390 stack[3] = 0x04 // } // Block ends with call to 0x1430, returns to 0x0396 label_0396: // Incoming return from call to 0x1430 at 0x0395 0396 5B JUMPDEST 0397 61 PUSH2 0x0bb8 039A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bb8 label_039B: // Incoming jump from 0x0087, if 0xc87b56dd == stack[-1] // Inputs[1] { @03A2 msg.data.length } 039B 5B JUMPDEST 039C 61 PUSH2 0x01f9 039F 61 PUSH2 0x03a9 03A2 36 CALLDATASIZE 03A3 60 PUSH1 0x04 03A5 61 PUSH2 0x1207 03A8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @039C stack[0] = 0x01f9 // @039F stack[1] = 0x03a9 // @03A2 stack[2] = msg.data.length // @03A3 stack[3] = 0x04 // } // Block ends with call to 0x1207, returns to 0x03A9 label_03A9: // Incoming return from call to 0x1207 at 0x03A8 03A9 5B JUMPDEST 03AA 61 PUSH2 0x0ca0 03AD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ca0 label_03AE: // Incoming jump from 0x0092, if 0xca34adf0 == stack[-1] // Inputs[1] { @03B4 storage[0x0c] } 03AE 5B JUMPDEST 03AF 61 PUSH2 0x0278 03B2 60 PUSH1 0x0c 03B4 54 SLOAD 03B5 81 DUP2 03B6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @03AF stack[0] = 0x0278 // @03B4 stack[1] = storage[0x0c] // } // Block ends with unconditional jump to 0x0278 label_03B7: // Incoming jump from 0x004B, if 0xe0dd8cb8 == stack[-1] // Inputs[1] { @03BE msg.data.length } 03B7 5B JUMPDEST 03B8 61 PUSH2 0x025a 03BB 61 PUSH2 0x03c5 03BE 36 CALLDATASIZE 03BF 60 PUSH1 0x04 03C1 61 PUSH2 0x1207 03C4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03B8 stack[0] = 0x025a // @03BB stack[1] = 0x03c5 // @03BE stack[2] = msg.data.length // @03BF stack[3] = 0x04 // } // Block ends with call to 0x1207, returns to 0x03C5 label_03C5: // Incoming return from call to 0x1207 at 0x03C4 03C5 5B JUMPDEST 03C6 61 PUSH2 0x0d08 03C9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d08 label_03CA: // Incoming jump from 0x0056, if 0xe64710e6 == stack[-1] // Inputs[1] { @03D0 storage[0x0b] } 03CA 5B JUMPDEST 03CB 61 PUSH2 0x0278 03CE 60 PUSH1 0x0b 03D0 54 SLOAD 03D1 81 DUP2 03D2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @03CB stack[0] = 0x0278 // @03D0 stack[1] = storage[0x0b] // } // Block ends with unconditional jump to 0x0278 label_03D3: // Incoming jump from 0x0061, if 0xe8502697 == stack[-1] // Inputs[1] { @03DA msg.data.length } 03D3 5B JUMPDEST 03D4 61 PUSH2 0x025a 03D7 61 PUSH2 0x03e1 03DA 36 CALLDATASIZE 03DB 60 PUSH1 0x04 03DD 61 PUSH2 0x137f 03E0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03D4 stack[0] = 0x025a // @03D7 stack[1] = 0x03e1 // @03DA stack[2] = msg.data.length // @03DB stack[3] = 0x04 // } // Block ends with call to 0x137f, returns to 0x03E1 label_03E1: // Incoming return from call to 0x137F at 0x03E0 03E1 5B JUMPDEST 03E2 61 PUSH2 0x0d37 03E5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d37 label_03E6: // Incoming jump from 0x006C, if 0xe985e9c5 == stack[-1] // Inputs[1] { @03ED msg.data.length } 03E6 5B JUMPDEST 03E7 61 PUSH2 0x01dc 03EA 61 PUSH2 0x03f4 03ED 36 CALLDATASIZE 03EE 60 PUSH1 0x04 03F0 61 PUSH2 0x14cb 03F3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03E7 stack[0] = 0x01dc // @03EA stack[1] = 0x03f4 // @03ED stack[2] = msg.data.length // @03EE stack[3] = 0x04 // } // Block ends with call to 0x14cb, returns to 0x03F4 label_03F4: // Incoming return from call to 0x14CB at 0x03F3 // Inputs[6] // { // @03FE stack[-2] // @0405 memory[0x00:0x40] // @0409 stack[-1] // @040D memory[0x00:0x40] // @040E storage[keccak256(memory[0x00:0x40])] // @0412 stack[-3] // } 03F4 5B JUMPDEST 03F5 60 PUSH1 0x05 03F7 60 PUSH1 0x20 03F9 90 SWAP1 03FA 81 DUP2 03FB 52 MSTORE 03FC 60 PUSH1 0x00 03FE 92 SWAP3 03FF 83 DUP4 0400 52 MSTORE 0401 60 PUSH1 0x40 0403 80 DUP1 0404 84 DUP5 0405 20 SHA3 0406 90 SWAP1 0407 91 SWAP2 0408 52 MSTORE 0409 90 SWAP1 040A 82 DUP3 040B 52 MSTORE 040C 90 SWAP1 040D 20 SHA3 040E 54 SLOAD 040F 60 PUSH1 0xff 0411 16 AND 0412 81 DUP2 0413 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @03FB memory[0x20:0x40] = 0x05 // @0400 memory[0x00:0x20] = stack[-2] // @0408 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @040B memory[0x00:0x20] = stack[-1] // @0411 stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0414: // Incoming jump from 0x01DB // Inputs[1] { @0428 stack[-1] } 0414 5B JUMPDEST 0415 60 PUSH1 0x00 0417 63 PUSH4 0x01ffc9a7 041C 60 PUSH1 0xe0 041E 1B SHL 041F 60 PUSH1 0x01 0421 60 PUSH1 0x01 0423 60 PUSH1 0xe0 0425 1B SHL 0426 03 SUB 0427 19 NOT 0428 83 DUP4 0429 16 AND 042A 14 EQ 042B 80 DUP1 042C 61 PUSH2 0x0445 042F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0415 stack[0] = 0x00 // @042A stack[1] = stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // } // Block ends with conditional jump to 0x0445, if stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 label_0430: // Incoming jump from 0x042F, if not stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // Inputs[1] { @0442 stack[-3] } 0430 50 POP 0431 63 PUSH4 0x80ac58cd 0436 60 PUSH1 0xe0 0438 1B SHL 0439 60 PUSH1 0x01 043B 60 PUSH1 0x01 043D 60 PUSH1 0xe0 043F 1B SHL 0440 03 SUB 0441 19 NOT 0442 83 DUP4 0443 16 AND 0444 14 EQ 0445 5B JUMPDEST 0446 80 DUP1 0447 61 PUSH2 0x0460 044A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0444 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 } // Block ends with conditional jump to 0x0460, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 label_044B: // Incoming jump from 0x044A, if not stack[-1] // Incoming jump from 0x044A, if not stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Inputs[2] // { // @045D stack[-3] // @0461 stack[-4] // } 044B 50 POP 044C 63 PUSH4 0x5b5e139f 0451 60 PUSH1 0xe0 0453 1B SHL 0454 60 PUSH1 0x01 0456 60 PUSH1 0x01 0458 60 PUSH1 0xe0 045A 1B SHL 045B 03 SUB 045C 19 NOT 045D 83 DUP4 045E 16 AND 045F 14 EQ 0460 5B JUMPDEST 0461 92 SWAP3 0462 91 SWAP2 0463 50 POP 0464 50 POP 0465 56 *JUMP // Stack delta = -3 // Outputs[1] { @0461 stack[-4] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x5b5e139f << 0xe0 } // Block ends with unconditional jump to stack[-4] label_0466: // Incoming call from 0x01F8, returns to 0x01F9 // Inputs[1] { @046A storage[0x00] } 0466 5B JUMPDEST 0467 60 PUSH1 0x00 0469 80 DUP1 046A 54 SLOAD 046B 61 PUSH2 0x0473 046E 90 SWAP1 046F 61 PUSH2 0x14fe 0472 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0467 stack[0] = 0x00 // @046E stack[1] = 0x0473 // @046E stack[2] = storage[0x00] // } // Block ends with call to 0x14fe, returns to 0x0473 label_0473: // Incoming return from call to 0x14FE at 0x0472 // Incoming return from call to 0x14FE at 0x0ADB // Incoming return from call to 0x14FE at 0x0B4B // Inputs[4] // { // @0474 stack[-1] // @0483 memory[0x40:0x60] // @048B stack[-2] // @0496 storage[stack[-2]] // } 0473 5B JUMPDEST 0474 80 DUP1 0475 60 PUSH1 0x1f 0477 01 ADD 0478 60 PUSH1 0x20 047A 80 DUP1 047B 91 SWAP2 047C 04 DIV 047D 02 MUL 047E 60 PUSH1 0x20 0480 01 ADD 0481 60 PUSH1 0x40 0483 51 MLOAD 0484 90 SWAP1 0485 81 DUP2 0486 01 ADD 0487 60 PUSH1 0x40 0489 52 MSTORE 048A 80 DUP1 048B 92 SWAP3 048C 91 SWAP2 048D 90 SWAP1 048E 81 DUP2 048F 81 DUP2 0490 52 MSTORE 0491 60 PUSH1 0x20 0493 01 ADD 0494 82 DUP3 0495 80 DUP1 0496 54 SLOAD 0497 61 PUSH2 0x049f 049A 90 SWAP1 049B 61 PUSH2 0x14fe 049E 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0489 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @048B stack[-2] = memory[0x40:0x60] // @048C stack[-1] = stack[-2] // @048D stack[0] = stack[-1] // @0490 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0493 stack[1] = 0x20 + memory[0x40:0x60] // @0494 stack[2] = stack[-2] // @049A stack[4] = storage[stack[-2]] // @049A stack[3] = 0x049f // } // Block ends with call to 0x14fe, returns to 0x049F label_049F: // Incoming return from call to 0x14FE at 0x049E // Inputs[1] { @04A0 stack[-1] } 049F 5B JUMPDEST 04A0 80 DUP1 04A1 15 ISZERO 04A2 61 PUSH2 0x04ec 04A5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ec, if !stack[-1] label_04A6: // Incoming jump from 0x04A5, if not !stack[-1] // Inputs[1] { @04A6 stack[-1] } 04A6 80 DUP1 04A7 60 PUSH1 0x1f 04A9 10 LT 04AA 61 PUSH2 0x04c1 04AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c1, if 0x1f < stack[-1] label_04AE: // Incoming jump from 0x04AD, if not 0x1f < stack[-1] // Inputs[4] // { // @04B2 stack[-2] // @04B3 storage[stack[-2]] // @04B6 stack[-3] // @04B8 stack[-1] // } 04AE 61 PUSH2 0x0100 04B1 80 DUP1 04B2 83 DUP4 04B3 54 SLOAD 04B4 04 DIV 04B5 02 MUL 04B6 83 DUP4 04B7 52 MSTORE 04B8 91 SWAP2 04B9 60 PUSH1 0x20 04BB 01 ADD 04BC 91 SWAP2 04BD 61 PUSH2 0x04ec 04C0 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @04B7 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @04BC stack[-1] = stack[-1] // @04BC stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x04ec label_04C1: // Incoming jump from 0x04AD, if 0x1f < stack[-1] // Inputs[5] // { // @04C2 stack[-3] // @04C3 stack[-1] // @04C5 stack[-2] // @04CD memory[0x00:0x20] // @04D1 storage[keccak256(memory[0x00:0x20])] // } 04C1 5B JUMPDEST 04C2 82 DUP3 04C3 01 ADD 04C4 91 SWAP2 04C5 90 SWAP1 04C6 60 PUSH1 0x00 04C8 52 MSTORE 04C9 60 PUSH1 0x20 04CB 60 PUSH1 0x00 04CD 20 SHA3 04CE 90 SWAP1 04CF 5B JUMPDEST 04D0 81 DUP2 04D1 54 SLOAD 04D2 81 DUP2 04D3 52 MSTORE 04D4 90 SWAP1 04D5 60 PUSH1 0x01 04D7 01 ADD 04D8 90 SWAP1 04D9 60 PUSH1 0x20 04DB 01 ADD 04DC 80 DUP1 04DD 83 DUP4 04DE 11 GT 04DF 61 PUSH2 0x04cf 04E2 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @04C4 stack[-3] = stack[-3] + stack[-1] // @04C8 memory[0x00:0x20] = stack[-2] // @04D3 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @04D8 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @04DB stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x04cf, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_04E3: // Incoming jump from 0x04E2, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x04E2, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @04E3 stack[-3] // @04E4 stack[-1] // } 04E3 82 DUP3 04E4 90 SWAP1 04E5 03 SUB 04E6 60 PUSH1 0x1f 04E8 16 AND 04E9 82 DUP3 04EA 01 ADD 04EB 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @04EB stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @04EB stack[-1] = stack[-3] // } // Block continues label_04EC: // Incoming jump from 0x04EB // Incoming jump from 0x04A5, if !stack[-1] // Incoming jump from 0x04C0 // Inputs[1] { @04F2 stack[-7] } 04EC 5B JUMPDEST 04ED 50 POP 04EE 50 POP 04EF 50 POP 04F0 50 POP 04F1 50 POP 04F2 81 DUP2 04F3 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_04F4: // Incoming jump from 0x0259 // Inputs[4] // { // @04F7 stack[-1] // @0502 memory[0x00:0x40] // @0503 storage[keccak256(memory[0x00:0x40])] // @050D msg.sender // } 04F4 5B JUMPDEST 04F5 60 PUSH1 0x00 04F7 81 DUP2 04F8 81 DUP2 04F9 52 MSTORE 04FA 60 PUSH1 0x02 04FC 60 PUSH1 0x20 04FE 52 MSTORE 04FF 60 PUSH1 0x40 0501 90 SWAP1 0502 20 SHA3 0503 54 SLOAD 0504 60 PUSH1 0x01 0506 60 PUSH1 0x01 0508 60 PUSH1 0xa0 050A 1B SHL 050B 03 SUB 050C 16 AND 050D 33 CALLER 050E 81 DUP2 050F 14 EQ 0510 80 DUP1 0511 61 PUSH2 0x053d 0514 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @04F9 memory[0x00:0x20] = stack[-1] // @04FE memory[0x20:0x40] = 0x02 // @050C stack[0] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // @050F stack[1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] == msg.sender // } // Block ends with conditional jump to 0x053d, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] == msg.sender label_0515: // Incoming jump from 0x0514, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] == msg.sender // Inputs[5] // { // @051E stack[-2] // @0530 memory[0x00:0x40] // @0531 msg.sender // @0538 memory[0x00:0x40] // @0539 storage[keccak256(memory[0x00:0x40])] // } 0515 50 POP 0516 60 PUSH1 0x01 0518 60 PUSH1 0x01 051A 60 PUSH1 0xa0 051C 1B SHL 051D 03 SUB 051E 81 DUP2 051F 16 AND 0520 60 PUSH1 0x00 0522 90 SWAP1 0523 81 DUP2 0524 52 MSTORE 0525 60 PUSH1 0x05 0527 60 PUSH1 0x20 0529 90 SWAP1 052A 81 DUP2 052B 52 MSTORE 052C 60 PUSH1 0x40 052E 80 DUP1 052F 83 DUP4 0530 20 SHA3 0531 33 CALLER 0532 84 DUP5 0533 52 MSTORE 0534 90 SWAP1 0535 91 SWAP2 0536 52 MSTORE 0537 90 SWAP1 0538 20 SHA3 0539 54 SLOAD 053A 60 PUSH1 0xff 053C 16 AND 053D 5B JUMPDEST 053E 61 PUSH2 0x057f 0541 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @0524 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @052B memory[0x20:0x40] = 0x05 // @0533 memory[0x00:0x20] = msg.sender // @0536 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x057f, if 0xff & storage[keccak256(memory[0x00:0x40])] label_0542: // Incoming jump from 0x0541, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x0541, if not stack[-1] // Inputs[1] { @0544 memory[0x40:0x60] } 0542 60 PUSH1 0x40 0544 51 MLOAD 0545 62 PUSH3 0x461bcd 0549 60 PUSH1 0xe5 054B 1B SHL 054C 81 DUP2 054D 52 MSTORE 054E 60 PUSH1 0x20 0550 60 PUSH1 0x04 0552 82 DUP3 0553 01 ADD 0554 52 MSTORE 0555 60 PUSH1 0x0e 0557 60 PUSH1 0x24 0559 82 DUP3 055A 01 ADD 055B 52 MSTORE 055C 6D PUSH14 0x1393d517d055551213d492569151 056B 60 PUSH1 0x92 056D 1B SHL 056E 60 PUSH1 0x44 0570 82 DUP3 0571 01 ADD 0572 52 MSTORE 0573 60 PUSH1 0x64 0575 01 ADD // Stack delta = +1 // Outputs[5] // { // @054D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0554 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @055B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @0572 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1393d517d055551213d492569151 << 0x92 // @0575 stack[0] = 0x64 + memory[0x40:0x60] // } // Block continues label_0576: // Incoming return from call to 0x1539 at 0x0D31 // Incoming jump from 0x0E97 // Incoming return from call to 0x1539 at 0x0604 // Incoming jump from 0x0C98 // Incoming jump from 0x06F0 // Incoming jump from 0x0EED // Incoming jump from 0x06A6 // Incoming jump from 0x0939 // Incoming return from call to 0x1539 at 0x0841 // Incoming jump from 0x0575 // Incoming return from call to 0x1539 at 0x0997 // Incoming jump from 0x0788 // Incoming return from call to 0x1539 at 0x0968 // Incoming jump from 0x0AC9 // Incoming jump from 0x0B22 // Inputs[3] // { // @0579 memory[0x40:0x60] // @057B stack[-1] // @057E memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0576 5B JUMPDEST 0577 60 PUSH1 0x40 0579 51 MLOAD 057A 80 DUP1 057B 91 SWAP2 057C 03 SUB 057D 90 SWAP1 057E FD *REVERT // Stack delta = -1 // Outputs[1] { @057E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_057F: // Incoming jump from 0x0541, if 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x0541, if stack[-1] // Inputs[8] // { // @0582 stack[-2] // @058E memory[0x00:0x40] // @0590 storage[keccak256(memory[0x00:0x40])] // @05A3 stack[-3] // @05AD memory[0x40:0x60] // @05B1 stack[-1] // @05D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @05DA stack[-4] // } 057F 5B JUMPDEST 0580 60 PUSH1 0x00 0582 82 DUP3 0583 81 DUP2 0584 52 MSTORE 0585 60 PUSH1 0x04 0587 60 PUSH1 0x20 0589 52 MSTORE 058A 60 PUSH1 0x40 058C 80 DUP1 058D 82 DUP3 058E 20 SHA3 058F 80 DUP1 0590 54 SLOAD 0591 60 PUSH1 0x01 0593 60 PUSH1 0x01 0595 60 PUSH1 0xa0 0597 1B SHL 0598 03 SUB 0599 19 NOT 059A 16 AND 059B 60 PUSH1 0x01 059D 60 PUSH1 0x01 059F 60 PUSH1 0xa0 05A1 1B SHL 05A2 03 SUB 05A3 87 DUP8 05A4 81 DUP2 05A5 16 AND 05A6 91 SWAP2 05A7 82 DUP3 05A8 17 OR 05A9 90 SWAP1 05AA 92 SWAP3 05AB 55 SSTORE 05AC 91 SWAP2 05AD 51 MLOAD 05AE 85 DUP6 05AF 93 SWAP4 05B0 91 SWAP2 05B1 85 DUP6 05B2 16 AND 05B3 91 SWAP2 05B4 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 05D5 91 SWAP2 05D6 A4 LOG4 05D7 50 POP 05D8 50 POP 05D9 50 POP 05DA 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @0584 memory[0x00:0x20] = stack[-2] // @0589 memory[0x20:0x40] = 0x04 // @05AB storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @05D6 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_05DB: // Incoming jump from 0x026E // Inputs[2] // { // @05DE storage[0x06] // @05E8 msg.sender // } 05DB 5B JUMPDEST 05DC 60 PUSH1 0x06 05DE 54 SLOAD 05DF 60 PUSH1 0x01 05E1 60 PUSH1 0x01 05E3 60 PUSH1 0xa0 05E5 1B SHL 05E6 03 SUB 05E7 16 AND 05E8 33 CALLER 05E9 14 EQ 05EA 61 PUSH2 0x0605 05ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0605, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_05EE: // Incoming jump from 0x05ED, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @05F0 memory[0x40:0x60] } 05EE 60 PUSH1 0x40 05F0 51 MLOAD 05F1 62 PUSH3 0x461bcd 05F5 60 PUSH1 0xe5 05F7 1B SHL 05F8 81 DUP2 05F9 52 MSTORE 05FA 60 PUSH1 0x04 05FC 01 ADD 05FD 61 PUSH2 0x0576 0600 90 SWAP1 0601 61 PUSH2 0x1539 0604 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05F9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0600 stack[0] = 0x0576 // @0600 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1539, returns to 0x0576 label_0605: // Incoming jump from 0x05ED, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[6] // { // @0609 storage[0x06] // @061C stack[-1] // @0626 memory[0x40:0x60] // @0627 msg.sender // @064E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0650 stack[-2] // } 0605 5B JUMPDEST 0606 60 PUSH1 0x06 0608 80 DUP1 0609 54 SLOAD 060A 60 PUSH1 0x01 060C 60 PUSH1 0x01 060E 60 PUSH1 0xa0 0610 1B SHL 0611 03 SUB 0612 19 NOT 0613 16 AND 0614 60 PUSH1 0x01 0616 60 PUSH1 0x01 0618 60 PUSH1 0xa0 061A 1B SHL 061B 03 SUB 061C 83 DUP4 061D 16 AND 061E 90 SWAP1 061F 81 DUP2 0620 17 OR 0621 90 SWAP1 0622 91 SWAP2 0623 55 SSTORE 0624 60 PUSH1 0x40 0626 51 MLOAD 0627 33 CALLER 0628 90 SWAP1 0629 7F PUSH32 0x8292fce18fa69edf4db7b94ea2e58241df0ae57f97e0a6c9b29067028bf92d76 064A 90 SWAP1 064B 60 PUSH1 0x00 064D 90 SWAP1 064E A3 LOG3 064F 50 POP 0650 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0623 storage[0x06] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[0x06]) // @064E log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8292fce18fa69edf4db7b94ea2e58241df0ae57f97e0a6c9b29067028bf92d76, msg.sender, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_0651: // Incoming call from 0x0851, returns to 0x0852 // Incoming call from 0x0BC2, returns to 0x0BC3 // Incoming jump from 0x0298 // Inputs[4] // { // @0654 stack[-1] // @065F memory[0x00:0x40] // @0660 storage[keccak256(memory[0x00:0x40])] // @0669 stack[-3] // } 0651 5B JUMPDEST 0652 60 PUSH1 0x00 0654 81 DUP2 0655 81 DUP2 0656 52 MSTORE 0657 60 PUSH1 0x02 0659 60 PUSH1 0x20 065B 52 MSTORE 065C 60 PUSH1 0x40 065E 90 SWAP1 065F 20 SHA3 0660 54 SLOAD 0661 60 PUSH1 0x01 0663 60 PUSH1 0x01 0665 60 PUSH1 0xa0 0667 1B SHL 0668 03 SUB 0669 84 DUP5 066A 81 DUP2 066B 16 AND 066C 91 SWAP2 066D 16 AND 066E 14 EQ 066F 61 PUSH2 0x06a7 0672 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0656 memory[0x00:0x20] = stack[-1] // @065B memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x06a7, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-3] label_0673: // Incoming jump from 0x0672, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[1] { @0675 memory[0x40:0x60] } 0673 60 PUSH1 0x40 0675 51 MLOAD 0676 62 PUSH3 0x461bcd 067A 60 PUSH1 0xe5 067C 1B SHL 067D 81 DUP2 067E 52 MSTORE 067F 60 PUSH1 0x20 0681 60 PUSH1 0x04 0683 82 DUP3 0684 01 ADD 0685 52 MSTORE 0686 60 PUSH1 0x0a 0688 60 PUSH1 0x24 068A 82 DUP3 068B 01 ADD 068C 52 MSTORE 068D 69 PUSH10 0x57524f4e475f46524f4d 0698 60 PUSH1 0xb0 069A 1B SHL 069B 60 PUSH1 0x44 069D 82 DUP3 069E 01 ADD 069F 52 MSTORE 06A0 60 PUSH1 0x64 06A2 01 ADD 06A3 61 PUSH2 0x0576 06A6 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @067E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0685 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @068C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0a // @069F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x57524f4e475f46524f4d << 0xb0 // @06A2 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0576 label_06A7: // Incoming jump from 0x0672, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[1] { @06B0 stack[-2] } 06A7 5B JUMPDEST 06A8 60 PUSH1 0x01 06AA 60 PUSH1 0x01 06AC 60 PUSH1 0xa0 06AE 1B SHL 06AF 03 SUB 06B0 82 DUP3 06B1 16 AND 06B2 61 PUSH2 0x06f1 06B5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06f1, if stack[-2] & (0x01 << 0xa0) - 0x01 label_06B6: // Incoming jump from 0x06B5, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @06B8 memory[0x40:0x60] } 06B6 60 PUSH1 0x40 06B8 51 MLOAD 06B9 62 PUSH3 0x461bcd 06BD 60 PUSH1 0xe5 06BF 1B SHL 06C0 81 DUP2 06C1 52 MSTORE 06C2 60 PUSH1 0x20 06C4 60 PUSH1 0x04 06C6 82 DUP3 06C7 01 ADD 06C8 52 MSTORE 06C9 60 PUSH1 0x11 06CB 60 PUSH1 0x24 06CD 82 DUP3 06CE 01 ADD 06CF 52 MSTORE 06D0 70 PUSH17 0x1253959053125117d49150d25412515395 06E2 60 PUSH1 0x7a 06E4 1B SHL 06E5 60 PUSH1 0x44 06E7 82 DUP3 06E8 01 ADD 06E9 52 MSTORE 06EA 60 PUSH1 0x64 06EC 01 ADD 06ED 61 PUSH2 0x0576 06F0 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @06C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @06C8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @06CF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x11 // @06E9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1253959053125117d49150d25412515395 << 0x7a // @06EC stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0576 label_06F1: // Incoming jump from 0x06B5, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @06F2 msg.sender // @06FB stack[-3] // } 06F1 5B JUMPDEST 06F2 33 CALLER 06F3 60 PUSH1 0x01 06F5 60 PUSH1 0x01 06F7 60 PUSH1 0xa0 06F9 1B SHL 06FA 03 SUB 06FB 84 DUP5 06FC 16 AND 06FD 14 EQ 06FE 80 DUP1 06FF 61 PUSH2 0x072b 0702 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06FD stack[0] = stack[-3] & (0x01 << 0xa0) - 0x01 == msg.sender } // Block ends with conditional jump to 0x072b, if stack[-3] & (0x01 << 0xa0) - 0x01 == msg.sender label_0703: // Incoming jump from 0x0702, if not stack[-3] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[5] // { // @070C stack[-4] // @071E memory[0x00:0x40] // @071F msg.sender // @0726 memory[0x00:0x40] // @0727 storage[keccak256(memory[0x00:0x40])] // } 0703 50 POP 0704 60 PUSH1 0x01 0706 60 PUSH1 0x01 0708 60 PUSH1 0xa0 070A 1B SHL 070B 03 SUB 070C 83 DUP4 070D 16 AND 070E 60 PUSH1 0x00 0710 90 SWAP1 0711 81 DUP2 0712 52 MSTORE 0713 60 PUSH1 0x05 0715 60 PUSH1 0x20 0717 90 SWAP1 0718 81 DUP2 0719 52 MSTORE 071A 60 PUSH1 0x40 071C 80 DUP1 071D 83 DUP4 071E 20 SHA3 071F 33 CALLER 0720 84 DUP5 0721 52 MSTORE 0722 90 SWAP1 0723 91 SWAP2 0724 52 MSTORE 0725 90 SWAP1 0726 20 SHA3 0727 54 SLOAD 0728 60 PUSH1 0xff 072A 16 AND 072B 5B JUMPDEST 072C 80 DUP1 072D 61 PUSH2 0x074c 0730 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0712 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @0719 memory[0x20:0x40] = 0x05 // @0721 memory[0x00:0x20] = msg.sender // @0724 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @072A stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x074c, if 0xff & storage[keccak256(memory[0x00:0x40])] label_0731: // Incoming jump from 0x0730, if not stack[-1] // Incoming jump from 0x0730, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @0734 stack[-2] // @073F memory[0x00:0x40] // @0740 storage[keccak256(memory[0x00:0x40])] // @074A msg.sender // } 0731 50 POP 0732 60 PUSH1 0x00 0734 81 DUP2 0735 81 DUP2 0736 52 MSTORE 0737 60 PUSH1 0x04 0739 60 PUSH1 0x20 073B 52 MSTORE 073C 60 PUSH1 0x40 073E 90 SWAP1 073F 20 SHA3 0740 54 SLOAD 0741 60 PUSH1 0x01 0743 60 PUSH1 0x01 0745 60 PUSH1 0xa0 0747 1B SHL 0748 03 SUB 0749 16 AND 074A 33 CALLER 074B 14 EQ 074C 5B JUMPDEST 074D 61 PUSH2 0x0789 0750 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0736 memory[0x00:0x20] = stack[-2] // @073B memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x0789, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_0751: // Incoming jump from 0x0750, if not stack[-1] // Incoming jump from 0x0750, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0753 memory[0x40:0x60] } 0751 60 PUSH1 0x40 0753 51 MLOAD 0754 62 PUSH3 0x461bcd 0758 60 PUSH1 0xe5 075A 1B SHL 075B 81 DUP2 075C 52 MSTORE 075D 60 PUSH1 0x20 075F 60 PUSH1 0x04 0761 82 DUP3 0762 01 ADD 0763 52 MSTORE 0764 60 PUSH1 0x0e 0766 60 PUSH1 0x24 0768 82 DUP3 0769 01 ADD 076A 52 MSTORE 076B 6D PUSH14 0x1393d517d055551213d492569151 077A 60 PUSH1 0x92 077C 1B SHL 077D 60 PUSH1 0x44 077F 82 DUP3 0780 01 ADD 0781 52 MSTORE 0782 60 PUSH1 0x64 0784 01 ADD 0785 61 PUSH2 0x0576 0788 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @075C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0763 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @076A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @0781 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1393d517d055551213d492569151 << 0x92 // @0784 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0576 label_0789: // Incoming jump from 0x0750, if stack[-1] // Incoming jump from 0x0750, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[14] // { // @0793 stack[-3] // @07A5 memory[0x00:0x40] // @07A7 storage[keccak256(memory[0x00:0x40])] // @07AF stack[-2] // @07B6 memory[0x00:0x40] // @07B8 storage[keccak256(memory[0x00:0x40])] // @07BE stack[-1] // @07C7 memory[0x00:0x40] // @07C9 storage[keccak256(memory[0x00:0x40])] // @07E2 memory[0x00:0x40] // @07E4 storage[keccak256(memory[0x00:0x40])] // @07EC memory[0x40:0x60] // @0813 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0817 stack[-4] // } 0789 5B JUMPDEST 078A 60 PUSH1 0x01 078C 60 PUSH1 0x01 078E 60 PUSH1 0xa0 0790 1B SHL 0791 03 SUB 0792 80 DUP1 0793 84 DUP5 0794 16 AND 0795 60 PUSH1 0x00 0797 81 DUP2 0798 81 DUP2 0799 52 MSTORE 079A 60 PUSH1 0x03 079C 60 PUSH1 0x20 079E 90 SWAP1 079F 81 DUP2 07A0 52 MSTORE 07A1 60 PUSH1 0x40 07A3 80 DUP1 07A4 83 DUP4 07A5 20 SHA3 07A6 80 DUP1 07A7 54 SLOAD 07A8 60 PUSH1 0x00 07AA 19 NOT 07AB 01 ADD 07AC 90 SWAP1 07AD 55 SSTORE 07AE 93 SWAP4 07AF 86 DUP7 07B0 16 AND 07B1 80 DUP1 07B2 83 DUP4 07B3 52 MSTORE 07B4 84 DUP5 07B5 83 DUP4 07B6 20 SHA3 07B7 80 DUP1 07B8 54 SLOAD 07B9 60 PUSH1 0x01 07BB 01 ADD 07BC 90 SWAP1 07BD 55 SSTORE 07BE 85 DUP6 07BF 83 DUP4 07C0 52 MSTORE 07C1 60 PUSH1 0x02 07C3 82 DUP3 07C4 52 MSTORE 07C5 84 DUP5 07C6 83 DUP4 07C7 20 SHA3 07C8 80 DUP1 07C9 54 SLOAD 07CA 60 PUSH1 0x01 07CC 60 PUSH1 0x01 07CE 60 PUSH1 0xa0 07D0 1B SHL 07D1 03 SUB 07D2 19 NOT 07D3 90 SWAP1 07D4 81 DUP2 07D5 16 AND 07D6 83 DUP4 07D7 17 OR 07D8 90 SWAP1 07D9 91 SWAP2 07DA 55 SSTORE 07DB 60 PUSH1 0x04 07DD 90 SWAP1 07DE 92 SWAP3 07DF 52 MSTORE 07E0 84 DUP5 07E1 83 DUP4 07E2 20 SHA3 07E3 80 DUP1 07E4 54 SLOAD 07E5 90 SWAP1 07E6 92 SWAP3 07E7 16 AND 07E8 90 SWAP1 07E9 91 SWAP2 07EA 55 SSTORE 07EB 92 SWAP3 07EC 51 MLOAD 07ED 84 DUP5 07EE 93 SWAP4 07EF 92 SWAP3 07F0 91 SWAP2 07F1 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0812 91 SWAP2 0813 A4 LOG4 0814 50 POP 0815 50 POP 0816 50 POP 0817 56 *JUMP // Stack delta = -4 // Outputs[11] // { // @0799 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @07A0 memory[0x20:0x40] = 0x03 // @07AD storage[keccak256(memory[0x00:0x40])] = ~0x00 + storage[keccak256(memory[0x00:0x40])] // @07B3 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @07BD storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // @07C0 memory[0x00:0x20] = stack[-1] // @07C4 memory[0x20:0x40] = 0x02 // @07DA storage[keccak256(memory[0x00:0x40])] = (stack[-2] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @07DF memory[0x20:0x40] = 0x04 // @07EA storage[keccak256(memory[0x00:0x40])] = ~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])] // @0813 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1]]); // } // Block ends with unconditional jump to stack[-4] label_0818: // Incoming jump from 0x02AB // Inputs[2] // { // @081B storage[0x06] // @0825 msg.sender // } 0818 5B JUMPDEST 0819 60 PUSH1 0x06 081B 54 SLOAD 081C 60 PUSH1 0x01 081E 60 PUSH1 0x01 0820 60 PUSH1 0xa0 0822 1B SHL 0823 03 SUB 0824 16 AND 0825 33 CALLER 0826 14 EQ 0827 61 PUSH2 0x0842 082A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0842, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_082B: // Incoming jump from 0x082A, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @082D memory[0x40:0x60] } 082B 60 PUSH1 0x40 082D 51 MLOAD 082E 62 PUSH3 0x461bcd 0832 60 PUSH1 0xe5 0834 1B SHL 0835 81 DUP2 0836 52 MSTORE 0837 60 PUSH1 0x04 0839 01 ADD 083A 61 PUSH2 0x0576 083D 90 SWAP1 083E 61 PUSH2 0x1539 0841 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0836 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @083D stack[0] = 0x0576 // @083D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1539, returns to 0x0576 label_0842: // Incoming jump from 0x082A, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[2] // { // @0845 stack[-1] // @0846 stack[-2] // } 0842 5B JUMPDEST 0843 60 PUSH1 0x09 0845 55 SSTORE 0846 56 *JUMP // Stack delta = -2 // Outputs[1] { @0845 storage[0x09] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0847: // Incoming jump from 0x02E9 // Inputs[3] // { // @084B stack[-3] // @084C stack[-2] // @084D stack[-1] // } 0847 5B JUMPDEST 0848 61 PUSH2 0x0852 084B 83 DUP4 084C 83 DUP4 084D 83 DUP4 084E 61 PUSH2 0x0651 0851 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0848 stack[0] = 0x0852 // @084B stack[1] = stack[-3] // @084C stack[2] = stack[-2] // @084D stack[3] = stack[-1] // } // Block ends with call to 0x0651, returns to 0x0852 label_0852: // Incoming return from call to 0x0651 at 0x0851 // Inputs[2] // { // @085B stack[-2] // @085D address(stack[-2] & (0x01 << 0xa0) - 0x01).code.length // } 0852 5B JUMPDEST 0853 60 PUSH1 0x01 0855 60 PUSH1 0x01 0857 60 PUSH1 0xa0 0859 1B SHL 085A 03 SUB 085B 82 DUP3 085C 16 AND 085D 3B EXTCODESIZE 085E 15 ISZERO 085F 80 DUP1 0860 61 PUSH2 0x08fb 0863 57 *JUMPI // Stack delta = +1 // Outputs[1] { @085E stack[0] = !address(stack[-2] & (0x01 << 0xa0) - 0x01).code.length } // Block ends with conditional jump to 0x08fb, if !address(stack[-2] & (0x01 << 0xa0) - 0x01).code.length label_0864: // Incoming jump from 0x0863, if not !address(stack[-2] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @0867 memory[0x40:0x60] // @0873 msg.sender // @0881 stack[-4] // @088D stack[-2] // @08A1 stack[-3] // @08B1 memory[0x40:0x60] // @08B9 msg.gas // @08BA address(stack[-3] & (0x01 << 0xa0) - 0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @08BA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0864 50 POP 0865 60 PUSH1 0x40 0867 51 MLOAD 0868 63 PUSH4 0x0a85bd01 086D 60 PUSH1 0xe1 086F 1B SHL 0870 80 DUP1 0871 82 DUP3 0872 52 MSTORE 0873 33 CALLER 0874 60 PUSH1 0x04 0876 83 DUP4 0877 01 ADD 0878 52 MSTORE 0879 60 PUSH1 0x01 087B 60 PUSH1 0x01 087D 60 PUSH1 0xa0 087F 1B SHL 0880 03 SUB 0881 85 DUP6 0882 81 DUP2 0883 16 AND 0884 60 PUSH1 0x24 0886 84 DUP5 0887 01 ADD 0888 52 MSTORE 0889 60 PUSH1 0x44 088B 83 DUP4 088C 01 ADD 088D 84 DUP5 088E 90 SWAP1 088F 52 MSTORE 0890 60 PUSH1 0x80 0892 60 PUSH1 0x64 0894 84 DUP5 0895 01 ADD 0896 52 MSTORE 0897 60 PUSH1 0x00 0899 60 PUSH1 0x84 089B 84 DUP5 089C 01 ADD 089D 52 MSTORE 089E 90 SWAP1 089F 91 SWAP2 08A0 90 SWAP1 08A1 84 DUP5 08A2 16 AND 08A3 90 SWAP1 08A4 63 PUSH4 0x150b7a02 08A9 90 SWAP1 08AA 60 PUSH1 0xa4 08AC 01 ADD 08AD 60 PUSH1 0x20 08AF 60 PUSH1 0x40 08B1 51 MLOAD 08B2 80 DUP1 08B3 83 DUP4 08B4 03 SUB 08B5 81 DUP2 08B6 60 PUSH1 0x00 08B8 87 DUP8 08B9 5A GAS 08BA F1 CALL 08BB 15 ISZERO 08BC 80 DUP1 08BD 15 ISZERO 08BE 61 PUSH2 0x08cb 08C1 57 *JUMPI // Stack delta = +4 // Outputs[12] // { // @0872 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @0878 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @0888 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @088F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-2] // @0896 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x80 // @089D memory[memory[0x40:0x60] + 0x84:memory[0x40:0x60] + 0x84 + 0x20] = 0x00 // @089F stack[-1] = 0x0a85bd01 << 0xe1 // @08A3 stack[0] = stack[-3] & (0x01 << 0xa0) - 0x01 // @08A9 stack[1] = 0x150b7a02 // @08AC stack[2] = 0xa4 + memory[0x40:0x60] // @08BA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-3] & (0x01 << 0xa0) - 0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @08BB stack[3] = !address(stack[-3] & (0x01 << 0xa0) - 0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x08cb, if !!address(stack[-3] & (0x01 << 0xa0) - 0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_08C2: // Incoming jump from 0x08C1, if not !!address(stack[-3] & (0x01 << 0xa0) - 0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @08C2 returndata.length // @08C6 returndata[0x00:0x00 + returndata.length] // @08C7 returndata.length // @08CA memory[0x00:0x00 + returndata.length] // } 08C2 3D RETURNDATASIZE 08C3 60 PUSH1 0x00 08C5 80 DUP1 08C6 3E RETURNDATACOPY 08C7 3D RETURNDATASIZE 08C8 60 PUSH1 0x00 08CA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @08C6 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @08CA revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_08CB: // Incoming jump from 0x08C1, if !!address(stack[-3] & (0x01 << 0xa0) - 0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[2] // { // @08D2 memory[0x40:0x60] // @08D3 returndata.length // } 08CB 5B JUMPDEST 08CC 50 POP 08CD 50 POP 08CE 50 POP 08CF 50 POP 08D0 60 PUSH1 0x40 08D2 51 MLOAD 08D3 3D RETURNDATASIZE 08D4 60 PUSH1 0x1f 08D6 19 NOT 08D7 60 PUSH1 0x1f 08D9 82 DUP3 08DA 01 ADD 08DB 16 AND 08DC 82 DUP3 08DD 01 ADD 08DE 80 DUP1 08DF 60 PUSH1 0x40 08E1 52 MSTORE 08E2 50 POP 08E3 81 DUP2 08E4 01 ADD 08E5 90 SWAP1 08E6 61 PUSH2 0x08ef 08E9 91 SWAP2 08EA 90 SWAP1 08EB 61 PUSH2 0x155f 08EE 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @08E1 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @08E9 stack[-4] = 0x08ef // @08EA stack[-2] = memory[0x40:0x60] // @08EA stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x155f 08EF 5B JUMPDEST 08F0 60 PUSH1 0x01 08F2 60 PUSH1 0x01 08F4 60 PUSH1 0xe0 08F6 1B SHL 08F7 03 SUB 08F8 19 NOT 08F9 16 AND 08FA 14 EQ label_08FB: // Incoming jump from 0x0863, if !address(stack[-2] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @08FF stack[-1] } 08FB 5B JUMPDEST 08FC 61 PUSH2 0x093a 08FF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x093a, if stack[-1] label_0900: // Incoming jump from 0x08FF, if not stack[-1] // Inputs[1] { @0902 memory[0x40:0x60] } 0900 60 PUSH1 0x40 0902 51 MLOAD 0903 62 PUSH3 0x461bcd 0907 60 PUSH1 0xe5 0909 1B SHL 090A 81 DUP2 090B 52 MSTORE 090C 60 PUSH1 0x20 090E 60 PUSH1 0x04 0910 82 DUP3 0911 01 ADD 0912 52 MSTORE 0913 60 PUSH1 0x10 0915 60 PUSH1 0x24 0917 82 DUP3 0918 01 ADD 0919 52 MSTORE 091A 6F PUSH16 0x155394d0519157d49150d25412515395 092B 60 PUSH1 0x82 092D 1B SHL 092E 60 PUSH1 0x44 0930 82 DUP3 0931 01 ADD 0932 52 MSTORE 0933 60 PUSH1 0x64 0935 01 ADD 0936 61 PUSH2 0x0576 0939 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @090B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0912 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0919 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @0932 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x155394d0519157d49150d25412515395 << 0x82 // @0935 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0576 label_093A: // Incoming return from call to 0x0A6F at 0x0E09 // Incoming return from call to 0x0A6F at 0x0A6E // Incoming jump from 0x08FF, if stack[-1] // Inputs[1] { @093E stack[-4] } 093A 5B JUMPDEST 093B 50 POP 093C 50 POP 093D 50 POP 093E 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_093F: // Incoming jump from 0x02FC // Inputs[2] // { // @0942 storage[0x06] // @094C msg.sender // } 093F 5B JUMPDEST 0940 60 PUSH1 0x06 0942 54 SLOAD 0943 60 PUSH1 0x01 0945 60 PUSH1 0x01 0947 60 PUSH1 0xa0 0949 1B SHL 094A 03 SUB 094B 16 AND 094C 33 CALLER 094D 14 EQ 094E 61 PUSH2 0x0969 0951 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0969, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0952: // Incoming jump from 0x0951, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0954 memory[0x40:0x60] } 0952 60 PUSH1 0x40 0954 51 MLOAD 0955 62 PUSH3 0x461bcd 0959 60 PUSH1 0xe5 095B 1B SHL 095C 81 DUP2 095D 52 MSTORE 095E 60 PUSH1 0x04 0960 01 ADD 0961 61 PUSH2 0x0576 0964 90 SWAP1 0965 61 PUSH2 0x1539 0968 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @095D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0964 stack[0] = 0x0576 // @0964 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1539, returns to 0x0576 label_0969: // Incoming jump from 0x0951, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[2] // { // @096C stack[-1] // @096D stack[-2] // } 0969 5B JUMPDEST 096A 60 PUSH1 0x0b 096C 55 SSTORE 096D 56 *JUMP // Stack delta = -2 // Outputs[1] { @096C storage[0x0b] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_096E: // Incoming jump from 0x030F // Inputs[2] // { // @0971 storage[0x06] // @097B msg.sender // } 096E 5B JUMPDEST 096F 60 PUSH1 0x06 0971 54 SLOAD 0972 60 PUSH1 0x01 0974 60 PUSH1 0x01 0976 60 PUSH1 0xa0 0978 1B SHL 0979 03 SUB 097A 16 AND 097B 33 CALLER 097C 14 EQ 097D 61 PUSH2 0x0998 0980 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0998, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0981: // Incoming jump from 0x0980, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0983 memory[0x40:0x60] } 0981 60 PUSH1 0x40 0983 51 MLOAD 0984 62 PUSH3 0x461bcd 0988 60 PUSH1 0xe5 098A 1B SHL 098B 81 DUP2 098C 52 MSTORE 098D 60 PUSH1 0x04 098F 01 ADD 0990 61 PUSH2 0x0576 0993 90 SWAP1 0994 61 PUSH2 0x1539 0997 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @098C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0993 stack[0] = 0x0576 // @0993 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1539, returns to 0x0576 label_0998: // Incoming jump from 0x0980, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[2] // { // @0999 stack[-1] // @099A memory[stack[-1]:stack[-1] + 0x20] // } 0998 5B JUMPDEST 0999 80 DUP1 099A 51 MLOAD 099B 61 PUSH2 0x09ab 099E 90 SWAP1 099F 60 PUSH1 0x07 09A1 90 SWAP1 09A2 60 PUSH1 0x20 09A4 84 DUP5 09A5 01 ADD 09A6 90 SWAP1 09A7 61 PUSH2 0x10ce 09AA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @099E stack[0] = 0x09ab // @09A1 stack[1] = 0x07 // @09A6 stack[2] = stack[-1] + 0x20 // @09A6 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x10ce 09AB 5B JUMPDEST 09AC 50 POP 09AD 50 POP 09AE 56 *JUMP label_09AF: // Incoming jump from 0x0322 // Inputs[4] // { // @09B2 storage[0x0c] // @09B3 msg.sender // @09B9 stack[-2] // @09BB stack[-1] // } 09AF 5B JUMPDEST 09B0 60 PUSH1 0x0c 09B2 54 SLOAD 09B3 33 CALLER 09B4 90 SWAP1 09B5 61 PUSH2 0x09c2 09B8 90 SWAP1 09B9 84 DUP5 09BA 90 SWAP1 09BB 84 DUP5 09BC 90 SWAP1 09BD 84 DUP5 09BE 61 PUSH2 0x0e0a 09C1 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @09B4 stack[0] = msg.sender // @09B8 stack[1] = 0x09c2 // @09BA stack[2] = stack[-2] // @09BC stack[3] = stack[-1] // @09BC stack[4] = storage[0x0c] // @09BD stack[5] = msg.sender // } // Block ends with call to 0x0e0a, returns to 0x09C2 label_09C2: // Incoming return from call to 0x0E0A at 0x09C1 // Inputs[1] { @09C6 stack[-1] } 09C2 5B JUMPDEST 09C3 61 PUSH2 0x09df 09C6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x09df, if stack[-1] label_09C7: // Incoming jump from 0x09C6, if not stack[-1] // Inputs[3] // { // @09C9 memory[0x40:0x60] // @09D9 memory[0x40:0x60] // @09DE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 09C7 60 PUSH1 0x40 09C9 51 MLOAD 09CA 63 PUSH4 0x09bde339 09CF 60 PUSH1 0xe0 09D1 1B SHL 09D2 81 DUP2 09D3 52 MSTORE 09D4 60 PUSH1 0x04 09D6 01 ADD 09D7 60 PUSH1 0x40 09D9 51 MLOAD 09DA 80 DUP1 09DB 91 SWAP2 09DC 03 SUB 09DD 90 SWAP1 09DE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @09D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x09bde339 << 0xe0 // @09DE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_09DF: // Incoming jump from 0x09C6, if stack[-1] // Inputs[1] { @09E2 storage[0x09] } 09DF 5B JUMPDEST 09E0 60 PUSH1 0x09 09E2 54 SLOAD 09E3 61 PUSH2 0x09ed 09E6 90 SWAP1 09E7 60 PUSH1 0x45 09E9 61 PUSH2 0x1592 09EC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09E6 stack[0] = 0x09ed // @09E6 stack[1] = storage[0x09] // @09E7 stack[2] = 0x45 // } // Block ends with call to 0x1592, returns to 0x09ED label_09ED: // Incoming return from call to 0x1592 at 0x09EC // Inputs[2] // { // @09F0 storage[0x08] // @09F1 stack[-1] // } 09ED 5B JUMPDEST 09EE 60 PUSH1 0x08 09F0 54 SLOAD 09F1 11 GT 09F2 15 ISZERO 09F3 61 PUSH2 0x0a0f 09F6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a0f, if !(storage[0x08] > stack[-1]) label_09F7: // Incoming jump from 0x09F6, if not !(storage[0x08] > stack[-1]) // Inputs[3] // { // @09F9 memory[0x40:0x60] // @0A09 memory[0x40:0x60] // @0A0E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 09F7 60 PUSH1 0x40 09F9 51 MLOAD 09FA 63 PUSH4 0x52df9fe5 09FF 60 PUSH1 0xe0 0A01 1B SHL 0A02 81 DUP2 0A03 52 MSTORE 0A04 60 PUSH1 0x04 0A06 01 ADD 0A07 60 PUSH1 0x40 0A09 51 MLOAD 0A0A 80 DUP1 0A0B 91 SWAP2 0A0C 03 SUB 0A0D 90 SWAP1 0A0E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A03 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x52df9fe5 << 0xe0 // @0A0E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0A0F: // Incoming jump from 0x09F6, if !(storage[0x08] > stack[-1]) // Inputs[3] // { // @0A10 msg.sender // @0A1E memory[0x00:0x40] // @0A1F storage[keccak256(memory[0x00:0x40])] // } 0A0F 5B JUMPDEST 0A10 33 CALLER 0A11 60 PUSH1 0x00 0A13 90 SWAP1 0A14 81 DUP2 0A15 52 MSTORE 0A16 60 PUSH1 0x0a 0A18 60 PUSH1 0x20 0A1A 52 MSTORE 0A1B 60 PUSH1 0x40 0A1D 90 SWAP1 0A1E 20 SHA3 0A1F 54 SLOAD 0A20 60 PUSH1 0xff 0A22 16 AND 0A23 15 ISZERO 0A24 61 PUSH2 0x0a40 0A27 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0A15 memory[0x00:0x20] = msg.sender // @0A1A memory[0x20:0x40] = 0x0a // } // Block ends with conditional jump to 0x0a40, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_0A28: // Incoming jump from 0x0A27, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @0A2A memory[0x40:0x60] // @0A3A memory[0x40:0x60] // @0A3F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A28 60 PUSH1 0x40 0A2A 51 MLOAD 0A2B 63 PUSH4 0x1bbdf5c5 0A30 60 PUSH1 0xe3 0A32 1B SHL 0A33 81 DUP2 0A34 52 MSTORE 0A35 60 PUSH1 0x04 0A37 01 ADD 0A38 60 PUSH1 0x40 0A3A 51 MLOAD 0A3B 80 DUP1 0A3C 91 SWAP2 0A3D 03 SUB 0A3E 90 SWAP1 0A3F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A34 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1bbdf5c5 << 0xe3 // @0A3F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0A40: // Incoming jump from 0x0A27, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @0A41 msg.sender // @0A4F memory[0x00:0x40] // @0A51 storage[keccak256(memory[0x00:0x40])] // @0A5E storage[0x08] // } 0A40 5B JUMPDEST 0A41 33 CALLER 0A42 60 PUSH1 0x00 0A44 81 DUP2 0A45 81 DUP2 0A46 52 MSTORE 0A47 60 PUSH1 0x0a 0A49 60 PUSH1 0x20 0A4B 52 MSTORE 0A4C 60 PUSH1 0x40 0A4E 81 DUP2 0A4F 20 SHA3 0A50 80 DUP1 0A51 54 SLOAD 0A52 60 PUSH1 0xff 0A54 19 NOT 0A55 16 AND 0A56 60 PUSH1 0x01 0A58 17 OR 0A59 90 SWAP1 0A5A 55 SSTORE 0A5B 60 PUSH1 0x08 0A5D 80 DUP1 0A5E 54 SLOAD 0A5F 61 PUSH2 0x093a 0A62 93 SWAP4 0A63 92 SWAP3 0A64 90 SWAP1 0A65 91 SWAP2 0A66 90 SWAP1 0A67 61 PUSH2 0x0a6f 0A6A 83 DUP4 0A6B 61 PUSH2 0x15a9 0A6E 56 *JUMP // Stack delta = +7 // Outputs[10] // { // @0A46 memory[0x00:0x20] = msg.sender // @0A4B memory[0x20:0x40] = 0x0a // @0A5A storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0A62 stack[0] = 0x093a // @0A63 stack[1] = msg.sender // @0A65 stack[2] = storage[0x08] // @0A66 stack[3] = 0x08 // @0A66 stack[4] = 0x00 // @0A67 stack[5] = 0x0a6f // @0A6A stack[6] = storage[0x08] // } // Block ends with call to 0x15a9, returns to 0x0A6F label_0A6F: // Incoming return from call to 0x15A9 at 0x0E09 // Incoming return from call to 0x15A9 at 0x0A6E // Inputs[3] // { // @0A70 stack[-1] // @0A70 stack[-3] // @0A71 stack[-2] // } 0A6F 5B JUMPDEST 0A70 91 SWAP2 0A71 90 SWAP1 0A72 50 POP 0A73 55 SSTORE 0A74 61 PUSH2 0x0e4e 0A77 56 *JUMP // Stack delta = -3 // Outputs[1] { @0A73 storage[stack[-3]] = stack[-1] } // Block ends with unconditional jump to 0x0e4e label_0A78: // Incoming jump from 0x0335 // Incoming call from 0x0CAA, returns to 0x0CAB // Inputs[3] // { // @0A7B stack[-1] // @0A86 memory[0x00:0x40] // @0A87 storage[keccak256(memory[0x00:0x40])] // } 0A78 5B JUMPDEST 0A79 60 PUSH1 0x00 0A7B 81 DUP2 0A7C 81 DUP2 0A7D 52 MSTORE 0A7E 60 PUSH1 0x02 0A80 60 PUSH1 0x20 0A82 52 MSTORE 0A83 60 PUSH1 0x40 0A85 90 SWAP1 0A86 20 SHA3 0A87 54 SLOAD 0A88 60 PUSH1 0x01 0A8A 60 PUSH1 0x01 0A8C 60 PUSH1 0xa0 0A8E 1B SHL 0A8F 03 SUB 0A90 16 AND 0A91 80 DUP1 0A92 61 PUSH2 0x0aca 0A95 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0A7D memory[0x00:0x20] = stack[-1] // @0A82 memory[0x20:0x40] = 0x02 // @0A90 stack[0] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0aca, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_0A96: // Incoming jump from 0x0A95, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0A98 memory[0x40:0x60] } 0A96 60 PUSH1 0x40 0A98 51 MLOAD 0A99 62 PUSH3 0x461bcd 0A9D 60 PUSH1 0xe5 0A9F 1B SHL 0AA0 81 DUP2 0AA1 52 MSTORE 0AA2 60 PUSH1 0x20 0AA4 60 PUSH1 0x04 0AA6 82 DUP3 0AA7 01 ADD 0AA8 52 MSTORE 0AA9 60 PUSH1 0x0a 0AAB 60 PUSH1 0x24 0AAD 82 DUP3 0AAE 01 ADD 0AAF 52 MSTORE 0AB0 69 PUSH10 0x1393d517d35253951151 0ABB 60 PUSH1 0xb2 0ABD 1B SHL 0ABE 60 PUSH1 0x44 0AC0 82 DUP3 0AC1 01 ADD 0AC2 52 MSTORE 0AC3 60 PUSH1 0x64 0AC5 01 ADD 0AC6 61 PUSH2 0x0576 0AC9 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0AA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AA8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0AAF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0a // @0AC2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1393d517d35253951151 << 0xb2 // @0AC5 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0576 label_0ACA: // Incoming jump from 0x1232, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x0A95, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @0ACB stack[-1] // @0ACB stack[-3] // @0ACC stack[-2] // } 0ACA 5B JUMPDEST 0ACB 91 SWAP2 0ACC 90 SWAP1 0ACD 50 POP 0ACE 56 *JUMP // Stack delta = -2 // Outputs[1] { @0ACB stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_0ACF: // Incoming call from 0x033D, returns to 0x01F9 // Inputs[1] { @0AD3 storage[0x07] } 0ACF 5B JUMPDEST 0AD0 60 PUSH1 0x07 0AD2 80 DUP1 0AD3 54 SLOAD 0AD4 61 PUSH2 0x0473 0AD7 90 SWAP1 0AD8 61 PUSH2 0x14fe 0ADB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AD0 stack[0] = 0x07 // @0AD7 stack[1] = 0x0473 // @0AD7 stack[2] = storage[0x07] // } // Block ends with call to 0x14fe, returns to 0x0473 label_0ADC: // Incoming jump from 0x0350 // Inputs[1] { @0AE7 stack[-1] } 0ADC 5B JUMPDEST 0ADD 60 PUSH1 0x00 0ADF 60 PUSH1 0x01 0AE1 60 PUSH1 0x01 0AE3 60 PUSH1 0xa0 0AE5 1B SHL 0AE6 03 SUB 0AE7 82 DUP3 0AE8 16 AND 0AE9 61 PUSH2 0x0b23 0AEC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0ADD stack[0] = 0x00 } // Block ends with conditional jump to 0x0b23, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0AED: // Incoming jump from 0x0AEC, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0AEF memory[0x40:0x60] } 0AED 60 PUSH1 0x40 0AEF 51 MLOAD 0AF0 62 PUSH3 0x461bcd 0AF4 60 PUSH1 0xe5 0AF6 1B SHL 0AF7 81 DUP2 0AF8 52 MSTORE 0AF9 60 PUSH1 0x20 0AFB 60 PUSH1 0x04 0AFD 82 DUP3 0AFE 01 ADD 0AFF 52 MSTORE 0B00 60 PUSH1 0x0c 0B02 60 PUSH1 0x24 0B04 82 DUP3 0B05 01 ADD 0B06 52 MSTORE 0B07 6B PUSH12 0x5a45524f5f41444452455353 0B14 60 PUSH1 0xa0 0B16 1B SHL 0B17 60 PUSH1 0x44 0B19 82 DUP3 0B1A 01 ADD 0B1B 52 MSTORE 0B1C 60 PUSH1 0x64 0B1E 01 ADD 0B1F 61 PUSH2 0x0576 0B22 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0AF8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AFF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B06 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @0B1B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5a45524f5f41444452455353 << 0xa0 // @0B1E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0576 label_0B23: // Incoming jump from 0x0AEC, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0B2D stack[-2] // @0B3B memory[0x00:0x40] // @0B3C storage[keccak256(memory[0x00:0x40])] // @0B3D stack[-3] // } 0B23 5B JUMPDEST 0B24 50 POP 0B25 60 PUSH1 0x01 0B27 60 PUSH1 0x01 0B29 60 PUSH1 0xa0 0B2B 1B SHL 0B2C 03 SUB 0B2D 16 AND 0B2E 60 PUSH1 0x00 0B30 90 SWAP1 0B31 81 DUP2 0B32 52 MSTORE 0B33 60 PUSH1 0x03 0B35 60 PUSH1 0x20 0B37 52 MSTORE 0B38 60 PUSH1 0x40 0B3A 90 SWAP1 0B3B 20 SHA3 0B3C 54 SLOAD 0B3D 90 SWAP1 0B3E 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0B32 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0B37 memory[0x20:0x40] = 0x03 // @0B3D stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0B3F: // Incoming call from 0x0374, returns to 0x01F9 // Inputs[1] { @0B43 storage[0x01] } 0B3F 5B JUMPDEST 0B40 60 PUSH1 0x01 0B42 80 DUP1 0B43 54 SLOAD 0B44 61 PUSH2 0x0473 0B47 90 SWAP1 0B48 61 PUSH2 0x14fe 0B4B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B40 stack[0] = 0x01 // @0B47 stack[1] = 0x0473 // @0B47 stack[2] = storage[0x01] // } // Block ends with call to 0x14fe, returns to 0x0473 label_0B4C: // Incoming jump from 0x0387 // Inputs[10] // { // @0B4D msg.sender // @0B5E memory[0x00:0x40] // @0B67 stack[-2] // @0B72 memory[0x00:0x40] // @0B74 storage[keccak256(memory[0x00:0x40])] // @0B79 stack[-1] // @0B83 memory[0x40:0x60] // @0BAF memory[0x40:0x60] // @0BB4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0BB7 stack[-3] // } 0B4C 5B JUMPDEST 0B4D 33 CALLER 0B4E 60 PUSH1 0x00 0B50 81 DUP2 0B51 81 DUP2 0B52 52 MSTORE 0B53 60 PUSH1 0x05 0B55 60 PUSH1 0x20 0B57 90 SWAP1 0B58 81 DUP2 0B59 52 MSTORE 0B5A 60 PUSH1 0x40 0B5C 80 DUP1 0B5D 83 DUP4 0B5E 20 SHA3 0B5F 60 PUSH1 0x01 0B61 60 PUSH1 0x01 0B63 60 PUSH1 0xa0 0B65 1B SHL 0B66 03 SUB 0B67 87 DUP8 0B68 16 AND 0B69 80 DUP1 0B6A 85 DUP6 0B6B 52 MSTORE 0B6C 90 SWAP1 0B6D 83 DUP4 0B6E 52 MSTORE 0B6F 92 SWAP3 0B70 81 DUP2 0B71 90 SWAP1 0B72 20 SHA3 0B73 80 DUP1 0B74 54 SLOAD 0B75 60 PUSH1 0xff 0B77 19 NOT 0B78 16 AND 0B79 86 DUP7 0B7A 15 ISZERO 0B7B 15 ISZERO 0B7C 90 SWAP1 0B7D 81 DUP2 0B7E 17 OR 0B7F 90 SWAP1 0B80 91 SWAP2 0B81 55 SSTORE 0B82 90 SWAP1 0B83 51 MLOAD 0B84 90 SWAP1 0B85 81 DUP2 0B86 52 MSTORE 0B87 91 SWAP2 0B88 92 SWAP3 0B89 91 SWAP2 0B8A 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0BAB 91 SWAP2 0BAC 01 ADD 0BAD 60 PUSH1 0x40 0BAF 51 MLOAD 0BB0 80 DUP1 0BB1 91 SWAP2 0BB2 03 SUB 0BB3 90 SWAP1 0BB4 A3 LOG3 0BB5 50 POP 0BB6 50 POP 0BB7 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0B52 memory[0x00:0x20] = msg.sender // @0B59 memory[0x20:0x40] = 0x05 // @0B6B memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0B6E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0B81 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0B86 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0BB4 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-3] label_0BB8: // Incoming jump from 0x039A // Inputs[3] // { // @0BBC stack[-5] // @0BBD stack[-4] // @0BBE stack[-3] // } 0BB8 5B JUMPDEST 0BB9 61 PUSH2 0x0bc3 0BBC 85 DUP6 0BBD 85 DUP6 0BBE 85 DUP6 0BBF 61 PUSH2 0x0651 0BC2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0BB9 stack[0] = 0x0bc3 // @0BBC stack[1] = stack[-5] // @0BBD stack[2] = stack[-4] // @0BBE stack[3] = stack[-3] // } // Block ends with call to 0x0651, returns to 0x0BC3 label_0BC3: // Incoming return from call to 0x0651 at 0x0BC2 // Inputs[2] // { // @0BCC stack[-4] // @0BCE address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } 0BC3 5B JUMPDEST 0BC4 60 PUSH1 0x01 0BC6 60 PUSH1 0x01 0BC8 60 PUSH1 0xa0 0BCA 1B SHL 0BCB 03 SUB 0BCC 84 DUP5 0BCD 16 AND 0BCE 3B EXTCODESIZE 0BCF 15 ISZERO 0BD0 80 DUP1 0BD1 61 PUSH2 0x0c5a 0BD4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BCF stack[0] = !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length } // Block ends with conditional jump to 0x0c5a, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length label_0BD5: // Incoming jump from 0x0BD4, if not !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[7] // { // @0BD8 memory[0x40:0x60] // @0BED stack[-5] // @0BFA msg.sender // @0BFC stack[-6] // @0BFE stack[-4] // @0C00 stack[-3] // @0C02 stack[-2] // } 0BD5 50 POP 0BD6 60 PUSH1 0x40 0BD8 51 MLOAD 0BD9 63 PUSH4 0x0a85bd01 0BDE 60 PUSH1 0xe1 0BE0 1B SHL 0BE1 80 DUP1 0BE2 82 DUP3 0BE3 52 MSTORE 0BE4 90 SWAP1 0BE5 60 PUSH1 0x01 0BE7 60 PUSH1 0x01 0BE9 60 PUSH1 0xa0 0BEB 1B SHL 0BEC 03 SUB 0BED 86 DUP7 0BEE 16 AND 0BEF 90 SWAP1 0BF0 63 PUSH4 0x150b7a02 0BF5 90 SWAP1 0BF6 61 PUSH2 0x0c0b 0BF9 90 SWAP1 0BFA 33 CALLER 0BFB 90 SWAP1 0BFC 8A DUP11 0BFD 90 SWAP1 0BFE 89 DUP10 0BFF 90 SWAP1 0C00 89 DUP10 0C01 90 SWAP1 0C02 89 DUP10 0C03 90 SWAP1 0C04 60 PUSH1 0x04 0C06 01 ADD 0C07 61 PUSH2 0x15c4 0C0A 56 *JUMP // Stack delta = +9 // Outputs[11] // { // @0BE3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @0BE4 stack[-1] = 0x0a85bd01 << 0xe1 // @0BEF stack[0] = stack[-5] & (0x01 << 0xa0) - 0x01 // @0BF5 stack[1] = 0x150b7a02 // @0BF9 stack[2] = 0x0c0b // @0BFB stack[3] = msg.sender // @0BFD stack[4] = stack[-6] // @0BFF stack[5] = stack[-4] // @0C01 stack[6] = stack[-3] // @0C03 stack[7] = stack[-2] // @0C06 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x15c4, returns to 0x0C0B label_0C0B: // Incoming return from call to 0x15C4 at 0x0C0A // Inputs[6] // { // @0C10 memory[0x40:0x60] // @0C12 stack[-1] // @0C17 stack[-3] // @0C18 msg.gas // @0C19 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0C19 address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } 0C0B 5B JUMPDEST 0C0C 60 PUSH1 0x20 0C0E 60 PUSH1 0x40 0C10 51 MLOAD 0C11 80 DUP1 0C12 83 DUP4 0C13 03 SUB 0C14 81 DUP2 0C15 60 PUSH1 0x00 0C17 87 DUP8 0C18 5A GAS 0C19 F1 CALL 0C1A 15 ISZERO 0C1B 80 DUP1 0C1C 15 ISZERO 0C1D 61 PUSH2 0x0c2a 0C20 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0C19 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0C1A stack[0] = !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x0c2a, if !!address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_0C21: // Incoming jump from 0x0C20, if not !!address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[4] // { // @0C21 returndata.length // @0C25 returndata[0x00:0x00 + returndata.length] // @0C26 returndata.length // @0C29 memory[0x00:0x00 + returndata.length] // } 0C21 3D RETURNDATASIZE 0C22 60 PUSH1 0x00 0C24 80 DUP1 0C25 3E RETURNDATACOPY 0C26 3D RETURNDATASIZE 0C27 60 PUSH1 0x00 0C29 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C25 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0C29 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0C2A: // Incoming jump from 0x0C20, if !!address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[2] // { // @0C31 memory[0x40:0x60] // @0C32 returndata.length // } 0C2A 5B JUMPDEST 0C2B 50 POP 0C2C 50 POP 0C2D 50 POP 0C2E 50 POP 0C2F 60 PUSH1 0x40 0C31 51 MLOAD 0C32 3D RETURNDATASIZE 0C33 60 PUSH1 0x1f 0C35 19 NOT 0C36 60 PUSH1 0x1f 0C38 82 DUP3 0C39 01 ADD 0C3A 16 AND 0C3B 82 DUP3 0C3C 01 ADD 0C3D 80 DUP1 0C3E 60 PUSH1 0x40 0C40 52 MSTORE 0C41 50 POP 0C42 81 DUP2 0C43 01 ADD 0C44 90 SWAP1 0C45 61 PUSH2 0x0c4e 0C48 91 SWAP2 0C49 90 SWAP1 0C4A 61 PUSH2 0x155f 0C4D 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0C40 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0C48 stack[-4] = 0x0c4e // @0C49 stack[-2] = memory[0x40:0x60] // @0C49 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x155f 0C4E 5B JUMPDEST 0C4F 60 PUSH1 0x01 0C51 60 PUSH1 0x01 0C53 60 PUSH1 0xe0 0C55 1B SHL 0C56 03 SUB 0C57 19 NOT 0C58 16 AND 0C59 14 EQ label_0C5A: // Incoming jump from 0x0BD4, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0C5E stack[-1] } 0C5A 5B JUMPDEST 0C5B 61 PUSH2 0x0c99 0C5E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c99, if stack[-1] label_0C5F: // Incoming jump from 0x0C5E, if not stack[-1] // Inputs[1] { @0C61 memory[0x40:0x60] } 0C5F 60 PUSH1 0x40 0C61 51 MLOAD 0C62 62 PUSH3 0x461bcd 0C66 60 PUSH1 0xe5 0C68 1B SHL 0C69 81 DUP2 0C6A 52 MSTORE 0C6B 60 PUSH1 0x20 0C6D 60 PUSH1 0x04 0C6F 82 DUP3 0C70 01 ADD 0C71 52 MSTORE 0C72 60 PUSH1 0x10 0C74 60 PUSH1 0x24 0C76 82 DUP3 0C77 01 ADD 0C78 52 MSTORE 0C79 6F PUSH16 0x155394d0519157d49150d25412515395 0C8A 60 PUSH1 0x82 0C8C 1B SHL 0C8D 60 PUSH1 0x44 0C8F 82 DUP3 0C90 01 ADD 0C91 52 MSTORE 0C92 60 PUSH1 0x64 0C94 01 ADD 0C95 61 PUSH2 0x0576 0C98 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0C6A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C71 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C78 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @0C91 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x155394d0519157d49150d25412515395 << 0x82 // @0C94 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0576 label_0C99: // Incoming jump from 0x0C5E, if stack[-1] // Inputs[1] { @0C9F stack[-6] } 0C99 5B JUMPDEST 0C9A 50 POP 0C9B 50 POP 0C9C 50 POP 0C9D 50 POP 0C9E 50 POP 0C9F 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_0CA0: // Incoming jump from 0x03AD // Inputs[1] { @0CA6 stack[-1] } 0CA0 5B JUMPDEST 0CA1 60 PUSH1 0x60 0CA3 61 PUSH2 0x0cab 0CA6 82 DUP3 0CA7 61 PUSH2 0x0a78 0CAA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CA1 stack[0] = 0x60 // @0CA3 stack[1] = 0x0cab // @0CA6 stack[2] = stack[-1] // } // Block ends with call to 0x0a78, returns to 0x0CAB label_0CAB: // Incoming return from call to 0x0A78 at 0x0CAA // Inputs[1] { @0CB2 storage[0x07] } 0CAB 5B JUMPDEST 0CAC 50 POP 0CAD 60 PUSH1 0x00 0CAF 60 PUSH1 0x07 0CB1 80 DUP1 0CB2 54 SLOAD 0CB3 61 PUSH2 0x0cbb 0CB6 90 SWAP1 0CB7 61 PUSH2 0x14fe 0CBA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0CAD stack[-1] = 0x00 // @0CAF stack[0] = 0x07 // @0CB6 stack[2] = storage[0x07] // @0CB6 stack[1] = 0x0cbb // } // Block ends with call to 0x14fe, returns to 0x0CBB label_0CBB: // Incoming return from call to 0x14FE at 0x0CBA // Inputs[3] // { // @0CBC stack[-1] // @0CBC stack[-2] // @0CBE stack[-3] // } 0CBB 5B JUMPDEST 0CBC 90 SWAP1 0CBD 50 POP 0CBE 11 GT 0CBF 61 PUSH2 0x0cd7 0CC2 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x0cd7, if stack[-1] > stack[-3] label_0CC3: // Incoming jump from 0x0CC2, if not stack[-1] > stack[-3] // Inputs[1] { @0CC5 memory[0x40:0x60] } 0CC3 60 PUSH1 0x40 0CC5 51 MLOAD 0CC6 80 DUP1 0CC7 60 PUSH1 0x20 0CC9 01 ADD 0CCA 60 PUSH1 0x40 0CCC 52 MSTORE 0CCD 80 DUP1 0CCE 60 PUSH1 0x00 0CD0 81 DUP2 0CD1 52 MSTORE 0CD2 50 POP 0CD3 61 PUSH2 0x0460 0CD6 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0CC5 stack[0] = memory[0x40:0x60] // @0CCC memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0CD1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x0460 label_0CD7: // Incoming jump from 0x0CC2, if stack[-1] > stack[-3] // Inputs[1] { @0CDD stack[-2] } 0CD7 5B JUMPDEST 0CD8 60 PUSH1 0x07 0CDA 61 PUSH2 0x0ce2 0CDD 83 DUP4 0CDE 61 PUSH2 0x0f59 0CE1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CD8 stack[0] = 0x07 // @0CDA stack[1] = 0x0ce2 // @0CDD stack[2] = stack[-2] // } // Block ends with call to 0x0f59, returns to 0x0CE2 label_0CE2: // Incoming return from call to 0x0F59 at 0x0CE1 // Inputs[3] // { // @0CE5 memory[0x40:0x60] // @0CEC stack[-2] // @0CED stack[-1] // } 0CE2 5B JUMPDEST 0CE3 60 PUSH1 0x40 0CE5 51 MLOAD 0CE6 60 PUSH1 0x20 0CE8 01 ADD 0CE9 61 PUSH2 0x0cf3 0CEC 92 SWAP3 0CED 91 SWAP2 0CEE 90 SWAP1 0CEF 61 PUSH2 0x1634 0CF2 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0CEC stack[-2] = 0x0cf3 // @0CED stack[-1] = stack[-2] // @0CEE stack[1] = 0x20 + memory[0x40:0x60] // @0CEE stack[0] = stack[-1] // } // Block ends with call to 0x1634, returns to 0x0CF3 label_0CF3: // Incoming return from call to 0x1634 at 0x0CF2 // Inputs[4] // { // @0CF6 memory[0x40:0x60] // @0CFA stack[-1] // @0D03 stack[-4] // @0D04 stack[-3] // } 0CF3 5B JUMPDEST 0CF4 60 PUSH1 0x40 0CF6 51 MLOAD 0CF7 60 PUSH1 0x20 0CF9 81 DUP2 0CFA 83 DUP4 0CFB 03 SUB 0CFC 03 SUB 0CFD 81 DUP2 0CFE 52 MSTORE 0CFF 90 SWAP1 0D00 60 PUSH1 0x40 0D02 52 MSTORE 0D03 92 SWAP3 0D04 91 SWAP2 0D05 50 POP 0D06 50 POP 0D07 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0CFE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @0D02 memory[0x40:0x60] = stack[-1] // @0D03 stack[-4] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-4] label_0D08: // Incoming jump from 0x03C9 // Inputs[2] // { // @0D0B storage[0x06] // @0D15 msg.sender // } 0D08 5B JUMPDEST 0D09 60 PUSH1 0x06 0D0B 54 SLOAD 0D0C 60 PUSH1 0x01 0D0E 60 PUSH1 0x01 0D10 60 PUSH1 0xa0 0D12 1B SHL 0D13 03 SUB 0D14 16 AND 0D15 33 CALLER 0D16 14 EQ 0D17 61 PUSH2 0x0d32 0D1A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d32, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0D1B: // Incoming jump from 0x0D1A, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0D1D memory[0x40:0x60] } 0D1B 60 PUSH1 0x40 0D1D 51 MLOAD 0D1E 62 PUSH3 0x461bcd 0D22 60 PUSH1 0xe5 0D24 1B SHL 0D25 81 DUP2 0D26 52 MSTORE 0D27 60 PUSH1 0x04 0D29 01 ADD 0D2A 61 PUSH2 0x0576 0D2D 90 SWAP1 0D2E 61 PUSH2 0x1539 0D31 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D26 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D2D stack[0] = 0x0576 // @0D2D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1539, returns to 0x0576 label_0D32: // Incoming jump from 0x0D1A, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[2] // { // @0D35 stack[-1] // @0D36 stack[-2] // } 0D32 5B JUMPDEST 0D33 60 PUSH1 0x0c 0D35 55 SSTORE 0D36 56 *JUMP // Stack delta = -2 // Outputs[1] { @0D35 storage[0x0c] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0D37: // Incoming jump from 0x03E5 // Inputs[4] // { // @0D3A storage[0x0b] // @0D3B msg.sender // @0D41 stack[-2] // @0D43 stack[-1] // } 0D37 5B JUMPDEST 0D38 60 PUSH1 0x0b 0D3A 54 SLOAD 0D3B 33 CALLER 0D3C 90 SWAP1 0D3D 61 PUSH2 0x0d4a 0D40 90 SWAP1 0D41 84 DUP5 0D42 90 SWAP1 0D43 84 DUP5 0D44 90 SWAP1 0D45 84 DUP5 0D46 61 PUSH2 0x0e0a 0D49 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0D3C stack[0] = msg.sender // @0D40 stack[1] = 0x0d4a // @0D42 stack[2] = stack[-2] // @0D44 stack[3] = stack[-1] // @0D44 stack[4] = storage[0x0b] // @0D45 stack[5] = msg.sender // } // Block ends with call to 0x0e0a, returns to 0x0D4A label_0D4A: // Incoming return from call to 0x0E0A at 0x0D49 // Inputs[1] { @0D4E stack[-1] } 0D4A 5B JUMPDEST 0D4B 61 PUSH2 0x0d67 0D4E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0d67, if stack[-1] label_0D4F: // Incoming jump from 0x0D4E, if not stack[-1] // Inputs[3] // { // @0D51 memory[0x40:0x60] // @0D61 memory[0x40:0x60] // @0D66 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0D4F 60 PUSH1 0x40 0D51 51 MLOAD 0D52 63 PUSH4 0x09bde339 0D57 60 PUSH1 0xe0 0D59 1B SHL 0D5A 81 DUP2 0D5B 52 MSTORE 0D5C 60 PUSH1 0x04 0D5E 01 ADD 0D5F 60 PUSH1 0x40 0D61 51 MLOAD 0D62 80 DUP1 0D63 91 SWAP2 0D64 03 SUB 0D65 90 SWAP1 0D66 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0D5B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x09bde339 << 0xe0 // @0D66 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0D67: // Incoming jump from 0x0D4E, if stack[-1] // Inputs[1] { @0D6C storage[0x08] } 0D67 5B JUMPDEST 0D68 60 PUSH1 0x45 0D6A 60 PUSH1 0x08 0D6C 54 SLOAD 0D6D 11 GT 0D6E 15 ISZERO 0D6F 61 PUSH2 0x0d8b 0D72 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d8b, if !(storage[0x08] > 0x45) label_0D73: // Incoming jump from 0x0D72, if not !(storage[0x08] > 0x45) // Inputs[3] // { // @0D75 memory[0x40:0x60] // @0D85 memory[0x40:0x60] // @0D8A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0D73 60 PUSH1 0x40 0D75 51 MLOAD 0D76 63 PUSH4 0x52df9fe5 0D7B 60 PUSH1 0xe0 0D7D 1B SHL 0D7E 81 DUP2 0D7F 52 MSTORE 0D80 60 PUSH1 0x04 0D82 01 ADD 0D83 60 PUSH1 0x40 0D85 51 MLOAD 0D86 80 DUP1 0D87 91 SWAP2 0D88 03 SUB 0D89 90 SWAP1 0D8A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0D7F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x52df9fe5 << 0xe0 // @0D8A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0D8B: // Incoming jump from 0x0D72, if !(storage[0x08] > 0x45) // Inputs[3] // { // @0D8C msg.sender // @0D9A memory[0x00:0x40] // @0D9B storage[keccak256(memory[0x00:0x40])] // } 0D8B 5B JUMPDEST 0D8C 33 CALLER 0D8D 60 PUSH1 0x00 0D8F 90 SWAP1 0D90 81 DUP2 0D91 52 MSTORE 0D92 60 PUSH1 0x0a 0D94 60 PUSH1 0x20 0D96 52 MSTORE 0D97 60 PUSH1 0x40 0D99 90 SWAP1 0D9A 20 SHA3 0D9B 54 SLOAD 0D9C 60 PUSH1 0xff 0D9E 16 AND 0D9F 15 ISZERO 0DA0 61 PUSH2 0x0dbc 0DA3 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0D91 memory[0x00:0x20] = msg.sender // @0D96 memory[0x20:0x40] = 0x0a // } // Block ends with conditional jump to 0x0dbc, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_0DA4: // Incoming jump from 0x0DA3, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @0DA6 memory[0x40:0x60] // @0DB6 memory[0x40:0x60] // @0DBB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0DA4 60 PUSH1 0x40 0DA6 51 MLOAD 0DA7 63 PUSH4 0x1bbdf5c5 0DAC 60 PUSH1 0xe3 0DAE 1B SHL 0DAF 81 DUP2 0DB0 52 MSTORE 0DB1 60 PUSH1 0x04 0DB3 01 ADD 0DB4 60 PUSH1 0x40 0DB6 51 MLOAD 0DB7 80 DUP1 0DB8 91 SWAP2 0DB9 03 SUB 0DBA 90 SWAP1 0DBB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0DB0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1bbdf5c5 << 0xe3 // @0DBB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0DBC: // Incoming jump from 0x0DA3, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @0DBD msg.sender // @0DCB memory[0x00:0x40] // @0DCD storage[keccak256(memory[0x00:0x40])] // @0DD9 storage[0x09] // } 0DBC 5B JUMPDEST 0DBD 33 CALLER 0DBE 60 PUSH1 0x00 0DC0 90 SWAP1 0DC1 81 DUP2 0DC2 52 MSTORE 0DC3 60 PUSH1 0x0a 0DC5 60 PUSH1 0x20 0DC7 52 MSTORE 0DC8 60 PUSH1 0x40 0DCA 90 SWAP1 0DCB 20 SHA3 0DCC 80 DUP1 0DCD 54 SLOAD 0DCE 60 PUSH1 0xff 0DD0 19 NOT 0DD1 16 AND 0DD2 60 PUSH1 0x01 0DD4 17 OR 0DD5 90 SWAP1 0DD6 55 SSTORE 0DD7 60 PUSH1 0x09 0DD9 54 SLOAD 0DDA 15 ISZERO 0DDB 61 PUSH2 0x0df4 0DDE 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @0DC2 memory[0x00:0x20] = msg.sender // @0DC7 memory[0x20:0x40] = 0x0a // @0DD6 storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with conditional jump to 0x0df4, if !storage[0x09] label_0DDF: // Incoming jump from 0x0DDE, if not !storage[0x09] // Inputs[1] { @0DE2 storage[0x09] } 0DDF 60 PUSH1 0x09 0DE1 80 DUP1 0DE2 54 SLOAD 0DE3 90 SWAP1 0DE4 60 PUSH1 0x00 0DE6 61 PUSH2 0x0dee 0DE9 83 DUP4 0DEA 61 PUSH2 0x16db 0DED 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0DE3 stack[0] = storage[0x09] // @0DE3 stack[1] = 0x09 // @0DE4 stack[2] = 0x00 // @0DE6 stack[3] = 0x0dee // @0DE9 stack[4] = storage[0x09] // } // Block ends with call to 0x16db, returns to 0x0DEE label_0DEE: // Incoming return from call to 0x16DB at 0x0DED // Inputs[3] // { // @0DEF stack[-3] // @0DEF stack[-1] // @0DF0 stack[-2] // } 0DEE 5B JUMPDEST 0DEF 91 SWAP2 0DF0 90 SWAP1 0DF1 50 POP 0DF2 55 SSTORE 0DF3 50 POP // Stack delta = -4 // Outputs[1] { @0DF2 storage[stack[-3]] = stack[-1] } // Block continues label_0DF4: // Incoming jump from 0x0DF3 // Incoming jump from 0x0DDE, if !storage[0x09] // Inputs[2] // { // @0DF8 storage[0x08] // @0DFD msg.sender // } 0DF4 5B JUMPDEST 0DF5 60 PUSH1 0x08 0DF7 80 DUP1 0DF8 54 SLOAD 0DF9 61 PUSH2 0x093a 0DFC 91 SWAP2 0DFD 33 CALLER 0DFE 91 SWAP2 0DFF 90 SWAP1 0E00 60 PUSH1 0x00 0E02 61 PUSH2 0x0a6f 0E05 83 DUP4 0E06 61 PUSH2 0x15a9 0E09 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @0DFC stack[0] = 0x093a // @0DFE stack[1] = msg.sender // @0DFF stack[2] = storage[0x08] // @0DFF stack[3] = 0x08 // @0E00 stack[4] = 0x00 // @0E02 stack[5] = 0x0a6f // @0E05 stack[6] = storage[0x08] // } // Block ends with call to 0x15a9, returns to 0x0A6F label_0E0A: // Incoming call from 0x0D49, returns to 0x0D4A // Incoming call from 0x09C1, returns to 0x09C2 // Inputs[1] { @0E0D stack[-3] } 0E0A 5B JUMPDEST 0E0B 60 PUSH1 0x00 0E0D 83 DUP4 0E0E 15 ISZERO 0E0F 61 PUSH2 0x0e46 0E12 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E0B stack[0] = 0x00 } // Block ends with conditional jump to 0x0e46, if !stack[-3] label_0E13: // Incoming jump from 0x0E12, if not !stack[-3] // Inputs[5] // { // @0E13 stack[-4] // @0E17 stack[-5] // @0E1C msg.data[stack[-5]:stack[-5] + 0x20] // @0E1E stack[-2] // @0E30 memory[0x00:0x40] // } 0E13 83 DUP4 0E14 60 PUSH1 0x05 0E16 1B SHL 0E17 85 DUP6 0E18 01 ADD 0E19 85 DUP6 0E1A 5B JUMPDEST 0E1B 80 DUP1 0E1C 35 CALLDATALOAD 0E1D 80 DUP1 0E1E 85 DUP6 0E1F 11 GT 0E20 60 PUSH1 0x05 0E22 1B SHL 0E23 94 SWAP5 0E24 85 DUP6 0E25 52 MSTORE 0E26 60 PUSH1 0x20 0E28 94 SWAP5 0E29 85 DUP6 0E2A 18 XOR 0E2B 52 MSTORE 0E2C 60 PUSH1 0x40 0E2E 60 PUSH1 0x00 0E30 20 SHA3 0E31 93 SWAP4 0E32 01 ADD 0E33 81 DUP2 0E34 81 DUP2 0E35 10 LT 0E36 61 PUSH2 0x0e3e 0E39 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @0E18 stack[0] = stack[-5] + (stack[-4] << 0x05) // @0E25 memory[(stack[-2] > msg.data[stack[-5]:stack[-5] + 0x20]) << 0x05:(stack[-2] > msg.data[stack[-5]:stack[-5] + 0x20]) << 0x05 + 0x20] = stack[-2] // @0E2B memory[0x20 ~ ((stack[-2] > msg.data[stack[-5]:stack[-5] + 0x20]) << 0x05):0x20 ~ ((stack[-2] > msg.data[stack[-5]:stack[-5] + 0x20]) << 0x05) + 0x20] = msg.data[stack[-5]:stack[-5] + 0x20] // @0E31 stack[-2] = keccak256(memory[0x00:0x40]) // @0E32 stack[1] = 0x20 + stack[-5] // } // Block ends with conditional jump to 0x0e3e, if 0x20 + stack[-5] < stack[-5] + (stack[-4] << 0x05) label_0E3A: // Incoming jump from 0x0E39, if not 0x20 + stack[-1] < stack[-2] // Incoming jump from 0x0E39, if not 0x20 + stack[-5] < stack[-5] + (stack[-4] << 0x05) 0E3A 61 PUSH2 0x0e43 0E3D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e43 label_0E3E: // Incoming jump from 0x0E39, if 0x20 + stack[-1] < stack[-2] // Incoming jump from 0x0E39, if 0x20 + stack[-5] < stack[-5] + (stack[-4] << 0x05) 0E3E 5B JUMPDEST 0E3F 61 PUSH2 0x0e1a 0E42 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e1a label_0E43: // Incoming jump from 0x0E3D 0E43 5B JUMPDEST 0E44 50 POP 0E45 50 POP // Stack delta = -2 // Block continues label_0E46: // Incoming jump from 0x0E45 // Incoming jump from 0x0E12, if !stack[-3] // Inputs[4] // { // @0E48 stack[-2] // @0E48 stack[-3] // @0E49 stack[-6] // @0E4A stack[-5] // } 0E46 5B JUMPDEST 0E47 50 POP 0E48 14 EQ 0E49 92 SWAP3 0E4A 91 SWAP2 0E4B 50 POP 0E4C 50 POP 0E4D 56 *JUMP // Stack delta = -5 // Outputs[1] { @0E49 stack[-6] = stack[-2] == stack[-3] } // Block ends with unconditional jump to stack[-6] label_0E4E: // Incoming jump from 0x0A77 // Inputs[1] { @0E57 stack[-2] } 0E4E 5B JUMPDEST 0E4F 60 PUSH1 0x01 0E51 60 PUSH1 0x01 0E53 60 PUSH1 0xa0 0E55 1B SHL 0E56 03 SUB 0E57 82 DUP3 0E58 16 AND 0E59 61 PUSH2 0x0e98 0E5C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e98, if stack[-2] & (0x01 << 0xa0) - 0x01 label_0E5D: // Incoming jump from 0x0E5C, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0E5F memory[0x40:0x60] } 0E5D 60 PUSH1 0x40 0E5F 51 MLOAD 0E60 62 PUSH3 0x461bcd 0E64 60 PUSH1 0xe5 0E66 1B SHL 0E67 81 DUP2 0E68 52 MSTORE 0E69 60 PUSH1 0x20 0E6B 60 PUSH1 0x04 0E6D 82 DUP3 0E6E 01 ADD 0E6F 52 MSTORE 0E70 60 PUSH1 0x11 0E72 60 PUSH1 0x24 0E74 82 DUP3 0E75 01 ADD 0E76 52 MSTORE 0E77 70 PUSH17 0x1253959053125117d49150d25412515395 0E89 60 PUSH1 0x7a 0E8B 1B SHL 0E8C 60 PUSH1 0x44 0E8E 82 DUP3 0E8F 01 ADD 0E90 52 MSTORE 0E91 60 PUSH1 0x64 0E93 01 ADD 0E94 61 PUSH2 0x0576 0E97 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0E68 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E6F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E76 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x11 // @0E90 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1253959053125117d49150d25412515395 << 0x7a // @0E93 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0576 label_0E98: // Incoming jump from 0x0E5C, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0E9B stack[-1] // @0EA6 memory[0x00:0x40] // @0EA7 storage[keccak256(memory[0x00:0x40])] // } 0E98 5B JUMPDEST 0E99 60 PUSH1 0x00 0E9B 81 DUP2 0E9C 81 DUP2 0E9D 52 MSTORE 0E9E 60 PUSH1 0x02 0EA0 60 PUSH1 0x20 0EA2 52 MSTORE 0EA3 60 PUSH1 0x40 0EA5 90 SWAP1 0EA6 20 SHA3 0EA7 54 SLOAD 0EA8 60 PUSH1 0x01 0EAA 60 PUSH1 0x01 0EAC 60 PUSH1 0xa0 0EAE 1B SHL 0EAF 03 SUB 0EB0 16 AND 0EB1 15 ISZERO 0EB2 61 PUSH2 0x0eee 0EB5 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0E9D memory[0x00:0x20] = stack[-1] // @0EA2 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x0eee, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_0EB6: // Incoming jump from 0x0EB5, if not !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0EB8 memory[0x40:0x60] } 0EB6 60 PUSH1 0x40 0EB8 51 MLOAD 0EB9 62 PUSH3 0x461bcd 0EBD 60 PUSH1 0xe5 0EBF 1B SHL 0EC0 81 DUP2 0EC1 52 MSTORE 0EC2 60 PUSH1 0x20 0EC4 60 PUSH1 0x04 0EC6 82 DUP3 0EC7 01 ADD 0EC8 52 MSTORE 0EC9 60 PUSH1 0x0e 0ECB 60 PUSH1 0x24 0ECD 82 DUP3 0ECE 01 ADD 0ECF 52 MSTORE 0ED0 6D PUSH14 0x1053149150511657d35253951151 0EDF 60 PUSH1 0x92 0EE1 1B SHL 0EE2 60 PUSH1 0x44 0EE4 82 DUP3 0EE5 01 ADD 0EE6 52 MSTORE 0EE7 60 PUSH1 0x64 0EE9 01 ADD 0EEA 61 PUSH2 0x0576 0EED 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0EC1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EC8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0ECF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @0EE6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1053149150511657d35253951151 << 0x92 // @0EE9 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0576 label_0EEE: // Incoming jump from 0x0EB5, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[9] // { // @0EF7 stack[-2] // @0F09 memory[0x00:0x40] // @0F0B storage[keccak256(memory[0x00:0x40])] // @0F11 stack[-1] // @0F1B memory[0x00:0x40] // @0F1D storage[keccak256(memory[0x00:0x40])] // @0F2C memory[0x40:0x60] // @0F55 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0F58 stack[-3] // } 0EEE 5B JUMPDEST 0EEF 60 PUSH1 0x01 0EF1 60 PUSH1 0x01 0EF3 60 PUSH1 0xa0 0EF5 1B SHL 0EF6 03 SUB 0EF7 82 DUP3 0EF8 16 AND 0EF9 60 PUSH1 0x00 0EFB 81 DUP2 0EFC 81 DUP2 0EFD 52 MSTORE 0EFE 60 PUSH1 0x03 0F00 60 PUSH1 0x20 0F02 90 SWAP1 0F03 81 DUP2 0F04 52 MSTORE 0F05 60 PUSH1 0x40 0F07 80 DUP1 0F08 83 DUP4 0F09 20 SHA3 0F0A 80 DUP1 0F0B 54 SLOAD 0F0C 60 PUSH1 0x01 0F0E 01 ADD 0F0F 90 SWAP1 0F10 55 SSTORE 0F11 84 DUP5 0F12 83 DUP4 0F13 52 MSTORE 0F14 60 PUSH1 0x02 0F16 90 SWAP1 0F17 91 SWAP2 0F18 52 MSTORE 0F19 80 DUP1 0F1A 82 DUP3 0F1B 20 SHA3 0F1C 80 DUP1 0F1D 54 SLOAD 0F1E 60 PUSH1 0x01 0F20 60 PUSH1 0x01 0F22 60 PUSH1 0xa0 0F24 1B SHL 0F25 03 SUB 0F26 19 NOT 0F27 16 AND 0F28 84 DUP5 0F29 17 OR 0F2A 90 SWAP1 0F2B 55 SSTORE 0F2C 51 MLOAD 0F2D 83 DUP4 0F2E 92 SWAP3 0F2F 91 SWAP2 0F30 90 SWAP1 0F31 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0F52 90 SWAP1 0F53 82 DUP3 0F54 90 SWAP1 0F55 A4 LOG4 0F56 50 POP 0F57 50 POP 0F58 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0EFD memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0F04 memory[0x20:0x40] = 0x03 // @0F10 storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // @0F13 memory[0x00:0x20] = stack[-1] // @0F18 memory[0x20:0x40] = 0x02 // @0F2B storage[keccak256(memory[0x00:0x40])] = (stack[-2] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @0F55 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1]]); // } // Block ends with unconditional jump to stack[-3] label_0F59: // Incoming call from 0x0CE1, returns to 0x0CE2 // Inputs[1] { @0F61 stack[-1] } 0F59 5B JUMPDEST 0F5A 60 PUSH1 0x60 0F5C 60 PUSH1 0x00 0F5E 61 PUSH2 0x0f66 0F61 83 DUP4 0F62 61 PUSH2 0x0ff6 0F65 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F5A stack[0] = 0x60 // @0F5C stack[1] = 0x00 // @0F5E stack[2] = 0x0f66 // @0F61 stack[3] = stack[-1] // } // Block ends with call to 0x0ff6, returns to 0x0F66 label_0F66: // Incoming return from call to 0x0FF6 at 0x0F65 // Inputs[2] // { // @0F69 stack[-1] // @0F6A stack[-2] // } 0F66 5B JUMPDEST 0F67 60 PUSH1 0x01 0F69 01 ADD 0F6A 90 SWAP1 0F6B 50 POP 0F6C 60 PUSH1 0x00 0F6E 81 DUP2 0F6F 67 PUSH8 0xffffffffffffffff 0F78 81 DUP2 0F79 11 GT 0F7A 15 ISZERO 0F7B 61 PUSH2 0x0f86 0F7E 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0F6A stack[-2] = 0x01 + stack[-1] // @0F6C stack[-1] = 0x00 // @0F6E stack[0] = 0x01 + stack[-1] // } // Block ends with conditional jump to 0x0f86, if !(0x01 + stack[-1] > 0xffffffffffffffff) label_0F7F: // Incoming jump from 0x0F7E, if not !(0x01 + stack[-1] > 0xffffffffffffffff) 0F7F 61 PUSH2 0x0f86 0F82 61 PUSH2 0x12b8 0F85 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F7F stack[0] = 0x0f86 } // Block ends with unconditional jump to 0x12b8 label_0F86: // Incoming jump from 0x0F7E, if !(0x01 + stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @0F89 memory[0x40:0x60] // @0F8A stack[-1] // } 0F86 5B JUMPDEST 0F87 60 PUSH1 0x40 0F89 51 MLOAD 0F8A 90 SWAP1 0F8B 80 DUP1 0F8C 82 DUP3 0F8D 52 MSTORE 0F8E 80 DUP1 0F8F 60 PUSH1 0x1f 0F91 01 ADD 0F92 60 PUSH1 0x1f 0F94 19 NOT 0F95 16 AND 0F96 60 PUSH1 0x20 0F98 01 ADD 0F99 82 DUP3 0F9A 01 ADD 0F9B 60 PUSH1 0x40 0F9D 52 MSTORE 0F9E 80 DUP1 0F9F 15 ISZERO 0FA0 61 PUSH2 0x0fb0 0FA3 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0F8A stack[-1] = memory[0x40:0x60] // @0F8A stack[0] = stack[-1] // @0F8D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0F9D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x0fb0, if !stack[-1] label_0FA4: // Incoming jump from 0x0FA3, if not !stack[-1] // Inputs[7] // { // @0FA6 stack[-2] // @0FA8 stack[-1] // @0FAA msg.data.length // @0FAC msg.data[msg.data.length:msg.data.length + stack[-1]] // @0FB2 stack[-3] // @0FB4 stack[-4] // @0FD5 stack[-6] // } 0FA4 60 PUSH1 0x20 0FA6 82 DUP3 0FA7 01 ADD 0FA8 81 DUP2 0FA9 80 DUP1 0FAA 36 CALLDATASIZE 0FAB 83 DUP4 0FAC 37 CALLDATACOPY 0FAD 01 ADD 0FAE 90 SWAP1 0FAF 50 POP 0FB0 5B JUMPDEST 0FB1 50 POP 0FB2 90 SWAP1 0FB3 50 POP 0FB4 81 DUP2 0FB5 81 DUP2 0FB6 01 ADD 0FB7 60 PUSH1 0x20 0FB9 01 ADD 0FBA 5B JUMPDEST 0FBB 60 PUSH1 0x00 0FBD 19 NOT 0FBE 01 ADD 0FBF 6F PUSH16 0x181899199a1a9b1b9c1cb0b131b232b3 0FD0 60 PUSH1 0x81 0FD2 1B SHL 0FD3 60 PUSH1 0x0a 0FD5 86 DUP7 0FD6 06 MOD 0FD7 1A BYTE 0FD8 81 DUP2 0FD9 53 MSTORE8 0FDA 60 PUSH1 0x0a 0FDC 85 DUP6 0FDD 04 DIV 0FDE 94 SWAP5 0FDF 50 POP 0FE0 84 DUP5 0FE1 61 PUSH2 0x0fe9 0FE4 57 *JUMPI // Stack delta = -1 // Outputs[5] // { // @0FAC memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @0FB2 stack[-3] = stack[-2] // @0FBE stack[-2] = ~0x00 + 0x20 + stack[-2] + stack[-4] // @0FD9 memory[~0x00 + 0x20 + stack[-2] + stack[-4]:~0x00 + 0x20 + stack[-2] + stack[-4] + 0x01] = byte(0x181899199a1a9b1b9c1cb0b131b232b3 << 0x81, stack[-6] % 0x0a) // @0FDE stack[-6] = stack[-6] / 0x0a // } // Block ends with conditional jump to 0x0fe9, if stack[-6] / 0x0a label_0FE5: // Incoming jump from 0x0FE4, if not stack[-5] / 0x0a // Incoming jump from 0x0FE4, if not stack[-6] / 0x0a // Incoming jump from 0x0FE4, if not stack[-6] / 0x0a 0FE5 61 PUSH2 0x0fee 0FE8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fee label_0FE9: // Incoming jump from 0x0FE4, if stack[-5] / 0x0a // Incoming jump from 0x0FE4, if stack[-6] / 0x0a // Incoming jump from 0x0FE4, if stack[-6] / 0x0a 0FE9 5B JUMPDEST 0FEA 61 PUSH2 0x0fba 0FED 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fba label_0FEE: // Incoming jump from 0x0FE8 // Inputs[3] // { // @0FF0 stack[-2] // @0FF0 stack[-6] // @0FF1 stack[-5] // } 0FEE 5B JUMPDEST 0FEF 50 POP 0FF0 93 SWAP4 0FF1 92 SWAP3 0FF2 50 POP 0FF3 50 POP 0FF4 50 POP 0FF5 56 *JUMP // Stack delta = -5 // Outputs[1] { @0FF0 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_0FF6: // Incoming call from 0x0F65, returns to 0x0F66 // Inputs[1] { @1011 stack[-1] } 0FF6 5B JUMPDEST 0FF7 60 PUSH1 0x00 0FF9 80 DUP1 0FFA 72 PUSH19 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f01 100E 60 PUSH1 0x40 1010 1B SHL 1011 83 DUP4 1012 10 LT 1013 61 PUSH2 0x1035 1016 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0FF7 stack[0] = 0x00 // @0FF9 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1035, if stack[-1] < 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f01 << 0x40 label_1017: // Incoming jump from 0x1016, if not stack[-1] < 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f01 << 0x40 // Inputs[2] // { // @102E stack[-3] // @1034 stack[-1] // } 1017 72 PUSH19 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f01 102B 60 PUSH1 0x40 102D 1B SHL 102E 83 DUP4 102F 04 DIV 1030 92 SWAP3 1031 50 POP 1032 60 PUSH1 0x40 1034 01 ADD 1035 5B JUMPDEST 1036 6D PUSH14 0x04ee2d6d415b85acef8100000000 1045 83 DUP4 1046 10 LT 1047 61 PUSH2 0x1061 104A 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1030 stack[-3] = stack[-3] / (0x184f03e93ff9f4daa797ed6e38ed64bf6a1f01 << 0x40) // @1034 stack[-1] = 0x40 + stack[-1] // } // Block ends with conditional jump to 0x1061, if stack[-3] / (0x184f03e93ff9f4daa797ed6e38ed64bf6a1f01 << 0x40) < 0x04ee2d6d415b85acef8100000000 label_104B: // Incoming jump from 0x104A, if not stack[-3] / (0x184f03e93ff9f4daa797ed6e38ed64bf6a1f01 << 0x40) < 0x04ee2d6d415b85acef8100000000 // Incoming jump from 0x104A, if not stack[-3] < 0x04ee2d6d415b85acef8100000000 // Inputs[2] // { // @105A stack[-3] // @1060 stack[-1] // } 104B 6D PUSH14 0x04ee2d6d415b85acef8100000000 105A 83 DUP4 105B 04 DIV 105C 92 SWAP3 105D 50 POP 105E 60 PUSH1 0x20 1060 01 ADD 1061 5B JUMPDEST 1062 66 PUSH7 0x2386f26fc10000 106A 83 DUP4 106B 10 LT 106C 61 PUSH2 0x107f 106F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @105C stack[-3] = stack[-3] / 0x04ee2d6d415b85acef8100000000 // @1060 stack[-1] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x107f, if stack[-3] / 0x04ee2d6d415b85acef8100000000 < 0x2386f26fc10000 label_1070: // Incoming jump from 0x106F, if not stack[-3] / 0x04ee2d6d415b85acef8100000000 < 0x2386f26fc10000 // Incoming jump from 0x106F, if not stack[-3] < 0x2386f26fc10000 // Inputs[2] // { // @1078 stack[-3] // @107E stack[-1] // } 1070 66 PUSH7 0x2386f26fc10000 1078 83 DUP4 1079 04 DIV 107A 92 SWAP3 107B 50 POP 107C 60 PUSH1 0x10 107E 01 ADD 107F 5B JUMPDEST 1080 63 PUSH4 0x05f5e100 1085 83 DUP4 1086 10 LT 1087 61 PUSH2 0x1097 108A 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @107A stack[-3] = stack[-3] / 0x2386f26fc10000 // @107E stack[-1] = 0x10 + stack[-1] // } // Block ends with conditional jump to 0x1097, if stack[-3] / 0x2386f26fc10000 < 0x05f5e100 label_108B: // Incoming jump from 0x108A, if not stack[-3] / 0x2386f26fc10000 < 0x05f5e100 // Incoming jump from 0x108A, if not stack[-3] < 0x05f5e100 // Inputs[2] // { // @1090 stack[-3] // @1096 stack[-1] // } 108B 63 PUSH4 0x05f5e100 1090 83 DUP4 1091 04 DIV 1092 92 SWAP3 1093 50 POP 1094 60 PUSH1 0x08 1096 01 ADD 1097 5B JUMPDEST 1098 61 PUSH2 0x2710 109B 83 DUP4 109C 10 LT 109D 61 PUSH2 0x10ab 10A0 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1092 stack[-3] = stack[-3] / 0x05f5e100 // @1096 stack[-1] = 0x08 + stack[-1] // } // Block ends with conditional jump to 0x10ab, if stack[-3] / 0x05f5e100 < 0x2710 label_10A1: // Incoming jump from 0x10A0, if not stack[-3] / 0x05f5e100 < 0x2710 // Incoming jump from 0x10A0, if not stack[-3] < 0x2710 // Inputs[2] // { // @10A4 stack[-3] // @10AA stack[-1] // } 10A1 61 PUSH2 0x2710 10A4 83 DUP4 10A5 04 DIV 10A6 92 SWAP3 10A7 50 POP 10A8 60 PUSH1 0x04 10AA 01 ADD 10AB 5B JUMPDEST 10AC 60 PUSH1 0x64 10AE 83 DUP4 10AF 10 LT 10B0 61 PUSH2 0x10bd 10B3 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @10A6 stack[-3] = stack[-3] / 0x2710 // @10AA stack[-1] = 0x04 + stack[-1] // } // Block ends with conditional jump to 0x10bd, if stack[-3] / 0x2710 < 0x64 label_10B4: // Incoming jump from 0x10B3, if not stack[-3] / 0x2710 < 0x64 // Incoming jump from 0x10B3, if not stack[-3] < 0x64 // Inputs[2] // { // @10B6 stack[-3] // @10BC stack[-1] // } 10B4 60 PUSH1 0x64 10B6 83 DUP4 10B7 04 DIV 10B8 92 SWAP3 10B9 50 POP 10BA 60 PUSH1 0x02 10BC 01 ADD 10BD 5B JUMPDEST 10BE 60 PUSH1 0x0a 10C0 83 DUP4 10C1 10 LT 10C2 61 PUSH2 0x0460 10C5 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @10B8 stack[-3] = stack[-3] / 0x64 // @10BC stack[-1] = 0x02 + stack[-1] // } // Block ends with conditional jump to 0x0460, if stack[-3] / 0x64 < 0x0a label_10C6: // Incoming jump from 0x10C5, if not stack[-3] < 0x0a // Incoming jump from 0x10C5, if not stack[-3] / 0x64 < 0x0a // Inputs[3] // { // @10C8 stack[-1] // @10C9 stack[-4] // @10CA stack[-3] // } 10C6 60 PUSH1 0x01 10C8 01 ADD 10C9 92 SWAP3 10CA 91 SWAP2 10CB 50 POP 10CC 50 POP 10CD 56 *JUMP // Stack delta = -3 // Outputs[1] { @10C9 stack[-4] = 0x01 + stack[-1] } // Block ends with unconditional jump to stack[-4] label_10CE: // Incoming jump from 0x09AA // Inputs[2] // { // @10CF stack[-3] // @10D1 storage[stack[-3]] // } 10CE 5B JUMPDEST 10CF 82 DUP3 10D0 80 DUP1 10D1 54 SLOAD 10D2 61 PUSH2 0x10da 10D5 90 SWAP1 10D6 61 PUSH2 0x14fe 10D9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10CF stack[0] = stack[-3] // @10D5 stack[1] = 0x10da // @10D5 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x14fe, returns to 0x10DA label_10DA: // Incoming return from call to 0x14FE at 0x10D9 // Inputs[5] // { // @10DB stack[-2] // @10DB stack[-1] // @10E3 memory[0x00:0x20] // @10EE stack[-4] // @10EF stack[-3] // } 10DA 5B JUMPDEST 10DB 90 SWAP1 10DC 60 PUSH1 0x00 10DE 52 MSTORE 10DF 60 PUSH1 0x20 10E1 60 PUSH1 0x00 10E3 20 SHA3 10E4 90 SWAP1 10E5 60 PUSH1 0x1f 10E7 01 ADD 10E8 60 PUSH1 0x20 10EA 90 SWAP1 10EB 04 DIV 10EC 81 DUP2 10ED 01 ADD 10EE 92 SWAP3 10EF 82 DUP3 10F0 61 PUSH2 0x10fc 10F3 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @10DE memory[0x00:0x20] = stack[-2] // @10E4 stack[-2] = keccak256(memory[0x00:0x20]) // @10EE stack[-1] = stack[-4] // @10EE stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x10fc, if stack[-3] label_10F4: // Incoming jump from 0x10F3, if not stack[-3] // Inputs[1] { @10F6 stack[-5] } 10F4 60 PUSH1 0x00 10F6 85 DUP6 10F7 55 SSTORE 10F8 61 PUSH2 0x1142 10FB 56 *JUMP // Stack delta = +0 // Outputs[1] { @10F7 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x1142 label_10FC: // Incoming jump from 0x10F3, if stack[-3] // Inputs[1] { @10FD stack[-3] } 10FC 5B JUMPDEST 10FD 82 DUP3 10FE 60 PUSH1 0x1f 1100 10 LT 1101 61 PUSH2 0x1115 1104 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1115, if 0x1f < stack[-3] label_1105: // Incoming jump from 0x1104, if not 0x1f < stack[-3] // Inputs[4] // { // @1105 stack[-1] // @1106 memory[stack[-1]:stack[-1] + 0x20] // @110B stack[-3] // @110F stack[-5] // } 1105 80 DUP1 1106 51 MLOAD 1107 60 PUSH1 0xff 1109 19 NOT 110A 16 AND 110B 83 DUP4 110C 80 DUP1 110D 01 ADD 110E 17 OR 110F 85 DUP6 1110 55 SSTORE 1111 61 PUSH2 0x1142 1114 56 *JUMP // Stack delta = +0 // Outputs[1] { @1110 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x1142 label_1115: // Incoming jump from 0x1104, if 0x1f < stack[-3] // Inputs[2] // { // @1116 stack[-3] // @111C stack[-5] // } 1115 5B JUMPDEST 1116 82 DUP3 1117 80 DUP1 1118 01 ADD 1119 60 PUSH1 0x01 111B 01 ADD 111C 85 DUP6 111D 55 SSTORE 111E 82 DUP3 111F 15 ISZERO 1120 61 PUSH2 0x1142 1123 57 *JUMPI // Stack delta = +0 // Outputs[1] { @111D storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1142, if !stack[-3] label_1124: // Incoming jump from 0x1123, if not !stack[-3] // Inputs[2] // { // @1124 stack[-1] // @1124 stack[-3] // } 1124 91 SWAP2 1125 82 DUP3 1126 01 ADD 1127 5B JUMPDEST 1128 82 DUP3 1129 81 DUP2 112A 11 GT 112B 15 ISZERO 112C 61 PUSH2 0x1142 112F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1124 stack[-3] = stack[-1] // @1126 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1142, if !(stack[-1] + stack[-3] > stack[-1]) label_1130: // Incoming jump from 0x112F, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x112F, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @1130 stack[-3] // @1131 memory[stack[-3]:stack[-3] + 0x20] // @1132 stack[-2] // @1134 stack[-1] // } 1130 82 DUP3 1131 51 MLOAD 1132 82 DUP3 1133 55 SSTORE 1134 91 SWAP2 1135 60 PUSH1 0x20 1137 01 ADD 1138 91 SWAP2 1139 90 SWAP1 113A 60 PUSH1 0x01 113C 01 ADD 113D 90 SWAP1 113E 61 PUSH2 0x1127 1141 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1133 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1138 stack[-3] = 0x20 + stack[-3] // @113D stack[-2] = 0x01 + stack[-2] // @113D stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1127 label_1142: // Incoming jump from 0x112F, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x112F, if !(stack[-1] > stack[-3]) // Incoming jump from 0x10FB // Incoming jump from 0x1123, if !stack[-3] // Incoming jump from 0x1114 // Inputs[2] // { // @1147 stack[-4] // @1148 stack[-3] // } 1142 5B JUMPDEST 1143 50 POP 1144 61 PUSH2 0x114e 1147 92 SWAP3 1148 91 SWAP2 1149 50 POP 114A 61 PUSH2 0x1152 114D 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1147 stack[-4] = 0x114e // @1148 stack[-3] = stack[-4] // } // Block ends with call to 0x1152, returns to 0x114E label_114E: // Incoming jump from 0x115B, if !(stack[-2] > stack[-1]) // Incoming jump from 0x115B, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x1152 at 0x114D // Inputs[2] // { // @1150 stack[-2] // @1150 stack[-3] // } 114E 5B JUMPDEST 114F 50 POP 1150 90 SWAP1 1151 56 *JUMP // Stack delta = -2 // Outputs[1] { @1150 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1152: // Incoming call from 0x114D, returns to 0x114E // Inputs[2] // { // @1154 stack[-1] // @1155 stack[-2] // } 1152 5B JUMPDEST 1153 5B JUMPDEST 1154 80 DUP1 1155 82 DUP3 1156 11 GT 1157 15 ISZERO 1158 61 PUSH2 0x114e 115B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x114e, if !(stack[-2] > stack[-1]) label_115C: // Incoming jump from 0x115B, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x115B, if not !(stack[-2] > stack[-1]) // Inputs[1] { @115E stack[-1] } 115C 60 PUSH1 0x00 115E 81 DUP2 115F 55 SSTORE 1160 60 PUSH1 0x01 1162 01 ADD 1163 61 PUSH2 0x1153 1166 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @115F storage[stack[-1]] = 0x00 // @1162 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1153 label_1167: // Incoming call from 0x157B, returns to 0x119D // Incoming call from 0x119C, returns to 0x119D // Inputs[1] { @1171 stack[-1] } 1167 5B JUMPDEST 1168 60 PUSH1 0x01 116A 60 PUSH1 0x01 116C 60 PUSH1 0xe0 116E 1B SHL 116F 03 SUB 1170 19 NOT 1171 81 DUP2 1172 16 AND 1173 81 DUP2 1174 14 EQ 1175 61 PUSH2 0x117d 1178 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x117d, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1179: // Incoming jump from 0x1178, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @117C memory[0x00:0x00] } 1179 60 PUSH1 0x00 117B 80 DUP1 117C FD *REVERT // Stack delta = +0 // Outputs[1] { @117C revert(memory[0x00:0x00]); } // Block terminates label_117D: // Incoming jump from 0x1178, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @117F stack[-2] } 117D 5B JUMPDEST 117E 50 POP 117F 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1180: // Incoming call from 0x01D6, returns to 0x01D7 // Inputs[2] // { // @1185 stack[-1] // @1186 stack[-2] // } 1180 5B JUMPDEST 1181 60 PUSH1 0x00 1183 60 PUSH1 0x20 1185 82 DUP3 1186 84 DUP5 1187 03 SUB 1188 12 SLT 1189 15 ISZERO 118A 61 PUSH2 0x1192 118D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1181 stack[0] = 0x00 } // Block ends with conditional jump to 0x1192, if !(stack[-2] - stack[-1] i< 0x20) label_118E: // Incoming jump from 0x118D, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1191 memory[0x00:0x00] } 118E 60 PUSH1 0x00 1190 80 DUP1 1191 FD *REVERT // Stack delta = +0 // Outputs[1] { @1191 revert(memory[0x00:0x00]); } // Block terminates label_1192: // Incoming jump from 0x118D, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1193 stack[-2] // @1194 msg.data[stack[-2]:stack[-2] + 0x20] // } 1192 5B JUMPDEST 1193 81 DUP2 1194 35 CALLDATALOAD 1195 61 PUSH2 0x119d 1198 81 DUP2 1199 61 PUSH2 0x1167 119C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1194 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1195 stack[1] = 0x119d // @1198 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1167, returns to 0x119D label_119D: // Incoming return from call to 0x1220 at 0x127B // Incoming return from call to 0x1167 at 0x157B // Incoming return from call to 0x1167 at 0x119C // Inputs[3] // { // @119E stack[-1] // @119E stack[-5] // @119F stack[-4] // } 119D 5B JUMPDEST 119E 93 SWAP4 119F 92 SWAP3 11A0 50 POP 11A1 50 POP 11A2 50 POP 11A3 56 *JUMP // Stack delta = -4 // Outputs[1] { @119E stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_11A4: // Incoming call from 0x1629, returns to 0x162A // Incoming call from 0x11F2, returns to 0x11F3 // Inputs[1] { @11A8 stack[-3] } 11A4 5B JUMPDEST 11A5 60 PUSH1 0x00 11A7 5B JUMPDEST 11A8 83 DUP4 11A9 81 DUP2 11AA 10 LT 11AB 15 ISZERO 11AC 61 PUSH2 0x11bf 11AF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @11A5 stack[0] = 0x00 } // Block ends with conditional jump to 0x11bf, if !(0x00 < stack[-3]) label_11B0: // Incoming jump from 0x11AF, if not !(0x00 < stack[-3]) // Incoming jump from 0x11AF, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @11B0 stack[-2] // @11B1 stack[-1] // @11B3 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @11B4 stack[-3] // } 11B0 81 DUP2 11B1 81 DUP2 11B2 01 ADD 11B3 51 MLOAD 11B4 83 DUP4 11B5 82 DUP3 11B6 01 ADD 11B7 52 MSTORE 11B8 60 PUSH1 0x20 11BA 01 ADD 11BB 61 PUSH2 0x11a7 11BE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @11B7 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @11BA stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x11a7 label_11BF: // Incoming jump from 0x11AF, if !(0x00 < stack[-3]) // Incoming jump from 0x11AF, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @11C0 stack[-4] // @11C1 stack[-1] // } 11BF 5B JUMPDEST 11C0 83 DUP4 11C1 81 DUP2 11C2 11 GT 11C3 15 ISZERO 11C4 61 PUSH2 0x11ce 11C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11ce, if !(stack[-1] > stack[-4]) label_11C8: // Incoming jump from 0x11C7, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @11CA stack[-4] // @11CB stack[-3] // @11D3 stack[-5] // } 11C8 60 PUSH1 0x00 11CA 84 DUP5 11CB 84 DUP5 11CC 01 ADD 11CD 52 MSTORE 11CE 5B JUMPDEST 11CF 50 POP 11D0 50 POP 11D1 50 POP 11D2 50 POP 11D3 56 *JUMP // Stack delta = -5 // Outputs[1] { @11CD memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_11D4: // Incoming call from 0x0205, returns to 0x01E8 // Inputs[3] // { // @11D7 stack[-1] // @11DB stack[-2] // @11DC memory[stack[-2]:stack[-2] + 0x20] // } 11D4 5B JUMPDEST 11D5 60 PUSH1 0x20 11D7 81 DUP2 11D8 52 MSTORE 11D9 60 PUSH1 0x00 11DB 82 DUP3 11DC 51 MLOAD 11DD 80 DUP1 11DE 60 PUSH1 0x20 11E0 84 DUP5 11E1 01 ADD 11E2 52 MSTORE 11E3 61 PUSH2 0x11f3 11E6 81 DUP2 11E7 60 PUSH1 0x40 11E9 85 DUP6 11EA 01 ADD 11EB 60 PUSH1 0x20 11ED 87 DUP8 11EE 01 ADD 11EF 61 PUSH2 0x11a4 11F2 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @11D8 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @11D9 stack[0] = 0x00 // @11DC stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @11E2 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @11E3 stack[2] = 0x11f3 // @11E6 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @11EA stack[4] = stack[-1] + 0x40 // @11EE stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x11a4, returns to 0x11F3 label_11F3: // Incoming return from call to 0x11A4 at 0x11F2 // Inputs[5] // { // @11F6 stack[-1] // @11FB stack[-3] // @11FC stack[-2] // @1202 stack[-5] // @1203 stack[-4] // } 11F3 5B JUMPDEST 11F4 60 PUSH1 0x1f 11F6 01 ADD 11F7 60 PUSH1 0x1f 11F9 19 NOT 11FA 16 AND 11FB 91 SWAP2 11FC 90 SWAP1 11FD 91 SWAP2 11FE 01 ADD 11FF 60 PUSH1 0x40 1201 01 ADD 1202 92 SWAP3 1203 91 SWAP2 1204 50 POP 1205 50 POP 1206 56 *JUMP // Stack delta = -4 // Outputs[1] { @1202 stack[-5] = 0x40 + (~0x1f & 0x1f + stack[-1]) + stack[-3] } // Block ends with unconditional jump to stack[-5] label_1207: // Incoming call from 0x0330, returns to 0x0331 // Incoming call from 0x03A8, returns to 0x03A9 // Incoming call from 0x03C4, returns to 0x03C5 // Incoming call from 0x02F7, returns to 0x02F8 // Incoming call from 0x0213, returns to 0x0214 // Incoming call from 0x02A6, returns to 0x02A7 // Inputs[2] // { // @120C stack[-1] // @120D stack[-2] // } 1207 5B JUMPDEST 1208 60 PUSH1 0x00 120A 60 PUSH1 0x20 120C 82 DUP3 120D 84 DUP5 120E 03 SUB 120F 12 SLT 1210 15 ISZERO 1211 61 PUSH2 0x1219 1214 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1208 stack[0] = 0x00 } // Block ends with conditional jump to 0x1219, if !(stack[-2] - stack[-1] i< 0x20) label_1215: // Incoming jump from 0x1214, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1218 memory[0x00:0x00] } 1215 60 PUSH1 0x00 1217 80 DUP1 1218 FD *REVERT // Stack delta = +0 // Outputs[1] { @1218 revert(memory[0x00:0x00]); } // Block terminates label_1219: // Incoming jump from 0x1214, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @121B msg.data[stack[-2]:stack[-2] + 0x20] // @121B stack[-2] // @121C stack[-4] // @121D stack[-3] // } 1219 5B JUMPDEST 121A 50 POP 121B 35 CALLDATALOAD 121C 91 SWAP2 121D 90 SWAP1 121E 50 POP 121F 56 *JUMP // Stack delta = -3 // Outputs[1] { @121C stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1220: // Incoming call from 0x140F, returns to 0x1410 // Incoming call from 0x127B, returns to 0x119D // Incoming call from 0x12A7, returns to 0x12A8 // Incoming call from 0x1450, returns to 0x1451 // Incoming call from 0x14E6, returns to 0x14E7 // Incoming call from 0x14F4, returns to 0x14F5 // Incoming call from 0x145E, returns to 0x145F // Incoming call from 0x1299, returns to 0x129A // Incoming call from 0x1252, returns to 0x1253 // Inputs[2] // { // @1221 stack[-1] // @1222 msg.data[stack[-1]:stack[-1] + 0x20] // } 1220 5B JUMPDEST 1221 80 DUP1 1222 35 CALLDATALOAD 1223 60 PUSH1 0x01 1225 60 PUSH1 0x01 1227 60 PUSH1 0xa0 1229 1B SHL 122A 03 SUB 122B 81 DUP2 122C 16 AND 122D 81 DUP2 122E 14 EQ 122F 61 PUSH2 0x0aca 1232 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1222 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x0aca, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_1233: // Incoming jump from 0x1232, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1236 memory[0x00:0x00] } 1233 60 PUSH1 0x00 1235 80 DUP1 1236 FD *REVERT // Stack delta = +0 // Outputs[1] { @1236 revert(memory[0x00:0x00]); } // Block terminates label_1237: // Incoming call from 0x0254, returns to 0x0255 // Inputs[2] // { // @123D stack[-1] // @123E stack[-2] // } 1237 5B JUMPDEST 1238 60 PUSH1 0x00 123A 80 DUP1 123B 60 PUSH1 0x40 123D 83 DUP4 123E 85 DUP6 123F 03 SUB 1240 12 SLT 1241 15 ISZERO 1242 61 PUSH2 0x124a 1245 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1238 stack[0] = 0x00 // @123A stack[1] = 0x00 // } // Block ends with conditional jump to 0x124a, if !(stack[-2] - stack[-1] i< 0x40) label_1246: // Incoming jump from 0x1245, if not !(stack[-2] - stack[-1] i< 0x40) // 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 jump from 0x1245, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @124E stack[-3] } 124A 5B JUMPDEST 124B 61 PUSH2 0x1253 124E 83 DUP4 124F 61 PUSH2 0x1220 1252 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @124B stack[0] = 0x1253 // @124E stack[1] = stack[-3] // } // Block ends with call to 0x1220, returns to 0x1253 label_1253: // Incoming return from call to 0x1220 at 0x1252 // Inputs[5] // { // @1254 stack[-6] // @1254 stack[-1] // @1257 stack[-4] // @125B msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @125C stack[-5] // } 1253 5B JUMPDEST 1254 94 SWAP5 1255 60 PUSH1 0x20 1257 93 SWAP4 1258 90 SWAP1 1259 93 SWAP4 125A 01 ADD 125B 35 CALLDATALOAD 125C 93 SWAP4 125D 50 POP 125E 50 POP 125F 50 POP 1260 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1254 stack[-6] = stack[-1] // @125C stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_1261: // Incoming call from 0x034B, returns to 0x034C // Incoming call from 0x0269, returns to 0x026A // Incoming call from 0x02C1, returns to 0x02C2 // Inputs[2] // { // @1266 stack[-1] // @1267 stack[-2] // } 1261 5B JUMPDEST 1262 60 PUSH1 0x00 1264 60 PUSH1 0x20 1266 82 DUP3 1267 84 DUP5 1268 03 SUB 1269 12 SLT 126A 15 ISZERO 126B 61 PUSH2 0x1273 126E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1262 stack[0] = 0x00 } // Block ends with conditional jump to 0x1273, if !(stack[-2] - stack[-1] i< 0x20) label_126F: // Incoming jump from 0x126E, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1272 memory[0x00:0x00] } 126F 60 PUSH1 0x00 1271 80 DUP1 1272 FD *REVERT // Stack delta = +0 // Outputs[1] { @1272 revert(memory[0x00:0x00]); } // Block terminates label_1273: // Incoming jump from 0x126E, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1277 stack[-2] } 1273 5B JUMPDEST 1274 61 PUSH2 0x119d 1277 82 DUP3 1278 61 PUSH2 0x1220 127B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1274 stack[0] = 0x119d // @1277 stack[1] = stack[-2] // } // Block ends with call to 0x1220, returns to 0x119D label_127C: // Incoming call from 0x02E4, returns to 0x02E5 // Incoming call from 0x0293, returns to 0x0294 // Inputs[2] // { // @1284 stack[-1] // @1285 stack[-2] // } 127C 5B JUMPDEST 127D 60 PUSH1 0x00 127F 80 DUP1 1280 60 PUSH1 0x00 1282 60 PUSH1 0x60 1284 84 DUP5 1285 86 DUP7 1286 03 SUB 1287 12 SLT 1288 15 ISZERO 1289 61 PUSH2 0x1291 128C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @127D stack[0] = 0x00 // @127F stack[1] = 0x00 // @1280 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1291, if !(stack[-2] - stack[-1] i< 0x60) label_128D: // Incoming jump from 0x128C, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1290 memory[0x00:0x00] } 128D 60 PUSH1 0x00 128F 80 DUP1 1290 FD *REVERT // Stack delta = +0 // Outputs[1] { @1290 revert(memory[0x00:0x00]); } // Block terminates label_1291: // Incoming jump from 0x128C, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1295 stack[-4] } 1291 5B JUMPDEST 1292 61 PUSH2 0x129a 1295 84 DUP5 1296 61 PUSH2 0x1220 1299 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1292 stack[0] = 0x129a // @1295 stack[1] = stack[-4] // } // Block ends with call to 0x1220, returns to 0x129A label_129A: // Incoming return from call to 0x1220 at 0x1299 // Inputs[3] // { // @129B stack[-4] // @129B stack[-1] // @12A2 stack[-5] // } 129A 5B JUMPDEST 129B 92 SWAP3 129C 50 POP 129D 61 PUSH2 0x12a8 12A0 60 PUSH1 0x20 12A2 85 DUP6 12A3 01 ADD 12A4 61 PUSH2 0x1220 12A7 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @129B stack[-4] = stack[-1] // @129D stack[-1] = 0x12a8 // @12A3 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x1220, returns to 0x12A8 label_12A8: // Incoming return from call to 0x1220 at 0x12A7 // Inputs[8] // { // @12A9 stack[-1] // @12A9 stack[-3] // @12AD stack[-5] // @12AF msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @12B0 stack[-2] // @12B4 stack[-6] // @12B6 stack[-4] // @12B6 stack[-7] // } 12A8 5B JUMPDEST 12A9 91 SWAP2 12AA 50 POP 12AB 60 PUSH1 0x40 12AD 84 DUP5 12AE 01 ADD 12AF 35 CALLDATALOAD 12B0 90 SWAP1 12B1 50 POP 12B2 92 SWAP3 12B3 50 POP 12B4 92 SWAP3 12B5 50 POP 12B6 92 SWAP3 12B7 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @12B2 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @12B4 stack[-6] = stack[-1] // @12B6 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_12B8: // Incoming jump from 0x1345 // Incoming jump from 0x0F85 // Incoming jump from 0x131D // Inputs[1] { @12CD memory[0x00:0x24] } 12B8 5B JUMPDEST 12B9 63 PUSH4 0x4e487b71 12BE 60 PUSH1 0xe0 12C0 1B SHL 12C1 60 PUSH1 0x00 12C3 52 MSTORE 12C4 60 PUSH1 0x41 12C6 60 PUSH1 0x04 12C8 52 MSTORE 12C9 60 PUSH1 0x24 12CB 60 PUSH1 0x00 12CD FD *REVERT // Stack delta = +0 // Outputs[3] // { // @12C3 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @12C8 memory[0x04:0x24] = 0x41 // @12CD revert(memory[0x00:0x24]); // } // Block terminates label_12CE: // Incoming call from 0x030A, returns to 0x030B // Inputs[2] // { // @12D3 stack[-1] // @12D4 stack[-2] // } 12CE 5B JUMPDEST 12CF 60 PUSH1 0x00 12D1 60 PUSH1 0x20 12D3 82 DUP3 12D4 84 DUP5 12D5 03 SUB 12D6 12 SLT 12D7 15 ISZERO 12D8 61 PUSH2 0x12e0 12DB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12CF stack[0] = 0x00 } // Block ends with conditional jump to 0x12e0, if !(stack[-2] - stack[-1] i< 0x20) label_12DC: // Incoming jump from 0x12DB, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @12DF memory[0x00:0x00] } 12DC 60 PUSH1 0x00 12DE 80 DUP1 12DF FD *REVERT // Stack delta = +0 // Outputs[1] { @12DF revert(memory[0x00:0x00]); } // Block terminates label_12E0: // Incoming jump from 0x12DB, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @12E1 stack[-2] // @12E2 msg.data[stack[-2]:stack[-2] + 0x20] // } 12E0 5B JUMPDEST 12E1 81 DUP2 12E2 35 CALLDATALOAD 12E3 67 PUSH8 0xffffffffffffffff 12EC 80 DUP1 12ED 82 DUP3 12EE 11 GT 12EF 15 ISZERO 12F0 61 PUSH2 0x12f8 12F3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @12E2 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @12E3 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x12f8, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_12F4: // Incoming jump from 0x12F3, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @12F7 memory[0x00:0x00] } 12F4 60 PUSH1 0x00 12F6 80 DUP1 12F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @12F7 revert(memory[0x00:0x00]); } // Block terminates label_12F8: // Incoming jump from 0x12F3, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @12F9 stack[-2] // @12FA stack[-4] // @12FE stack[-5] // } 12F8 5B JUMPDEST 12F9 81 DUP2 12FA 84 DUP5 12FB 01 ADD 12FC 91 SWAP2 12FD 50 POP 12FE 84 DUP5 12FF 60 PUSH1 0x1f 1301 83 DUP4 1302 01 ADD 1303 12 SLT 1304 61 PUSH2 0x130c 1307 57 *JUMPI // Stack delta = +0 // Outputs[1] { @12FC stack[-2] = stack[-4] + stack[-2] } // Block ends with conditional jump to 0x130c, if stack[-4] + stack[-2] + 0x1f i< stack[-5] label_1308: // Incoming jump from 0x1307, if not stack[-4] + stack[-2] + 0x1f i< stack[-5] // Inputs[1] { @130B memory[0x00:0x00] } 1308 60 PUSH1 0x00 130A 80 DUP1 130B FD *REVERT // Stack delta = +0 // Outputs[1] { @130B revert(memory[0x00:0x00]); } // Block terminates label_130C: // Incoming jump from 0x1307, if stack[-4] + stack[-2] + 0x1f i< stack[-5] // Inputs[3] // { // @130D stack[-2] // @130E msg.data[stack[-2]:stack[-2] + 0x20] // @130F stack[-1] // } 130C 5B JUMPDEST 130D 81 DUP2 130E 35 CALLDATALOAD 130F 81 DUP2 1310 81 DUP2 1311 11 GT 1312 15 ISZERO 1313 61 PUSH2 0x131e 1316 57 *JUMPI // Stack delta = +1 // Outputs[1] { @130E stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x131e, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_1317: // Incoming jump from 0x1316, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) 1317 61 PUSH2 0x131e 131A 61 PUSH2 0x12b8 131D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1317 stack[0] = 0x131e } // Block ends with unconditional jump to 0x12b8 label_131E: // Incoming jump from 0x1316, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @1321 memory[0x40:0x60] // @1324 stack[-1] // @1333 stack[-2] // } 131E 5B JUMPDEST 131F 60 PUSH1 0x40 1321 51 MLOAD 1322 60 PUSH1 0x1f 1324 82 DUP3 1325 01 ADD 1326 60 PUSH1 0x1f 1328 19 NOT 1329 90 SWAP1 132A 81 DUP2 132B 16 AND 132C 60 PUSH1 0x3f 132E 01 ADD 132F 16 AND 1330 81 DUP2 1331 01 ADD 1332 90 SWAP1 1333 83 DUP4 1334 82 DUP3 1335 11 GT 1336 81 DUP2 1337 83 DUP4 1338 10 LT 1339 17 OR 133A 15 ISZERO 133B 61 PUSH2 0x1346 133E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1332 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) // @1332 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x1346, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) > stack[-2])) label_133F: // Incoming jump from 0x133E, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) > stack[-2])) 133F 61 PUSH2 0x1346 1342 61 PUSH2 0x12b8 1345 56 *JUMP // Stack delta = +1 // Outputs[1] { @133F stack[0] = 0x1346 } // Block ends with unconditional jump to 0x12b8 label_1346: // Incoming jump from 0x133E, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) > stack[-2])) // Inputs[5] // { // @1347 stack[-2] // @134B stack[-3] // @134C stack[-1] // @134E stack[-8] // @1352 stack[-5] // } 1346 5B JUMPDEST 1347 81 DUP2 1348 60 PUSH1 0x40 134A 52 MSTORE 134B 82 DUP3 134C 81 DUP2 134D 52 MSTORE 134E 87 DUP8 134F 60 PUSH1 0x20 1351 84 DUP5 1352 87 DUP8 1353 01 ADD 1354 01 ADD 1355 11 GT 1356 15 ISZERO 1357 61 PUSH2 0x135f 135A 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @134A memory[0x40:0x60] = stack[-2] // @134D memory[stack[-1]:stack[-1] + 0x20] = stack[-3] // } // Block ends with conditional jump to 0x135f, if !(stack[-5] + stack[-3] + 0x20 > stack[-8]) label_135B: // Incoming jump from 0x135A, if not !(stack[-5] + stack[-3] + 0x20 > stack[-8]) // Inputs[1] { @135E memory[0x00:0x00] } 135B 60 PUSH1 0x00 135D 80 DUP1 135E FD *REVERT // Stack delta = +0 // Outputs[1] { @135E revert(memory[0x00:0x00]); } // Block terminates label_135F: // Incoming jump from 0x135A, if !(stack[-5] + stack[-3] + 0x20 > stack[-8]) // Inputs[6] // { // @1360 stack[-3] // @1363 stack[-5] // @1367 stack[-1] // @1369 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + stack[-3]] // @1377 stack[-9] // @1378 stack[-8] // } 135F 5B JUMPDEST 1360 82 DUP3 1361 60 PUSH1 0x20 1363 86 DUP7 1364 01 ADD 1365 60 PUSH1 0x20 1367 83 DUP4 1368 01 ADD 1369 37 CALLDATACOPY 136A 60 PUSH1 0x00 136C 92 SWAP3 136D 81 DUP2 136E 01 ADD 136F 60 PUSH1 0x20 1371 01 ADD 1372 92 SWAP3 1373 90 SWAP1 1374 92 SWAP3 1375 52 MSTORE 1376 50 POP 1377 95 SWAP6 1378 94 SWAP5 1379 50 POP 137A 50 POP 137B 50 POP 137C 50 POP 137D 50 POP 137E 56 *JUMP // Stack delta = -8 // Outputs[3] // { // @1369 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-3]] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + stack[-3]] // @1375 memory[0x20 + stack[-1] + stack[-3]:0x20 + stack[-1] + stack[-3] + 0x20] = 0x00 // @1377 stack[-9] = stack[-1] // } // Block ends with unconditional jump to stack[-9] label_137F: // Incoming call from 0x031D, returns to 0x031E // Incoming call from 0x03E0, returns to 0x03E1 // Inputs[2] // { // @1385 stack[-1] // @1386 stack[-2] // } 137F 5B JUMPDEST 1380 60 PUSH1 0x00 1382 80 DUP1 1383 60 PUSH1 0x20 1385 83 DUP4 1386 85 DUP6 1387 03 SUB 1388 12 SLT 1389 15 ISZERO 138A 61 PUSH2 0x1392 138D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1380 stack[0] = 0x00 // @1382 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1392, if !(stack[-2] - stack[-1] i< 0x20) label_138E: // Incoming jump from 0x138D, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1391 memory[0x00:0x00] } 138E 60 PUSH1 0x00 1390 80 DUP1 1391 FD *REVERT // Stack delta = +0 // Outputs[1] { @1391 revert(memory[0x00:0x00]); } // Block terminates label_1392: // Incoming jump from 0x138D, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1393 stack[-3] // @1394 msg.data[stack[-3]:stack[-3] + 0x20] // } 1392 5B JUMPDEST 1393 82 DUP3 1394 35 CALLDATALOAD 1395 67 PUSH8 0xffffffffffffffff 139E 80 DUP1 139F 82 DUP3 13A0 11 GT 13A1 15 ISZERO 13A2 61 PUSH2 0x13aa 13A5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1394 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1395 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x13aa, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_13A6: // Incoming jump from 0x13A5, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @13A9 memory[0x00:0x00] } 13A6 60 PUSH1 0x00 13A8 80 DUP1 13A9 FD *REVERT // Stack delta = +0 // Outputs[1] { @13A9 revert(memory[0x00:0x00]); } // Block terminates label_13AA: // Incoming jump from 0x13A5, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @13AB stack[-2] // @13AC stack[-5] // @13B0 stack[-6] // } 13AA 5B JUMPDEST 13AB 81 DUP2 13AC 85 DUP6 13AD 01 ADD 13AE 91 SWAP2 13AF 50 POP 13B0 85 DUP6 13B1 60 PUSH1 0x1f 13B3 83 DUP4 13B4 01 ADD 13B5 12 SLT 13B6 61 PUSH2 0x13be 13B9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @13AE stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x13be, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_13BA: // Incoming jump from 0x13B9, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @13BD memory[0x00:0x00] } 13BA 60 PUSH1 0x00 13BC 80 DUP1 13BD FD *REVERT // Stack delta = +0 // Outputs[1] { @13BD revert(memory[0x00:0x00]); } // Block terminates label_13BE: // Incoming jump from 0x13B9, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @13BF stack[-2] // @13C0 msg.data[stack[-2]:stack[-2] + 0x20] // @13C1 stack[-1] // } 13BE 5B JUMPDEST 13BF 81 DUP2 13C0 35 CALLDATALOAD 13C1 81 DUP2 13C2 81 DUP2 13C3 11 GT 13C4 15 ISZERO 13C5 61 PUSH2 0x13cd 13C8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @13C0 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x13cd, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_13C9: // Incoming jump from 0x13C8, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @13CC memory[0x00:0x00] } 13C9 60 PUSH1 0x00 13CB 80 DUP1 13CC FD *REVERT // Stack delta = +0 // Outputs[1] { @13CC revert(memory[0x00:0x00]); } // Block terminates label_13CD: // Incoming jump from 0x13C8, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @13CE stack[-7] // @13D1 stack[-1] // @13D5 stack[-3] // } 13CD 5B JUMPDEST 13CE 86 DUP7 13CF 60 PUSH1 0x20 13D1 82 DUP3 13D2 60 PUSH1 0x05 13D4 1B SHL 13D5 85 DUP6 13D6 01 ADD 13D7 01 ADD 13D8 11 GT 13D9 15 ISZERO 13DA 61 PUSH2 0x13e2 13DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13e2, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-7]) label_13DE: // Incoming jump from 0x13DD, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-7]) // Inputs[1] { @13E1 memory[0x00:0x00] } 13DE 60 PUSH1 0x00 13E0 80 DUP1 13E1 FD *REVERT // Stack delta = +0 // Outputs[1] { @13E1 revert(memory[0x00:0x00]); } // Block terminates label_13E2: // Incoming jump from 0x13DD, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-7]) // Inputs[6] // { // @13E5 stack[-3] // @13E6 stack[-1] // @13E9 stack[-8] // @13EB stack[-7] // @13ED stack[-2] // @13EE stack[-6] // } 13E2 5B JUMPDEST 13E3 60 PUSH1 0x20 13E5 92 SWAP3 13E6 90 SWAP1 13E7 92 SWAP3 13E8 01 ADD 13E9 96 SWAP7 13EA 91 SWAP2 13EB 95 SWAP6 13EC 50 POP 13ED 90 SWAP1 13EE 93 SWAP4 13EF 50 POP 13F0 50 POP 13F1 50 POP 13F2 50 POP 13F3 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @13E9 stack[-8] = 0x20 + stack[-3] // @13EB stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_13F4: // Incoming call from 0x0382, returns to 0x0383 // Inputs[2] // { // @13FA stack[-1] // @13FB stack[-2] // } 13F4 5B JUMPDEST 13F5 60 PUSH1 0x00 13F7 80 DUP1 13F8 60 PUSH1 0x40 13FA 83 DUP4 13FB 85 DUP6 13FC 03 SUB 13FD 12 SLT 13FE 15 ISZERO 13FF 61 PUSH2 0x1407 1402 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @13F5 stack[0] = 0x00 // @13F7 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1407, if !(stack[-2] - stack[-1] i< 0x40) label_1403: // Incoming jump from 0x1402, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1406 memory[0x00:0x00] } 1403 60 PUSH1 0x00 1405 80 DUP1 1406 FD *REVERT // Stack delta = +0 // Outputs[1] { @1406 revert(memory[0x00:0x00]); } // Block terminates label_1407: // Incoming jump from 0x1402, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @140B stack[-3] } 1407 5B JUMPDEST 1408 61 PUSH2 0x1410 140B 83 DUP4 140C 61 PUSH2 0x1220 140F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1408 stack[0] = 0x1410 // @140B stack[1] = stack[-3] // } // Block ends with call to 0x1220, returns to 0x1410 label_1410: // Incoming return from call to 0x1220 at 0x140F // Inputs[4] // { // @1411 stack[-3] // @1411 stack[-1] // @1415 stack[-4] // @1417 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1410 5B JUMPDEST 1411 91 SWAP2 1412 50 POP 1413 60 PUSH1 0x20 1415 83 DUP4 1416 01 ADD 1417 35 CALLDATALOAD 1418 80 DUP1 1419 15 ISZERO 141A 15 ISZERO 141B 81 DUP2 141C 14 EQ 141D 61 PUSH2 0x1425 1420 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1411 stack[-3] = stack[-1] // @1417 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1425, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_1421: // Incoming jump from 0x1420, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[1] { @1424 memory[0x00:0x00] } 1421 60 PUSH1 0x00 1423 80 DUP1 1424 FD *REVERT // Stack delta = +0 // Outputs[1] { @1424 revert(memory[0x00:0x00]); } // Block terminates label_1425: // Incoming jump from 0x1420, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @1426 stack[-1] // @1427 stack[-2] // @142A stack[-5] // @142C stack[-6] // @142C stack[-3] // @142D stack[-4] // } 1425 5B JUMPDEST 1426 80 DUP1 1427 91 SWAP2 1428 50 POP 1429 50 POP 142A 92 SWAP3 142B 50 POP 142C 92 SWAP3 142D 90 SWAP1 142E 50 POP 142F 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @142A stack[-5] = stack[-1] // @142C stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1430: // Incoming call from 0x0395, returns to 0x0396 // Inputs[2] // { // @143B stack[-1] // @143C stack[-2] // } 1430 5B JUMPDEST 1431 60 PUSH1 0x00 1433 80 DUP1 1434 60 PUSH1 0x00 1436 80 DUP1 1437 60 PUSH1 0x00 1439 60 PUSH1 0x80 143B 86 DUP7 143C 88 DUP9 143D 03 SUB 143E 12 SLT 143F 15 ISZERO 1440 61 PUSH2 0x1448 1443 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1431 stack[0] = 0x00 // @1433 stack[1] = 0x00 // @1434 stack[2] = 0x00 // @1436 stack[3] = 0x00 // @1437 stack[4] = 0x00 // } // Block ends with conditional jump to 0x1448, if !(stack[-2] - stack[-1] i< 0x80) label_1444: // Incoming jump from 0x1443, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1447 memory[0x00:0x00] } 1444 60 PUSH1 0x00 1446 80 DUP1 1447 FD *REVERT // Stack delta = +0 // Outputs[1] { @1447 revert(memory[0x00:0x00]); } // Block terminates label_1448: // Incoming jump from 0x1443, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @144C stack[-6] } 1448 5B JUMPDEST 1449 61 PUSH2 0x1451 144C 86 DUP7 144D 61 PUSH2 0x1220 1450 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1449 stack[0] = 0x1451 // @144C stack[1] = stack[-6] // } // Block ends with call to 0x1220, returns to 0x1451 label_1451: // Incoming return from call to 0x1220 at 0x1450 // Inputs[3] // { // @1452 stack[-6] // @1452 stack[-1] // @1459 stack[-7] // } 1451 5B JUMPDEST 1452 94 SWAP5 1453 50 POP 1454 61 PUSH2 0x145f 1457 60 PUSH1 0x20 1459 87 DUP8 145A 01 ADD 145B 61 PUSH2 0x1220 145E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1452 stack[-6] = stack[-1] // @1454 stack[-1] = 0x145f // @145A stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x1220, returns to 0x145F label_145F: // Incoming return from call to 0x1220 at 0x145E // Inputs[6] // { // @1460 stack[-5] // @1460 stack[-1] // @1464 stack[-7] // @1466 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @1467 stack[-4] // @146D msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // } 145F 5B JUMPDEST 1460 93 SWAP4 1461 50 POP 1462 60 PUSH1 0x40 1464 86 DUP7 1465 01 ADD 1466 35 CALLDATALOAD 1467 92 SWAP3 1468 50 POP 1469 60 PUSH1 0x60 146B 86 DUP7 146C 01 ADD 146D 35 CALLDATALOAD 146E 67 PUSH8 0xffffffffffffffff 1477 80 DUP1 1478 82 DUP3 1479 11 GT 147A 15 ISZERO 147B 61 PUSH2 0x1483 147E 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1460 stack[-5] = stack[-1] // @1467 stack[-4] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @146D stack[-1] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @146E stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1483, if !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) label_147F: // Incoming jump from 0x147E, if not !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1482 memory[0x00:0x00] } 147F 60 PUSH1 0x00 1481 80 DUP1 1482 FD *REVERT // Stack delta = +0 // Outputs[1] { @1482 revert(memory[0x00:0x00]); } // Block terminates label_1483: // Incoming jump from 0x147E, if !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1484 stack[-2] // @1485 stack[-8] // @1489 stack[-9] // } 1483 5B JUMPDEST 1484 81 DUP2 1485 88 DUP9 1486 01 ADD 1487 91 SWAP2 1488 50 POP 1489 88 DUP9 148A 60 PUSH1 0x1f 148C 83 DUP4 148D 01 ADD 148E 12 SLT 148F 61 PUSH2 0x1497 1492 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1487 stack[-2] = stack[-8] + stack[-2] } // Block ends with conditional jump to 0x1497, if stack[-8] + stack[-2] + 0x1f i< stack[-9] label_1493: // Incoming jump from 0x1492, if not stack[-8] + stack[-2] + 0x1f i< stack[-9] // Inputs[1] { @1496 memory[0x00:0x00] } 1493 60 PUSH1 0x00 1495 80 DUP1 1496 FD *REVERT // Stack delta = +0 // Outputs[1] { @1496 revert(memory[0x00:0x00]); } // Block terminates label_1497: // Incoming jump from 0x1492, if stack[-8] + stack[-2] + 0x1f i< stack[-9] // Inputs[3] // { // @1498 stack[-2] // @1499 msg.data[stack[-2]:stack[-2] + 0x20] // @149A stack[-1] // } 1497 5B JUMPDEST 1498 81 DUP2 1499 35 CALLDATALOAD 149A 81 DUP2 149B 81 DUP2 149C 11 GT 149D 15 ISZERO 149E 61 PUSH2 0x14a6 14A1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1499 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x14a6, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_14A2: // Incoming jump from 0x14A1, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @14A5 memory[0x00:0x00] } 14A2 60 PUSH1 0x00 14A4 80 DUP1 14A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @14A5 revert(memory[0x00:0x00]); } // Block terminates label_14A6: // Incoming jump from 0x14A1, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @14A7 stack[-10] // @14AA stack[-1] // @14AB stack[-3] // } 14A6 5B JUMPDEST 14A7 89 DUP10 14A8 60 PUSH1 0x20 14AA 82 DUP3 14AB 85 DUP6 14AC 01 ADD 14AD 01 ADD 14AE 11 GT 14AF 15 ISZERO 14B0 61 PUSH2 0x14b8 14B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14b8, if !(stack[-3] + stack[-1] + 0x20 > stack[-10]) label_14B4: // Incoming jump from 0x14B3, if not !(stack[-3] + stack[-1] + 0x20 > stack[-10]) // Inputs[1] { @14B7 memory[0x00:0x00] } 14B4 60 PUSH1 0x00 14B6 80 DUP1 14B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @14B7 revert(memory[0x00:0x00]); } // Block terminates label_14B8: // Incoming jump from 0x14B3, if !(stack[-3] + stack[-1] + 0x20 > stack[-10]) // Inputs[9] // { // @14B9 stack[-8] // @14B9 stack[-1] // @14BA stack[-11] // @14BB stack[-7] // @14BC stack[-10] // @14BE stack[-2] // @14BE stack[-6] // @14BF stack[-9] // @14C3 stack[-3] // } 14B8 5B JUMPDEST 14B9 96 SWAP7 14BA 99 SWAP10 14BB 95 SWAP6 14BC 98 SWAP9 14BD 50 POP 14BE 93 SWAP4 14BF 96 SWAP7 14C0 50 POP 14C1 60 PUSH1 0x20 14C3 01 ADD 14C4 94 SWAP5 14C5 93 SWAP4 14C6 92 SWAP3 14C7 50 POP 14C8 50 POP 14C9 50 POP 14CA 56 *JUMP // Stack delta = -6 // Outputs[5] // { // @14BA stack[-11] = stack[-8] // @14BC stack[-10] = stack[-7] // @14BF stack[-9] = stack[-6] // @14C4 stack[-8] = 0x20 + stack[-3] // @14C5 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-11] label_14CB: // Incoming call from 0x03F3, returns to 0x03F4 // Inputs[2] // { // @14D1 stack[-1] // @14D2 stack[-2] // } 14CB 5B JUMPDEST 14CC 60 PUSH1 0x00 14CE 80 DUP1 14CF 60 PUSH1 0x40 14D1 83 DUP4 14D2 85 DUP6 14D3 03 SUB 14D4 12 SLT 14D5 15 ISZERO 14D6 61 PUSH2 0x14de 14D9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14CC stack[0] = 0x00 // @14CE stack[1] = 0x00 // } // Block ends with conditional jump to 0x14de, if !(stack[-2] - stack[-1] i< 0x40) label_14DA: // Incoming jump from 0x14D9, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @14DD memory[0x00:0x00] } 14DA 60 PUSH1 0x00 14DC 80 DUP1 14DD FD *REVERT // Stack delta = +0 // Outputs[1] { @14DD revert(memory[0x00:0x00]); } // Block terminates label_14DE: // Incoming jump from 0x14D9, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @14E2 stack[-3] } 14DE 5B JUMPDEST 14DF 61 PUSH2 0x14e7 14E2 83 DUP4 14E3 61 PUSH2 0x1220 14E6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @14DF stack[0] = 0x14e7 // @14E2 stack[1] = stack[-3] // } // Block ends with call to 0x1220, returns to 0x14E7 label_14E7: // Incoming return from call to 0x1220 at 0x14E6 // Inputs[3] // { // @14E8 stack[-3] // @14E8 stack[-1] // @14EF stack[-4] // } 14E7 5B JUMPDEST 14E8 91 SWAP2 14E9 50 POP 14EA 61 PUSH2 0x14f5 14ED 60 PUSH1 0x20 14EF 84 DUP5 14F0 01 ADD 14F1 61 PUSH2 0x1220 14F4 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @14E8 stack[-3] = stack[-1] // @14EA stack[-1] = 0x14f5 // @14F0 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1220, returns to 0x14F5 label_14F5: // Incoming return from call to 0x1220 at 0x14F4 // Inputs[6] // { // @14F6 stack[-2] // @14F6 stack[-1] // @14F8 stack[-5] // @14FA stack[-3] // @14FA stack[-6] // @14FB stack[-4] // } 14F5 5B JUMPDEST 14F6 90 SWAP1 14F7 50 POP 14F8 92 SWAP3 14F9 50 POP 14FA 92 SWAP3 14FB 90 SWAP1 14FC 50 POP 14FD 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @14F8 stack[-5] = stack[-1] // @14FA stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_14FE: // Incoming call from 0x0CBA, returns to 0x0CBB // Incoming call from 0x0B4B, returns to 0x0473 // Incoming call from 0x0472, returns to 0x0473 // Incoming call from 0x049E, returns to 0x049F // Incoming call from 0x0ADB, returns to 0x0473 // Incoming call from 0x10D9, returns to 0x10DA // Inputs[1] { @1501 stack[-1] } 14FE 5B JUMPDEST 14FF 60 PUSH1 0x01 1501 81 DUP2 1502 81 DUP2 1503 1C SHR 1504 90 SWAP1 1505 82 DUP3 1506 16 AND 1507 80 DUP1 1508 61 PUSH2 0x1512 150B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1504 stack[0] = stack[-1] >> 0x01 // @1506 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x1512, if stack[-1] & 0x01 label_150C: // Incoming jump from 0x150B, if not stack[-1] & 0x01 // Inputs[2] // { // @150E stack[-2] // @1517 stack[-1] // } 150C 60 PUSH1 0x7f 150E 82 DUP3 150F 16 AND 1510 91 SWAP2 1511 50 POP 1512 5B JUMPDEST 1513 60 PUSH1 0x20 1515 82 DUP3 1516 10 LT 1517 81 DUP2 1518 14 EQ 1519 15 ISZERO 151A 61 PUSH2 0x1533 151D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1510 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x1533, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_151E: // Incoming jump from 0x151D, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x151D, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @1532 memory[0x00:0x24] } 151E 63 PUSH4 0x4e487b71 1523 60 PUSH1 0xe0 1525 1B SHL 1526 60 PUSH1 0x00 1528 52 MSTORE 1529 60 PUSH1 0x22 152B 60 PUSH1 0x04 152D 52 MSTORE 152E 60 PUSH1 0x24 1530 60 PUSH1 0x00 1532 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1528 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @152D memory[0x04:0x24] = 0x22 // @1532 revert(memory[0x00:0x24]); // } // Block terminates label_1533: // Incoming jump from 0x151D, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x151D, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @1535 stack[-4] // @1535 stack[-2] // @1536 stack[-3] // } 1533 5B JUMPDEST 1534 50 POP 1535 91 SWAP2 1536 90 SWAP1 1537 50 POP 1538 56 *JUMP // Stack delta = -3 // Outputs[1] { @1535 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_1539: // Incoming call from 0x0D31, returns to 0x0576 // Incoming call from 0x0841, returns to 0x0576 // Incoming call from 0x0604, returns to 0x0576 // Incoming call from 0x0968, returns to 0x0576 // Incoming call from 0x0997, returns to 0x0576 // Inputs[2] // { // @153D stack[-1] // @155D stack[-2] // } 1539 5B JUMPDEST 153A 60 PUSH1 0x20 153C 80 DUP1 153D 82 DUP3 153E 52 MSTORE 153F 60 PUSH1 0x0c 1541 90 SWAP1 1542 82 DUP3 1543 01 ADD 1544 52 MSTORE 1545 6B PUSH12 0x15539055551213d492569151 1552 60 PUSH1 0xa2 1554 1B SHL 1555 60 PUSH1 0x40 1557 82 DUP3 1558 01 ADD 1559 52 MSTORE 155A 60 PUSH1 0x60 155C 01 ADD 155D 90 SWAP1 155E 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @153E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1544 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x0c // @1559 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x15539055551213d492569151 << 0xa2 // @155D stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_155F: // Incoming jump from 0x0C4D // Incoming jump from 0x08EE // Inputs[2] // { // @1564 stack[-1] // @1565 stack[-2] // } 155F 5B JUMPDEST 1560 60 PUSH1 0x00 1562 60 PUSH1 0x20 1564 82 DUP3 1565 84 DUP5 1566 03 SUB 1567 12 SLT 1568 15 ISZERO 1569 61 PUSH2 0x1571 156C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1560 stack[0] = 0x00 } // Block ends with conditional jump to 0x1571, if !(stack[-2] - stack[-1] i< 0x20) label_156D: // Incoming jump from 0x156C, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1570 memory[0x00:0x00] } 156D 60 PUSH1 0x00 156F 80 DUP1 1570 FD *REVERT // Stack delta = +0 // Outputs[1] { @1570 revert(memory[0x00:0x00]); } // Block terminates label_1571: // Incoming jump from 0x156C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1572 stack[-2] // @1573 memory[stack[-2]:stack[-2] + 0x20] // } 1571 5B JUMPDEST 1572 81 DUP2 1573 51 MLOAD 1574 61 PUSH2 0x119d 1577 81 DUP2 1578 61 PUSH2 0x1167 157B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1573 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @1574 stack[1] = 0x119d // @1577 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1167, returns to 0x119D label_157C: // Incoming jump from 0x15BC // Incoming jump from 0x15A3 // Incoming jump from 0x16E9 // Inputs[1] { @1591 memory[0x00:0x24] } 157C 5B JUMPDEST 157D 63 PUSH4 0x4e487b71 1582 60 PUSH1 0xe0 1584 1B SHL 1585 60 PUSH1 0x00 1587 52 MSTORE 1588 60 PUSH1 0x11 158A 60 PUSH1 0x04 158C 52 MSTORE 158D 60 PUSH1 0x24 158F 60 PUSH1 0x00 1591 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1587 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @158C memory[0x04:0x24] = 0x11 // @1591 revert(memory[0x00:0x24]); // } // Block terminates label_1592: // Incoming call from 0x09EC, returns to 0x09ED // Inputs[2] // { // @1595 stack[-2] // @1596 stack[-1] // } 1592 5B JUMPDEST 1593 60 PUSH1 0x00 1595 82 DUP3 1596 82 DUP3 1597 10 LT 1598 15 ISZERO 1599 61 PUSH2 0x15a4 159C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1593 stack[0] = 0x00 } // Block ends with conditional jump to 0x15a4, if !(stack[-1] < stack[-2]) label_159D: // Incoming jump from 0x159C, if not !(stack[-1] < stack[-2]) 159D 61 PUSH2 0x15a4 15A0 61 PUSH2 0x157c 15A3 56 *JUMP // Stack delta = +1 // Outputs[1] { @159D stack[0] = 0x15a4 } // Block ends with unconditional jump to 0x157c label_15A4: // Incoming jump from 0x159C, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @15A6 stack[-2] // @15A6 stack[-3] // @15A7 stack[-4] // } 15A4 5B JUMPDEST 15A5 50 POP 15A6 03 SUB 15A7 90 SWAP1 15A8 56 *JUMP // Stack delta = -3 // Outputs[1] { @15A7 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_15A9: // Incoming call from 0x0E09, returns to 0x0A6F // Incoming call from 0x0A6E, returns to 0x0A6F // Inputs[1] { @15AF stack[-1] } 15A9 5B JUMPDEST 15AA 60 PUSH1 0x00 15AC 60 PUSH1 0x00 15AE 19 NOT 15AF 82 DUP3 15B0 14 EQ 15B1 15 ISZERO 15B2 61 PUSH2 0x15bd 15B5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @15AA stack[0] = 0x00 } // Block ends with conditional jump to 0x15bd, if !(stack[-1] == ~0x00) label_15B6: // Incoming jump from 0x15B5, if not !(stack[-1] == ~0x00) 15B6 61 PUSH2 0x15bd 15B9 61 PUSH2 0x157c 15BC 56 *JUMP // Stack delta = +1 // Outputs[1] { @15B6 stack[0] = 0x15bd } // Block ends with unconditional jump to 0x157c label_15BD: // Incoming jump from 0x15B5, if !(stack[-1] == ~0x00) // Inputs[2] // { // @15C1 stack[-2] // @15C2 stack[-3] // } 15BD 5B JUMPDEST 15BE 50 POP 15BF 60 PUSH1 0x01 15C1 01 ADD 15C2 90 SWAP1 15C3 56 *JUMP // Stack delta = -2 // Outputs[1] { @15C2 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_15C4: // Incoming call from 0x0C0A, returns to 0x0C0B // Inputs[8] // { // @15CD stack[-6] // @15D0 stack[-1] // @15D2 stack[-5] // @15DD stack[-4] // @15EB stack[-2] // @15F1 stack[-3] // @15F6 msg.data[stack[-3]:stack[-3] + stack[-2]] // @160F stack[-7] // } 15C4 5B JUMPDEST 15C5 60 PUSH1 0x01 15C7 60 PUSH1 0x01 15C9 60 PUSH1 0xa0 15CB 1B SHL 15CC 03 SUB 15CD 86 DUP7 15CE 81 DUP2 15CF 16 AND 15D0 82 DUP3 15D1 52 MSTORE 15D2 85 DUP6 15D3 16 AND 15D4 60 PUSH1 0x20 15D6 82 DUP3 15D7 01 ADD 15D8 52 MSTORE 15D9 60 PUSH1 0x40 15DB 81 DUP2 15DC 01 ADD 15DD 84 DUP5 15DE 90 SWAP1 15DF 52 MSTORE 15E0 60 PUSH1 0x80 15E2 60 PUSH1 0x60 15E4 82 DUP3 15E5 01 ADD 15E6 81 DUP2 15E7 90 SWAP1 15E8 52 MSTORE 15E9 81 DUP2 15EA 01 ADD 15EB 82 DUP3 15EC 90 SWAP1 15ED 52 MSTORE 15EE 60 PUSH1 0x00 15F0 82 DUP3 15F1 84 DUP5 15F2 60 PUSH1 0xa0 15F4 84 DUP5 15F5 01 ADD 15F6 37 CALLDATACOPY 15F7 60 PUSH1 0x00 15F9 60 PUSH1 0xa0 15FB 84 DUP5 15FC 84 DUP5 15FD 01 ADD 15FE 01 ADD 15FF 52 MSTORE 1600 60 PUSH1 0xa0 1602 60 PUSH1 0x1f 1604 19 NOT 1605 60 PUSH1 0x1f 1607 85 DUP6 1608 01 ADD 1609 16 AND 160A 83 DUP4 160B 01 ADD 160C 01 ADD 160D 90 SWAP1 160E 50 POP 160F 96 SWAP7 1610 95 SWAP6 1611 50 POP 1612 50 POP 1613 50 POP 1614 50 POP 1615 50 POP 1616 50 POP 1617 56 *JUMP // Stack delta = -6 // Outputs[8] // { // @15D1 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @15D8 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @15DF memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-4] // @15E8 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @15ED memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] = stack[-2] // @15F6 memory[stack[-1] + 0xa0:stack[-1] + 0xa0 + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @15FF memory[stack[-1] + stack[-2] + 0xa0:stack[-1] + stack[-2] + 0xa0 + 0x20] = 0x00 // @160F stack[-7] = stack[-1] + (stack[-2] + 0x1f & ~0x1f) + 0xa0 // } // Block ends with unconditional jump to stack[-7] label_1618: // Incoming call from 0x16D1, returns to 0x16D2 // Inputs[3] // { // @161B stack[-1] // @161C memory[stack[-1]:stack[-1] + 0x20] // @1621 stack[-2] // } 1618 5B JUMPDEST 1619 60 PUSH1 0x00 161B 81 DUP2 161C 51 MLOAD 161D 61 PUSH2 0x162a 1620 81 DUP2 1621 85 DUP6 1622 60 PUSH1 0x20 1624 86 DUP7 1625 01 ADD 1626 61 PUSH2 0x11a4 1629 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1619 stack[0] = 0x00 // @161C stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @161D stack[2] = 0x162a // @1620 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1621 stack[4] = stack[-2] // @1625 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x11a4, returns to 0x162A label_162A: // Incoming return from call to 0x11A4 at 0x1629 // Inputs[4] // { // @162B stack[-4] // @162B stack[-1] // @162C stack[-2] // @162F stack[-5] // } 162A 5B JUMPDEST 162B 92 SWAP3 162C 90 SWAP1 162D 92 SWAP3 162E 01 ADD 162F 92 SWAP3 1630 91 SWAP2 1631 50 POP 1632 50 POP 1633 56 *JUMP // Stack delta = -4 // Outputs[1] { @162F stack[-5] = stack[-1] + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1634: // Incoming call from 0x0CF2, returns to 0x0CF3 // Inputs[2] // { // @1638 stack[-3] // @1639 storage[stack[-3]] // } 1634 5B JUMPDEST 1635 60 PUSH1 0x00 1637 80 DUP1 1638 84 DUP5 1639 54 SLOAD 163A 81 DUP2 163B 60 PUSH1 0x01 163D 82 DUP3 163E 81 DUP2 163F 1C SHR 1640 91 SWAP2 1641 50 POP 1642 80 DUP1 1643 83 DUP4 1644 16 AND 1645 80 DUP1 1646 61 PUSH2 0x1650 1649 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @1635 stack[0] = 0x00 // @1637 stack[1] = 0x00 // @1639 stack[2] = storage[stack[-3]] // @163B stack[4] = 0x01 // @1640 stack[3] = storage[stack[-3]] >> 0x01 // @1644 stack[5] = storage[stack[-3]] & 0x01 // } // Block ends with conditional jump to 0x1650, if storage[stack[-3]] & 0x01 label_164A: // Incoming jump from 0x1649, if not storage[stack[-3]] & 0x01 // Inputs[2] // { // @164C stack[-3] // @1656 stack[-1] // } 164A 60 PUSH1 0x7f 164C 83 DUP4 164D 16 AND 164E 92 SWAP3 164F 50 POP 1650 5B JUMPDEST 1651 60 PUSH1 0x20 1653 80 DUP1 1654 84 DUP5 1655 10 LT 1656 82 DUP3 1657 14 EQ 1658 15 ISZERO 1659 61 PUSH2 0x1670 165C 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @164E stack[-3] = stack[-3] & 0x7f // @1651 stack[0] = 0x20 // } // Block ends with conditional jump to 0x1670, if !(stack[-1] == (stack[-3] & 0x7f < 0x20)) label_165D: // Incoming jump from 0x165C, if not !(stack[-1] == (stack[-3] < 0x20)) // Incoming jump from 0x165C, if not !(stack[-1] == (stack[-3] & 0x7f < 0x20)) // Inputs[2] // { // @1665 stack[-6] // @166F memory[stack[-6]:stack[-6] + 0x24] // } 165D 63 PUSH4 0x4e487b71 1662 60 PUSH1 0xe0 1664 1B SHL 1665 86 DUP7 1666 52 MSTORE 1667 60 PUSH1 0x22 1669 60 PUSH1 0x04 166B 52 MSTORE 166C 60 PUSH1 0x24 166E 86 DUP7 166F FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1666 memory[stack[-6]:stack[-6] + 0x20] = 0x4e487b71 << 0xe0 // @166B memory[0x04:0x24] = 0x22 // @166F revert(memory[stack[-6]:stack[-6] + 0x24]); // } // Block terminates label_1670: // Incoming jump from 0x165C, if !(stack[-1] == (stack[-3] < 0x20)) // Incoming jump from 0x165C, if !(stack[-1] == (stack[-3] & 0x7f < 0x20)) // Inputs[1] { @1671 stack[-2] } 1670 5B JUMPDEST 1671 81 DUP2 1672 80 DUP1 1673 15 ISZERO 1674 61 PUSH2 0x1684 1677 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1671 stack[0] = stack[-2] } // Block ends with conditional jump to 0x1684, if !stack[-2] label_1678: // Incoming jump from 0x1677, if not !stack[-2] // Inputs[1] { @167A stack[-1] } 1678 60 PUSH1 0x01 167A 81 DUP2 167B 14 EQ 167C 61 PUSH2 0x1695 167F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1695, if stack[-1] == 0x01 label_1680: // Incoming jump from 0x167F, if not stack[-1] == 0x01 1680 61 PUSH2 0x16c2 1683 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x16c2 label_1684: // Incoming jump from 0x1677, if !stack[-2] // Inputs[4] // { // @1688 stack[-6] // @168A stack[-9] // @168C stack[-5] // @168F stack[-7] // } 1684 5B JUMPDEST 1685 60 PUSH1 0xff 1687 19 NOT 1688 86 DUP7 1689 16 AND 168A 89 DUP10 168B 52 MSTORE 168C 84 DUP5 168D 89 DUP10 168E 01 ADD 168F 96 SWAP7 1690 50 POP 1691 61 PUSH2 0x16c2 1694 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @168B memory[stack[-9]:stack[-9] + 0x20] = stack[-6] & ~0xff // @168F stack[-7] = stack[-9] + stack[-5] // } // Block ends with unconditional jump to 0x16c2 label_1695: // Incoming jump from 0x167F, if stack[-1] == 0x01 // Inputs[3] // { // @1698 stack[-11] // @169E memory[0x00:0x20] // @16A2 stack[-5] // } 1695 5B JUMPDEST 1696 60 PUSH1 0x00 1698 8B DUP12 1699 81 DUP2 169A 52 MSTORE 169B 60 PUSH1 0x20 169D 90 SWAP1 169E 20 SHA3 169F 60 PUSH1 0x00 16A1 5B JUMPDEST 16A2 86 DUP7 16A3 81 DUP2 16A4 10 LT 16A5 15 ISZERO 16A6 61 PUSH2 0x16ba 16A9 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @169A memory[0x00:0x20] = stack[-11] // @169E stack[0] = keccak256(memory[0x00:0x20]) // @169F stack[1] = 0x00 // } // Block ends with conditional jump to 0x16ba, if !(0x00 < stack[-5]) label_16AA: // Incoming jump from 0x16A9, if not !(stack[-1] < stack[-7]) // Incoming jump from 0x16A9, if not !(0x00 < stack[-5]) // Inputs[6] // { // @16AA stack[-2] // @16AB storage[stack[-2]] // @16AC stack[-11] // @16AD stack[-1] // @16B1 stack[-6] // @16B4 stack[-4] // } 16AA 81 DUP2 16AB 54 SLOAD 16AC 8B DUP12 16AD 82 DUP3 16AE 01 ADD 16AF 52 MSTORE 16B0 90 SWAP1 16B1 85 DUP6 16B2 01 ADD 16B3 90 SWAP1 16B4 83 DUP4 16B5 01 ADD 16B6 61 PUSH2 0x16a1 16B9 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @16AF memory[stack[-1] + stack[-11]:stack[-1] + stack[-11] + 0x20] = storage[stack[-2]] // @16B3 stack[-2] = stack[-6] + stack[-2] // @16B5 stack[-1] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x16a1 label_16BA: // Incoming jump from 0x16A9, if !(stack[-1] < stack[-7]) // Incoming jump from 0x16A9, if !(0x00 < stack[-5]) // Inputs[3] // { // @16BD stack[-7] // @16BE stack[-11] // @16C0 stack[-9] // } 16BA 5B JUMPDEST 16BB 50 POP 16BC 50 POP 16BD 84 DUP5 16BE 89 DUP10 16BF 01 ADD 16C0 96 SWAP7 16C1 50 POP // Stack delta = -2 // Outputs[1] { @16C0 stack[-9] = stack[-11] + stack[-7] } // Block continues label_16C2: // Incoming jump from 0x16C1 // Incoming jump from 0x1683 // Incoming jump from 0x1694 // Inputs[2] // { // @16CC stack[-7] // @16CD stack[-10] // } 16C2 5B JUMPDEST 16C3 50 POP 16C4 50 POP 16C5 50 POP 16C6 50 POP 16C7 50 POP 16C8 50 POP 16C9 61 PUSH2 0x16d2 16CC 81 DUP2 16CD 85 DUP6 16CE 61 PUSH2 0x1618 16D1 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @16C9 stack[-6] = 0x16d2 // @16CC stack[-5] = stack[-7] // @16CD stack[-4] = stack[-10] // } // Block ends with call to 0x1618, returns to 0x16D2 label_16D2: // Incoming return from call to 0x1618 at 0x16D1 // Inputs[3] // { // @16D3 stack[-1] // @16D3 stack[-7] // @16D4 stack[-6] // } 16D2 5B JUMPDEST 16D3 95 SWAP6 16D4 94 SWAP5 16D5 50 POP 16D6 50 POP 16D7 50 POP 16D8 50 POP 16D9 50 POP 16DA 56 *JUMP // Stack delta = -6 // Outputs[1] { @16D3 stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] label_16DB: // Incoming call from 0x0DED, returns to 0x0DEE // Inputs[1] { @16DE stack[-1] } 16DB 5B JUMPDEST 16DC 60 PUSH1 0x00 16DE 81 DUP2 16DF 61 PUSH2 0x16ea 16E2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @16DC stack[0] = 0x00 } // Block ends with conditional jump to 0x16ea, if stack[-1] label_16E3: // Incoming jump from 0x16E2, if not stack[-1] 16E3 61 PUSH2 0x16ea 16E6 61 PUSH2 0x157c 16E9 56 *JUMP // Stack delta = +1 // Outputs[1] { @16E3 stack[0] = 0x16ea } // Block ends with unconditional jump to 0x157c label_16EA: // Incoming jump from 0x16E2, if stack[-1] // Inputs[2] // { // @16EF stack[-2] // @16F0 stack[-3] // } 16EA 5B JUMPDEST 16EB 50 POP 16EC 60 PUSH1 0x00 16EE 19 NOT 16EF 01 ADD 16F0 90 SWAP1 16F1 56 *JUMP // Stack delta = -2 // Outputs[1] { @16F0 stack[-3] = ~0x00 + stack[-2] } // Block ends with unconditional jump to stack[-3] 16F2 FE *ASSERT 16F3 A2 LOG2 16F4 64 PUSH5 0x6970667358 16FA 22 22 16FB 12 SLT 16FC 20 SHA3 16FD 11 GT 16FE 82 DUP3 16FF A6 A6 1700 AC AC 1701 78 PUSH25 0xb402f8da54ae5442c4eb36853034021cdb0f0d9a53620d06d5 171B 6D PUSH14 0x4764736f6c634300080a0033