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 0x00ea 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x00ea, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x95d89b41 0026 11 GT 0027 61 PUSH2 0x008c 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x008c, if 0x95d89b41 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x95d89b41 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xb5931f7c 0031 11 GT 0032 61 PUSH2 0x0066 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0066, if 0xb5931f7c > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xb5931f7c > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xb5931f7c 003C 14 EQ 003D 61 PUSH2 0x044b 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x044b, if 0xb5931f7c == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xb5931f7c == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xd05c78da 0047 14 EQ 0048 61 PUSH2 0x0497 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0497, if 0xd05c78da == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xd05c78da == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xdd62ed3e 0052 14 EQ 0053 61 PUSH2 0x04e3 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e3, if 0xdd62ed3e == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xe6cb9013 005D 14 EQ 005E 61 PUSH2 0x055b 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x055b, if 0xe6cb9013 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xe6cb9013 == stack[-1] 0062 61 PUSH2 0x00ea 0065 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00ea label_0066: // Incoming jump from 0x0035, if 0xb5931f7c > stack[-1] // Inputs[1] { @0067 stack[-1] } 0066 5B JUMPDEST 0067 80 DUP1 0068 63 PUSH4 0x95d89b41 006D 14 EQ 006E 61 PUSH2 0x0316 0071 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0316, if 0x95d89b41 == stack[-1] label_0072: // Incoming jump from 0x0071, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0072 stack[-1] } 0072 80 DUP1 0073 63 PUSH4 0xa293d1e8 0078 14 EQ 0079 61 PUSH2 0x0399 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0399, if 0xa293d1e8 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xa293d1e8 == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xa9059cbb 0083 14 EQ 0084 61 PUSH2 0x03e5 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e5, if 0xa9059cbb == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xa9059cbb == stack[-1] 0088 61 PUSH2 0x00ea 008B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00ea label_008C: // Incoming jump from 0x002A, if 0x95d89b41 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @008D stack[-1] } 008C 5B JUMPDEST 008D 80 DUP1 008E 63 PUSH4 0x23b872dd 0093 11 GT 0094 61 PUSH2 0x00c8 0097 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c8, if 0x23b872dd > stack[-1] label_0098: // Incoming jump from 0x0097, if not 0x23b872dd > stack[-1] // Inputs[1] { @0098 stack[-1] } 0098 80 DUP1 0099 63 PUSH4 0x23b872dd 009E 14 EQ 009F 61 PUSH2 0x01f6 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f6, if 0x23b872dd == stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x23b872dd == stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0x313ce567 00A9 14 EQ 00AA 61 PUSH2 0x027c 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027c, if 0x313ce567 == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x313ce567 == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x3eaaf86b 00B4 14 EQ 00B5 61 PUSH2 0x02a0 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a0, if 0x3eaaf86b == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x3eaaf86b == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x70a08231 00BF 14 EQ 00C0 61 PUSH2 0x02be 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02be, if 0x70a08231 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x70a08231 == stack[-1] 00C4 61 PUSH2 0x00ea 00C7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00ea label_00C8: // Incoming jump from 0x0097, if 0x23b872dd > stack[-1] // Inputs[1] { @00C9 stack[-1] } 00C8 5B JUMPDEST 00C9 80 DUP1 00CA 63 PUSH4 0x06fdde03 00CF 14 EQ 00D0 61 PUSH2 0x00ef 00D3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ef, if 0x06fdde03 == stack[-1] label_00D4: // Incoming jump from 0x00D3, if not 0x06fdde03 == stack[-1] // Inputs[1] { @00D4 stack[-1] } 00D4 80 DUP1 00D5 63 PUSH4 0x095ea7b3 00DA 14 EQ 00DB 61 PUSH2 0x0172 00DE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0172, if 0x095ea7b3 == stack[-1] label_00DF: // Incoming jump from 0x00DE, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @00DF stack[-1] } 00DF 80 DUP1 00E0 63 PUSH4 0x18160ddd 00E5 14 EQ 00E6 61 PUSH2 0x01d8 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d8, if 0x18160ddd == stack[-1] label_00EA: // Incoming jump from 0x00C7 // Incoming jump from 0x0065 // Incoming jump from 0x008B // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x00E9, if not 0x18160ddd == stack[-1] // Inputs[1] { @00EE memory[0x00:0x00] } 00EA 5B JUMPDEST 00EB 60 PUSH1 0x00 00ED 80 DUP1 00EE FD *REVERT // Stack delta = +0 // Outputs[1] { @00EE revert(memory[0x00:0x00]); } // Block terminates label_00EF: // Incoming jump from 0x00D3, if 0x06fdde03 == stack[-1] 00EF 5B JUMPDEST 00F0 61 PUSH2 0x00f7 00F3 61 PUSH2 0x05a7 00F6 56 *JUMP // Stack delta = +1 // Outputs[1] { @00F0 stack[0] = 0x00f7 } // Block ends with call to 0x05a7, returns to 0x00F7 label_00F7: // Incoming return from call to 0x05A7 at 0x00F6 // Inputs[4] // { // @00FA memory[0x40:0x60] // @0105 stack[-1] // @0108 memory[stack[-1]:stack[-1] + 0x20] // @0111 memory[stack[-1]:stack[-1] + 0x20] // } 00F7 5B JUMPDEST 00F8 60 PUSH1 0x40 00FA 51 MLOAD 00FB 80 DUP1 00FC 80 DUP1 00FD 60 PUSH1 0x20 00FF 01 ADD 0100 82 DUP3 0101 81 DUP2 0102 03 SUB 0103 82 DUP3 0104 52 MSTORE 0105 83 DUP4 0106 81 DUP2 0107 81 DUP2 0108 51 MLOAD 0109 81 DUP2 010A 52 MSTORE 010B 60 PUSH1 0x20 010D 01 ADD 010E 91 SWAP2 010F 50 POP 0110 80 DUP1 0111 51 MLOAD 0112 90 SWAP1 0113 60 PUSH1 0x20 0115 01 ADD 0116 90 SWAP1 0117 80 DUP1 0118 83 DUP4 0119 83 DUP4 011A 60 PUSH1 0x00 011C 5B JUMPDEST 011D 83 DUP4 011E 81 DUP2 011F 10 LT 0120 15 ISZERO 0121 61 PUSH2 0x0137 0124 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @00FA stack[0] = memory[0x40:0x60] // @00FB stack[1] = memory[0x40:0x60] // @0104 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @010A memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @010E stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0116 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0116 stack[3] = 0x20 + stack[-1] // @0117 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0118 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0119 stack[7] = 0x20 + stack[-1] // @011A stack[8] = 0x00 // } // Block ends with conditional jump to 0x0137, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0125: // Incoming jump from 0x0124, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0124, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0125 stack[-1] // @0126 stack[-2] // @0128 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @012A stack[-3] // } 0125 80 DUP1 0126 82 DUP3 0127 01 ADD 0128 51 MLOAD 0129 81 DUP2 012A 84 DUP5 012B 01 ADD 012C 52 MSTORE 012D 60 PUSH1 0x20 012F 81 DUP2 0130 01 ADD 0131 90 SWAP1 0132 50 POP 0133 61 PUSH2 0x011c 0136 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @012C memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0131 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x011c label_0137: // Incoming jump from 0x0124, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0124, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @013C stack[-5] // @013C stack[-6] // @013E stack[-7] // } 0137 5B JUMPDEST 0138 50 POP 0139 50 POP 013A 50 POP 013B 50 POP 013C 90 SWAP1 013D 50 POP 013E 90 SWAP1 013F 81 DUP2 0140 01 ADD 0141 90 SWAP1 0142 60 PUSH1 0x1f 0144 16 AND 0145 80 DUP1 0146 15 ISZERO 0147 61 PUSH2 0x0164 014A 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0141 stack[-7] = stack[-5] + stack[-7] // @0144 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0164, if !(0x1f & stack[-5]) label_014B: // Incoming jump from 0x014A, if not !(0x1f & stack[-5]) // Inputs[6] // { // @014B stack[-1] // @014C stack[-2] // @014F memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0166 stack[-5] // @016C memory[0x40:0x60] // @0171 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 014B 80 DUP1 014C 82 DUP3 014D 03 SUB 014E 80 DUP1 014F 51 MLOAD 0150 60 PUSH1 0x01 0152 83 DUP4 0153 60 PUSH1 0x20 0155 03 SUB 0156 61 PUSH2 0x0100 0159 0A EXP 015A 03 SUB 015B 19 NOT 015C 16 AND 015D 81 DUP2 015E 52 MSTORE 015F 60 PUSH1 0x20 0161 01 ADD 0162 91 SWAP2 0163 50 POP 0164 5B JUMPDEST 0165 50 POP 0166 92 SWAP3 0167 50 POP 0168 50 POP 0169 50 POP 016A 60 PUSH1 0x40 016C 51 MLOAD 016D 80 DUP1 016E 91 SWAP2 016F 03 SUB 0170 90 SWAP1 0171 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @015E memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0171 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0172: // Incoming jump from 0x00DE, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0179 msg.data.length } 0172 5B JUMPDEST 0173 61 PUSH2 0x01be 0176 60 PUSH1 0x04 0178 80 DUP1 0179 36 CALLDATASIZE 017A 03 SUB 017B 60 PUSH1 0x40 017D 81 DUP2 017E 10 LT 017F 15 ISZERO 0180 61 PUSH2 0x0188 0183 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0173 stack[0] = 0x01be // @0176 stack[1] = 0x04 // @017A stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0188, returns to 0x01BE, if !(msg.data.length - 0x04 < 0x40) label_0184: // Incoming jump from 0x0183, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0187 memory[0x00:0x00] } 0184 60 PUSH1 0x00 0186 80 DUP1 0187 FD *REVERT // Stack delta = +0 // Outputs[1] { @0187 revert(memory[0x00:0x00]); } // Block terminates label_0188: // Incoming call from 0x0183, returns to 0x01BE, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0189 stack[-2] // @018A stack[-1] // @018E msg.data[stack[-2]:stack[-2] + 0x20] // @01AE msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0188 5B JUMPDEST 0189 81 DUP2 018A 01 ADD 018B 90 SWAP1 018C 80 DUP1 018D 80 DUP1 018E 35 CALLDATALOAD 018F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01A4 16 AND 01A5 90 SWAP1 01A6 60 PUSH1 0x20 01A8 01 ADD 01A9 90 SWAP1 01AA 92 SWAP3 01AB 91 SWAP2 01AC 90 SWAP1 01AD 80 DUP1 01AE 35 CALLDATALOAD 01AF 90 SWAP1 01B0 60 PUSH1 0x20 01B2 01 ADD 01B3 90 SWAP1 01B4 92 SWAP3 01B5 91 SWAP2 01B6 90 SWAP1 01B7 50 POP 01B8 50 POP 01B9 50 POP 01BA 61 PUSH2 0x0645 01BD 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01AA stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @01B4 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0645 label_01BE: // Incoming return from call to 0x0188 at 0x0183 // Inputs[4] // { // @01C1 memory[0x40:0x60] // @01C3 stack[-1] // @01D2 memory[0x40:0x60] // @01D7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01BE 5B JUMPDEST 01BF 60 PUSH1 0x40 01C1 51 MLOAD 01C2 80 DUP1 01C3 82 DUP3 01C4 15 ISZERO 01C5 15 ISZERO 01C6 15 ISZERO 01C7 15 ISZERO 01C8 81 DUP2 01C9 52 MSTORE 01CA 60 PUSH1 0x20 01CC 01 ADD 01CD 91 SWAP2 01CE 50 POP 01CF 50 POP 01D0 60 PUSH1 0x40 01D2 51 MLOAD 01D3 80 DUP1 01D4 91 SWAP2 01D5 03 SUB 01D6 90 SWAP1 01D7 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @01D7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01D8: // Incoming jump from 0x00E9, if 0x18160ddd == stack[-1] 01D8 5B JUMPDEST 01D9 61 PUSH2 0x01e0 01DC 61 PUSH2 0x0737 01DF 56 *JUMP // Stack delta = +1 // Outputs[1] { @01D9 stack[0] = 0x01e0 } // Block ends with call to 0x0737, returns to 0x01E0 label_01E0: // Incoming return from call to 0x0737 at 0x01DF // Inputs[4] // { // @01E3 memory[0x40:0x60] // @01E5 stack[-1] // @01F0 memory[0x40:0x60] // @01F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01E0 5B JUMPDEST 01E1 60 PUSH1 0x40 01E3 51 MLOAD 01E4 80 DUP1 01E5 82 DUP3 01E6 81 DUP2 01E7 52 MSTORE 01E8 60 PUSH1 0x20 01EA 01 ADD 01EB 91 SWAP2 01EC 50 POP 01ED 50 POP 01EE 60 PUSH1 0x40 01F0 51 MLOAD 01F1 80 DUP1 01F2 91 SWAP2 01F3 03 SUB 01F4 90 SWAP1 01F5 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @01F5 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01F6: // Incoming jump from 0x00A2, if 0x23b872dd == stack[-1] // Inputs[1] { @01FD msg.data.length } 01F6 5B JUMPDEST 01F7 61 PUSH2 0x0262 01FA 60 PUSH1 0x04 01FC 80 DUP1 01FD 36 CALLDATASIZE 01FE 03 SUB 01FF 60 PUSH1 0x60 0201 81 DUP2 0202 10 LT 0203 15 ISZERO 0204 61 PUSH2 0x020c 0207 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @01F7 stack[0] = 0x0262 // @01FA stack[1] = 0x04 // @01FE stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x020c, returns to 0x0262, if !(msg.data.length - 0x04 < 0x60) label_0208: // Incoming jump from 0x0207, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @020B memory[0x00:0x00] } 0208 60 PUSH1 0x00 020A 80 DUP1 020B FD *REVERT // Stack delta = +0 // Outputs[1] { @020B revert(memory[0x00:0x00]); } // Block terminates label_020C: // Incoming call from 0x0207, returns to 0x0262, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @020D stack[-2] // @020E stack[-1] // @0212 msg.data[stack[-2]:stack[-2] + 0x20] // @0232 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0252 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 020C 5B JUMPDEST 020D 81 DUP2 020E 01 ADD 020F 90 SWAP1 0210 80 DUP1 0211 80 DUP1 0212 35 CALLDATALOAD 0213 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0228 16 AND 0229 90 SWAP1 022A 60 PUSH1 0x20 022C 01 ADD 022D 90 SWAP1 022E 92 SWAP3 022F 91 SWAP2 0230 90 SWAP1 0231 80 DUP1 0232 35 CALLDATALOAD 0233 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0248 16 AND 0249 90 SWAP1 024A 60 PUSH1 0x20 024C 01 ADD 024D 90 SWAP1 024E 92 SWAP3 024F 91 SWAP2 0250 90 SWAP1 0251 80 DUP1 0252 35 CALLDATALOAD 0253 90 SWAP1 0254 60 PUSH1 0x20 0256 01 ADD 0257 90 SWAP1 0258 92 SWAP3 0259 91 SWAP2 025A 90 SWAP1 025B 50 POP 025C 50 POP 025D 50 POP 025E 61 PUSH2 0x0782 0261 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @022E stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @024E stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0258 stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0782 label_0262: // Incoming return from call to 0x020C at 0x0207 // Inputs[4] // { // @0265 memory[0x40:0x60] // @0267 stack[-1] // @0276 memory[0x40:0x60] // @027B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0262 5B JUMPDEST 0263 60 PUSH1 0x40 0265 51 MLOAD 0266 80 DUP1 0267 82 DUP3 0268 15 ISZERO 0269 15 ISZERO 026A 15 ISZERO 026B 15 ISZERO 026C 81 DUP2 026D 52 MSTORE 026E 60 PUSH1 0x20 0270 01 ADD 0271 91 SWAP2 0272 50 POP 0273 50 POP 0274 60 PUSH1 0x40 0276 51 MLOAD 0277 80 DUP1 0278 91 SWAP2 0279 03 SUB 027A 90 SWAP1 027B F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @026D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @027B return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_027C: // Incoming jump from 0x00AD, if 0x313ce567 == stack[-1] 027C 5B JUMPDEST 027D 61 PUSH2 0x0284 0280 61 PUSH2 0x0a12 0283 56 *JUMP // Stack delta = +1 // Outputs[1] { @027D stack[0] = 0x0284 } // Block ends with call to 0x0a12, returns to 0x0284 label_0284: // Incoming return from call to 0x0A12 at 0x0283 // Inputs[4] // { // @0287 memory[0x40:0x60] // @0289 stack[-1] // @029A memory[0x40:0x60] // @029F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0284 5B JUMPDEST 0285 60 PUSH1 0x40 0287 51 MLOAD 0288 80 DUP1 0289 82 DUP3 028A 60 PUSH1 0xff 028C 16 AND 028D 60 PUSH1 0xff 028F 16 AND 0290 81 DUP2 0291 52 MSTORE 0292 60 PUSH1 0x20 0294 01 ADD 0295 91 SWAP2 0296 50 POP 0297 50 POP 0298 60 PUSH1 0x40 029A 51 MLOAD 029B 80 DUP1 029C 91 SWAP2 029D 03 SUB 029E 90 SWAP1 029F F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0291 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xff & 0xff & stack[-1] // @029F return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02A0: // Incoming jump from 0x00B8, if 0x3eaaf86b == stack[-1] 02A0 5B JUMPDEST 02A1 61 PUSH2 0x02a8 02A4 61 PUSH2 0x0a25 02A7 56 *JUMP // Stack delta = +1 // Outputs[1] { @02A1 stack[0] = 0x02a8 } // Block ends with call to 0x0a25, returns to 0x02A8 label_02A8: // Incoming return from call to 0x0A25 at 0x02A7 // Inputs[4] // { // @02AB memory[0x40:0x60] // @02AD stack[-1] // @02B8 memory[0x40:0x60] // @02BD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02A8 5B JUMPDEST 02A9 60 PUSH1 0x40 02AB 51 MLOAD 02AC 80 DUP1 02AD 82 DUP3 02AE 81 DUP2 02AF 52 MSTORE 02B0 60 PUSH1 0x20 02B2 01 ADD 02B3 91 SWAP2 02B4 50 POP 02B5 50 POP 02B6 60 PUSH1 0x40 02B8 51 MLOAD 02B9 80 DUP1 02BA 91 SWAP2 02BB 03 SUB 02BC 90 SWAP1 02BD F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02BD return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02BE: // Incoming jump from 0x00C3, if 0x70a08231 == stack[-1] // Inputs[1] { @02C5 msg.data.length } 02BE 5B JUMPDEST 02BF 61 PUSH2 0x0300 02C2 60 PUSH1 0x04 02C4 80 DUP1 02C5 36 CALLDATASIZE 02C6 03 SUB 02C7 60 PUSH1 0x20 02C9 81 DUP2 02CA 10 LT 02CB 15 ISZERO 02CC 61 PUSH2 0x02d4 02CF 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @02BF stack[0] = 0x0300 // @02C2 stack[1] = 0x04 // @02C6 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x02d4, returns to 0x0300, if !(msg.data.length - 0x04 < 0x20) label_02D0: // Incoming jump from 0x02CF, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @02D3 memory[0x00:0x00] } 02D0 60 PUSH1 0x00 02D2 80 DUP1 02D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D3 revert(memory[0x00:0x00]); } // Block terminates label_02D4: // Incoming call from 0x02CF, returns to 0x0300, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @02D5 stack[-2] // @02D6 stack[-1] // @02DA msg.data[stack[-2]:stack[-2] + 0x20] // } 02D4 5B JUMPDEST 02D5 81 DUP2 02D6 01 ADD 02D7 90 SWAP1 02D8 80 DUP1 02D9 80 DUP1 02DA 35 CALLDATALOAD 02DB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02F0 16 AND 02F1 90 SWAP1 02F2 60 PUSH1 0x20 02F4 01 ADD 02F5 90 SWAP1 02F6 92 SWAP3 02F7 91 SWAP2 02F8 90 SWAP1 02F9 50 POP 02FA 50 POP 02FB 50 POP 02FC 61 PUSH2 0x0a2b 02FF 56 *JUMP // Stack delta = -1 // Outputs[1] { @02F6 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0a2b label_0300: // Incoming return from call to 0x02D4 at 0x02CF // Inputs[4] // { // @0303 memory[0x40:0x60] // @0305 stack[-1] // @0310 memory[0x40:0x60] // @0315 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0300 5B JUMPDEST 0301 60 PUSH1 0x40 0303 51 MLOAD 0304 80 DUP1 0305 82 DUP3 0306 81 DUP2 0307 52 MSTORE 0308 60 PUSH1 0x20 030A 01 ADD 030B 91 SWAP2 030C 50 POP 030D 50 POP 030E 60 PUSH1 0x40 0310 51 MLOAD 0311 80 DUP1 0312 91 SWAP2 0313 03 SUB 0314 90 SWAP1 0315 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0307 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0315 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0316: // Incoming jump from 0x0071, if 0x95d89b41 == stack[-1] 0316 5B JUMPDEST 0317 61 PUSH2 0x031e 031A 61 PUSH2 0x0a74 031D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0317 stack[0] = 0x031e } // Block ends with call to 0x0a74, returns to 0x031E label_031E: // Incoming return from call to 0x0A74 at 0x031D // Inputs[4] // { // @0321 memory[0x40:0x60] // @032C stack[-1] // @032F memory[stack[-1]:stack[-1] + 0x20] // @0338 memory[stack[-1]:stack[-1] + 0x20] // } 031E 5B JUMPDEST 031F 60 PUSH1 0x40 0321 51 MLOAD 0322 80 DUP1 0323 80 DUP1 0324 60 PUSH1 0x20 0326 01 ADD 0327 82 DUP3 0328 81 DUP2 0329 03 SUB 032A 82 DUP3 032B 52 MSTORE 032C 83 DUP4 032D 81 DUP2 032E 81 DUP2 032F 51 MLOAD 0330 81 DUP2 0331 52 MSTORE 0332 60 PUSH1 0x20 0334 01 ADD 0335 91 SWAP2 0336 50 POP 0337 80 DUP1 0338 51 MLOAD 0339 90 SWAP1 033A 60 PUSH1 0x20 033C 01 ADD 033D 90 SWAP1 033E 80 DUP1 033F 83 DUP4 0340 83 DUP4 0341 60 PUSH1 0x00 0343 5B JUMPDEST 0344 83 DUP4 0345 81 DUP2 0346 10 LT 0347 15 ISZERO 0348 61 PUSH2 0x035e 034B 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0321 stack[0] = memory[0x40:0x60] // @0322 stack[1] = memory[0x40:0x60] // @032B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0331 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0335 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @033D stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @033D stack[3] = 0x20 + stack[-1] // @033E stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @033F stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0340 stack[7] = 0x20 + stack[-1] // @0341 stack[8] = 0x00 // } // Block ends with conditional jump to 0x035e, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_034C: // Incoming jump from 0x034B, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x034B, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @034C stack[-1] // @034D stack[-2] // @034F memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0351 stack[-3] // } 034C 80 DUP1 034D 82 DUP3 034E 01 ADD 034F 51 MLOAD 0350 81 DUP2 0351 84 DUP5 0352 01 ADD 0353 52 MSTORE 0354 60 PUSH1 0x20 0356 81 DUP2 0357 01 ADD 0358 90 SWAP1 0359 50 POP 035A 61 PUSH2 0x0343 035D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0353 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0358 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0343 label_035E: // Incoming jump from 0x034B, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x034B, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0363 stack[-6] // @0363 stack[-5] // @0365 stack[-7] // } 035E 5B JUMPDEST 035F 50 POP 0360 50 POP 0361 50 POP 0362 50 POP 0363 90 SWAP1 0364 50 POP 0365 90 SWAP1 0366 81 DUP2 0367 01 ADD 0368 90 SWAP1 0369 60 PUSH1 0x1f 036B 16 AND 036C 80 DUP1 036D 15 ISZERO 036E 61 PUSH2 0x038b 0371 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0368 stack[-7] = stack[-5] + stack[-7] // @036B stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x038b, if !(0x1f & stack[-5]) label_0372: // Incoming jump from 0x0371, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0372 stack[-1] // @0373 stack[-2] // @0376 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @038D stack[-5] // @0393 memory[0x40:0x60] // @0398 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0372 80 DUP1 0373 82 DUP3 0374 03 SUB 0375 80 DUP1 0376 51 MLOAD 0377 60 PUSH1 0x01 0379 83 DUP4 037A 60 PUSH1 0x20 037C 03 SUB 037D 61 PUSH2 0x0100 0380 0A EXP 0381 03 SUB 0382 19 NOT 0383 16 AND 0384 81 DUP2 0385 52 MSTORE 0386 60 PUSH1 0x20 0388 01 ADD 0389 91 SWAP2 038A 50 POP 038B 5B JUMPDEST 038C 50 POP 038D 92 SWAP3 038E 50 POP 038F 50 POP 0390 50 POP 0391 60 PUSH1 0x40 0393 51 MLOAD 0394 80 DUP1 0395 91 SWAP2 0396 03 SUB 0397 90 SWAP1 0398 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0385 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0398 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0399: // Incoming jump from 0x007C, if 0xa293d1e8 == stack[-1] // Inputs[1] { @03A0 msg.data.length } 0399 5B JUMPDEST 039A 61 PUSH2 0x03cf 039D 60 PUSH1 0x04 039F 80 DUP1 03A0 36 CALLDATASIZE 03A1 03 SUB 03A2 60 PUSH1 0x40 03A4 81 DUP2 03A5 10 LT 03A6 15 ISZERO 03A7 61 PUSH2 0x03af 03AA 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @039A stack[0] = 0x03cf // @039D stack[1] = 0x04 // @03A1 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03af, returns to 0x03CF, if !(msg.data.length - 0x04 < 0x40) label_03AB: // Incoming jump from 0x03AA, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @03AE memory[0x00:0x00] } 03AB 60 PUSH1 0x00 03AD 80 DUP1 03AE FD *REVERT // Stack delta = +0 // Outputs[1] { @03AE revert(memory[0x00:0x00]); } // Block terminates label_03AF: // Incoming call from 0x03AA, returns to 0x03CF, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @03B0 stack[-2] // @03B1 stack[-1] // @03B5 msg.data[stack[-2]:stack[-2] + 0x20] // @03BF msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 03AF 5B JUMPDEST 03B0 81 DUP2 03B1 01 ADD 03B2 90 SWAP1 03B3 80 DUP1 03B4 80 DUP1 03B5 35 CALLDATALOAD 03B6 90 SWAP1 03B7 60 PUSH1 0x20 03B9 01 ADD 03BA 90 SWAP1 03BB 92 SWAP3 03BC 91 SWAP2 03BD 90 SWAP1 03BE 80 DUP1 03BF 35 CALLDATALOAD 03C0 90 SWAP1 03C1 60 PUSH1 0x20 03C3 01 ADD 03C4 90 SWAP1 03C5 92 SWAP3 03C6 91 SWAP2 03C7 90 SWAP1 03C8 50 POP 03C9 50 POP 03CA 50 POP 03CB 61 PUSH2 0x0b12 03CE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03BB stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @03C5 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0b12 label_03CF: // Incoming return from call to 0x03AF at 0x03AA // Inputs[4] // { // @03D2 memory[0x40:0x60] // @03D4 stack[-1] // @03DF memory[0x40:0x60] // @03E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03CF 5B JUMPDEST 03D0 60 PUSH1 0x40 03D2 51 MLOAD 03D3 80 DUP1 03D4 82 DUP3 03D5 81 DUP2 03D6 52 MSTORE 03D7 60 PUSH1 0x20 03D9 01 ADD 03DA 91 SWAP2 03DB 50 POP 03DC 50 POP 03DD 60 PUSH1 0x40 03DF 51 MLOAD 03E0 80 DUP1 03E1 91 SWAP2 03E2 03 SUB 03E3 90 SWAP1 03E4 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @03D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @03E4 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_03E5: // Incoming jump from 0x0087, if 0xa9059cbb == stack[-1] // Inputs[1] { @03EC msg.data.length } 03E5 5B JUMPDEST 03E6 61 PUSH2 0x0431 03E9 60 PUSH1 0x04 03EB 80 DUP1 03EC 36 CALLDATASIZE 03ED 03 SUB 03EE 60 PUSH1 0x40 03F0 81 DUP2 03F1 10 LT 03F2 15 ISZERO 03F3 61 PUSH2 0x03fb 03F6 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @03E6 stack[0] = 0x0431 // @03E9 stack[1] = 0x04 // @03ED stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03fb, returns to 0x0431, if !(msg.data.length - 0x04 < 0x40) label_03F7: // Incoming jump from 0x03F6, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @03FA memory[0x00:0x00] } 03F7 60 PUSH1 0x00 03F9 80 DUP1 03FA FD *REVERT // Stack delta = +0 // Outputs[1] { @03FA revert(memory[0x00:0x00]); } // Block terminates label_03FB: // Incoming call from 0x03F6, returns to 0x0431, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @03FC stack[-2] // @03FD stack[-1] // @0401 msg.data[stack[-2]:stack[-2] + 0x20] // @0421 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 03FB 5B JUMPDEST 03FC 81 DUP2 03FD 01 ADD 03FE 90 SWAP1 03FF 80 DUP1 0400 80 DUP1 0401 35 CALLDATALOAD 0402 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0417 16 AND 0418 90 SWAP1 0419 60 PUSH1 0x20 041B 01 ADD 041C 90 SWAP1 041D 92 SWAP3 041E 91 SWAP2 041F 90 SWAP1 0420 80 DUP1 0421 35 CALLDATALOAD 0422 90 SWAP1 0423 60 PUSH1 0x20 0425 01 ADD 0426 90 SWAP1 0427 92 SWAP3 0428 91 SWAP2 0429 90 SWAP1 042A 50 POP 042B 50 POP 042C 50 POP 042D 61 PUSH2 0x0b2c 0430 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @041D stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0427 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0b2c label_0431: // Incoming return from call to 0x03FB at 0x03F6 // Inputs[4] // { // @0434 memory[0x40:0x60] // @0436 stack[-1] // @0445 memory[0x40:0x60] // @044A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0431 5B JUMPDEST 0432 60 PUSH1 0x40 0434 51 MLOAD 0435 80 DUP1 0436 82 DUP3 0437 15 ISZERO 0438 15 ISZERO 0439 15 ISZERO 043A 15 ISZERO 043B 81 DUP2 043C 52 MSTORE 043D 60 PUSH1 0x20 043F 01 ADD 0440 91 SWAP2 0441 50 POP 0442 50 POP 0443 60 PUSH1 0x40 0445 51 MLOAD 0446 80 DUP1 0447 91 SWAP2 0448 03 SUB 0449 90 SWAP1 044A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @043C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @044A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_044B: // Incoming jump from 0x0040, if 0xb5931f7c == stack[-1] // Inputs[1] { @0452 msg.data.length } 044B 5B JUMPDEST 044C 61 PUSH2 0x0481 044F 60 PUSH1 0x04 0451 80 DUP1 0452 36 CALLDATASIZE 0453 03 SUB 0454 60 PUSH1 0x40 0456 81 DUP2 0457 10 LT 0458 15 ISZERO 0459 61 PUSH2 0x0461 045C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @044C stack[0] = 0x0481 // @044F stack[1] = 0x04 // @0453 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0461, returns to 0x0481, if !(msg.data.length - 0x04 < 0x40) label_045D: // Incoming jump from 0x045C, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0460 memory[0x00:0x00] } 045D 60 PUSH1 0x00 045F 80 DUP1 0460 FD *REVERT // Stack delta = +0 // Outputs[1] { @0460 revert(memory[0x00:0x00]); } // Block terminates label_0461: // Incoming call from 0x045C, returns to 0x0481, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0462 stack[-2] // @0463 stack[-1] // @0467 msg.data[stack[-2]:stack[-2] + 0x20] // @0471 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0461 5B JUMPDEST 0462 81 DUP2 0463 01 ADD 0464 90 SWAP1 0465 80 DUP1 0466 80 DUP1 0467 35 CALLDATALOAD 0468 90 SWAP1 0469 60 PUSH1 0x20 046B 01 ADD 046C 90 SWAP1 046D 92 SWAP3 046E 91 SWAP2 046F 90 SWAP1 0470 80 DUP1 0471 35 CALLDATALOAD 0472 90 SWAP1 0473 60 PUSH1 0x20 0475 01 ADD 0476 90 SWAP1 0477 92 SWAP3 0478 91 SWAP2 0479 90 SWAP1 047A 50 POP 047B 50 POP 047C 50 POP 047D 61 PUSH2 0x0cb5 0480 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @046D stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0477 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0cb5 label_0481: // Incoming return from call to 0x0461 at 0x045C // Inputs[4] // { // @0484 memory[0x40:0x60] // @0486 stack[-1] // @0491 memory[0x40:0x60] // @0496 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0481 5B JUMPDEST 0482 60 PUSH1 0x40 0484 51 MLOAD 0485 80 DUP1 0486 82 DUP3 0487 81 DUP2 0488 52 MSTORE 0489 60 PUSH1 0x20 048B 01 ADD 048C 91 SWAP2 048D 50 POP 048E 50 POP 048F 60 PUSH1 0x40 0491 51 MLOAD 0492 80 DUP1 0493 91 SWAP2 0494 03 SUB 0495 90 SWAP1 0496 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0488 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0496 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0497: // Incoming jump from 0x004B, if 0xd05c78da == stack[-1] // Inputs[1] { @049E msg.data.length } 0497 5B JUMPDEST 0498 61 PUSH2 0x04cd 049B 60 PUSH1 0x04 049D 80 DUP1 049E 36 CALLDATASIZE 049F 03 SUB 04A0 60 PUSH1 0x40 04A2 81 DUP2 04A3 10 LT 04A4 15 ISZERO 04A5 61 PUSH2 0x04ad 04A8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0498 stack[0] = 0x04cd // @049B stack[1] = 0x04 // @049F stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04ad, returns to 0x04CD, if !(msg.data.length - 0x04 < 0x40) label_04A9: // Incoming jump from 0x04A8, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @04AC memory[0x00:0x00] } 04A9 60 PUSH1 0x00 04AB 80 DUP1 04AC FD *REVERT // Stack delta = +0 // Outputs[1] { @04AC revert(memory[0x00:0x00]); } // Block terminates label_04AD: // Incoming call from 0x04A8, returns to 0x04CD, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @04AE stack[-2] // @04AF stack[-1] // @04B3 msg.data[stack[-2]:stack[-2] + 0x20] // @04BD msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 04AD 5B JUMPDEST 04AE 81 DUP2 04AF 01 ADD 04B0 90 SWAP1 04B1 80 DUP1 04B2 80 DUP1 04B3 35 CALLDATALOAD 04B4 90 SWAP1 04B5 60 PUSH1 0x20 04B7 01 ADD 04B8 90 SWAP1 04B9 92 SWAP3 04BA 91 SWAP2 04BB 90 SWAP1 04BC 80 DUP1 04BD 35 CALLDATALOAD 04BE 90 SWAP1 04BF 60 PUSH1 0x20 04C1 01 ADD 04C2 90 SWAP1 04C3 92 SWAP3 04C4 91 SWAP2 04C5 90 SWAP1 04C6 50 POP 04C7 50 POP 04C8 50 POP 04C9 61 PUSH2 0x0cd5 04CC 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @04B9 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @04C3 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0cd5 label_04CD: // Incoming return from call to 0x04AD at 0x04A8 // Inputs[4] // { // @04D0 memory[0x40:0x60] // @04D2 stack[-1] // @04DD memory[0x40:0x60] // @04E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 04CD 5B JUMPDEST 04CE 60 PUSH1 0x40 04D0 51 MLOAD 04D1 80 DUP1 04D2 82 DUP3 04D3 81 DUP2 04D4 52 MSTORE 04D5 60 PUSH1 0x20 04D7 01 ADD 04D8 91 SWAP2 04D9 50 POP 04DA 50 POP 04DB 60 PUSH1 0x40 04DD 51 MLOAD 04DE 80 DUP1 04DF 91 SWAP2 04E0 03 SUB 04E1 90 SWAP1 04E2 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @04D4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @04E2 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_04E3: // Incoming jump from 0x0056, if 0xdd62ed3e == stack[-1] // Inputs[1] { @04EA msg.data.length } 04E3 5B JUMPDEST 04E4 61 PUSH2 0x0545 04E7 60 PUSH1 0x04 04E9 80 DUP1 04EA 36 CALLDATASIZE 04EB 03 SUB 04EC 60 PUSH1 0x40 04EE 81 DUP2 04EF 10 LT 04F0 15 ISZERO 04F1 61 PUSH2 0x04f9 04F4 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @04E4 stack[0] = 0x0545 // @04E7 stack[1] = 0x04 // @04EB stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04f9, returns to 0x0545, if !(msg.data.length - 0x04 < 0x40) label_04F5: // Incoming jump from 0x04F4, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @04F8 memory[0x00:0x00] } 04F5 60 PUSH1 0x00 04F7 80 DUP1 04F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F8 revert(memory[0x00:0x00]); } // Block terminates label_04F9: // Incoming call from 0x04F4, returns to 0x0545, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @04FA stack[-2] // @04FB stack[-1] // @04FF msg.data[stack[-2]:stack[-2] + 0x20] // @051F msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 04F9 5B JUMPDEST 04FA 81 DUP2 04FB 01 ADD 04FC 90 SWAP1 04FD 80 DUP1 04FE 80 DUP1 04FF 35 CALLDATALOAD 0500 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0515 16 AND 0516 90 SWAP1 0517 60 PUSH1 0x20 0519 01 ADD 051A 90 SWAP1 051B 92 SWAP3 051C 91 SWAP2 051D 90 SWAP1 051E 80 DUP1 051F 35 CALLDATALOAD 0520 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0535 16 AND 0536 90 SWAP1 0537 60 PUSH1 0x20 0539 01 ADD 053A 90 SWAP1 053B 92 SWAP3 053C 91 SWAP2 053D 90 SWAP1 053E 50 POP 053F 50 POP 0540 50 POP 0541 61 PUSH2 0x0d02 0544 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @051B stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @053B stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0d02 label_0545: // Incoming return from call to 0x04F9 at 0x04F4 // Inputs[4] // { // @0548 memory[0x40:0x60] // @054A stack[-1] // @0555 memory[0x40:0x60] // @055A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0545 5B JUMPDEST 0546 60 PUSH1 0x40 0548 51 MLOAD 0549 80 DUP1 054A 82 DUP3 054B 81 DUP2 054C 52 MSTORE 054D 60 PUSH1 0x20 054F 01 ADD 0550 91 SWAP2 0551 50 POP 0552 50 POP 0553 60 PUSH1 0x40 0555 51 MLOAD 0556 80 DUP1 0557 91 SWAP2 0558 03 SUB 0559 90 SWAP1 055A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @054C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @055A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_055B: // Incoming jump from 0x0061, if 0xe6cb9013 == stack[-1] // Inputs[1] { @0562 msg.data.length } 055B 5B JUMPDEST 055C 61 PUSH2 0x0591 055F 60 PUSH1 0x04 0561 80 DUP1 0562 36 CALLDATASIZE 0563 03 SUB 0564 60 PUSH1 0x40 0566 81 DUP2 0567 10 LT 0568 15 ISZERO 0569 61 PUSH2 0x0571 056C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @055C stack[0] = 0x0591 // @055F stack[1] = 0x04 // @0563 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0571, returns to 0x0591, if !(msg.data.length - 0x04 < 0x40) label_056D: // Incoming jump from 0x056C, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0570 memory[0x00:0x00] } 056D 60 PUSH1 0x00 056F 80 DUP1 0570 FD *REVERT // Stack delta = +0 // Outputs[1] { @0570 revert(memory[0x00:0x00]); } // Block terminates label_0571: // Incoming call from 0x056C, returns to 0x0591, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0572 stack[-2] // @0573 stack[-1] // @0577 msg.data[stack[-2]:stack[-2] + 0x20] // @0581 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0571 5B JUMPDEST 0572 81 DUP2 0573 01 ADD 0574 90 SWAP1 0575 80 DUP1 0576 80 DUP1 0577 35 CALLDATALOAD 0578 90 SWAP1 0579 60 PUSH1 0x20 057B 01 ADD 057C 90 SWAP1 057D 92 SWAP3 057E 91 SWAP2 057F 90 SWAP1 0580 80 DUP1 0581 35 CALLDATALOAD 0582 90 SWAP1 0583 60 PUSH1 0x20 0585 01 ADD 0586 90 SWAP1 0587 92 SWAP3 0588 91 SWAP2 0589 90 SWAP1 058A 50 POP 058B 50 POP 058C 50 POP 058D 61 PUSH2 0x0d89 0590 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @057D stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0587 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0d89 label_0591: // Incoming return from call to 0x0571 at 0x056C // Inputs[4] // { // @0594 memory[0x40:0x60] // @0596 stack[-1] // @05A1 memory[0x40:0x60] // @05A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0591 5B JUMPDEST 0592 60 PUSH1 0x40 0594 51 MLOAD 0595 80 DUP1 0596 82 DUP3 0597 81 DUP2 0598 52 MSTORE 0599 60 PUSH1 0x20 059B 01 ADD 059C 91 SWAP2 059D 50 POP 059E 50 POP 059F 60 PUSH1 0x40 05A1 51 MLOAD 05A2 80 DUP1 05A3 91 SWAP2 05A4 03 SUB 05A5 90 SWAP1 05A6 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0598 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @05A6 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_05A7: // Incoming call from 0x00F6, returns to 0x00F7 // Inputs[3] // { // @05AB storage[0x00] // @05CC memory[0x40:0x60] // @05DF storage[0x00] // } 05A7 5B JUMPDEST 05A8 60 PUSH1 0x00 05AA 80 DUP1 05AB 54 SLOAD 05AC 60 PUSH1 0x01 05AE 81 DUP2 05AF 60 PUSH1 0x01 05B1 16 AND 05B2 15 ISZERO 05B3 61 PUSH2 0x0100 05B6 02 MUL 05B7 03 SUB 05B8 16 AND 05B9 60 PUSH1 0x02 05BB 90 SWAP1 05BC 04 DIV 05BD 80 DUP1 05BE 60 PUSH1 0x1f 05C0 01 ADD 05C1 60 PUSH1 0x20 05C3 80 DUP1 05C4 91 SWAP2 05C5 04 DIV 05C6 02 MUL 05C7 60 PUSH1 0x20 05C9 01 ADD 05CA 60 PUSH1 0x40 05CC 51 MLOAD 05CD 90 SWAP1 05CE 81 DUP2 05CF 01 ADD 05D0 60 PUSH1 0x40 05D2 52 MSTORE 05D3 80 DUP1 05D4 92 SWAP3 05D5 91 SWAP2 05D6 90 SWAP1 05D7 81 DUP2 05D8 81 DUP2 05D9 52 MSTORE 05DA 60 PUSH1 0x20 05DC 01 ADD 05DD 82 DUP3 05DE 80 DUP1 05DF 54 SLOAD 05E0 60 PUSH1 0x01 05E2 81 DUP2 05E3 60 PUSH1 0x01 05E5 16 AND 05E6 15 ISZERO 05E7 61 PUSH2 0x0100 05EA 02 MUL 05EB 03 SUB 05EC 16 AND 05ED 60 PUSH1 0x02 05EF 90 SWAP1 05F0 04 DIV 05F1 80 DUP1 05F2 15 ISZERO 05F3 61 PUSH2 0x063d 05F6 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @05D2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) / 0x20 * 0x20 // @05D4 stack[0] = memory[0x40:0x60] // @05D5 stack[1] = 0x00 // @05D6 stack[2] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // @05D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // @05DC stack[3] = 0x20 + memory[0x40:0x60] // @05DD stack[4] = 0x00 // @05F0 stack[5] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // } // Block ends with conditional jump to 0x063d, if !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) label_05F7: // Incoming jump from 0x05F6, if not !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) // Inputs[1] { @05F7 stack[-1] } 05F7 80 DUP1 05F8 60 PUSH1 0x1f 05FA 10 LT 05FB 61 PUSH2 0x0612 05FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0612, if 0x1f < stack[-1] label_05FF: // Incoming jump from 0x05FE, if not 0x1f < stack[-1] // Inputs[4] // { // @0603 stack[-2] // @0604 storage[stack[-2]] // @0607 stack[-3] // @0609 stack[-1] // } 05FF 61 PUSH2 0x0100 0602 80 DUP1 0603 83 DUP4 0604 54 SLOAD 0605 04 DIV 0606 02 MUL 0607 83 DUP4 0608 52 MSTORE 0609 91 SWAP2 060A 60 PUSH1 0x20 060C 01 ADD 060D 91 SWAP2 060E 61 PUSH2 0x063d 0611 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0608 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @060D stack[-1] = stack[-1] // @060D stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x063d label_0612: // Incoming jump from 0x05FE, if 0x1f < stack[-1] // Inputs[5] // { // @0613 stack[-3] // @0614 stack[-1] // @0616 stack[-2] // @061E memory[0x00:0x20] // @0622 storage[keccak256(memory[0x00:0x20])] // } 0612 5B JUMPDEST 0613 82 DUP3 0614 01 ADD 0615 91 SWAP2 0616 90 SWAP1 0617 60 PUSH1 0x00 0619 52 MSTORE 061A 60 PUSH1 0x20 061C 60 PUSH1 0x00 061E 20 SHA3 061F 90 SWAP1 0620 5B JUMPDEST 0621 81 DUP2 0622 54 SLOAD 0623 81 DUP2 0624 52 MSTORE 0625 90 SWAP1 0626 60 PUSH1 0x01 0628 01 ADD 0629 90 SWAP1 062A 60 PUSH1 0x20 062C 01 ADD 062D 80 DUP1 062E 83 DUP4 062F 11 GT 0630 61 PUSH2 0x0620 0633 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0615 stack[-3] = stack[-3] + stack[-1] // @0619 memory[0x00:0x20] = stack[-2] // @0624 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0629 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @062C stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0620, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0634: // Incoming jump from 0x0633, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0633, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0634 stack[-3] // @0635 stack[-1] // } 0634 82 DUP3 0635 90 SWAP1 0636 03 SUB 0637 60 PUSH1 0x1f 0639 16 AND 063A 82 DUP3 063B 01 ADD 063C 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @063C stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @063C stack[-1] = stack[-3] // } // Block continues label_063D: // Incoming jump from 0x0611 // Incoming jump from 0x05F6, if !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) // Incoming jump from 0x063C // Inputs[1] { @0643 stack[-7] } 063D 5B JUMPDEST 063E 50 POP 063F 50 POP 0640 50 POP 0641 50 POP 0642 50 POP 0643 81 DUP2 0644 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0645: // Incoming jump from 0x01BD // Inputs[10] // { // @0648 stack[-1] // @064D msg.sender // @0687 memory[0x00:0x40] // @068A stack[-2] // @06C4 memory[0x00:0x40] // @06E0 msg.sender // @071B memory[0x40:0x60] // @0728 memory[0x40:0x60] // @072D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0732 stack[-3] // } 0645 5B JUMPDEST 0646 60 PUSH1 0x00 0648 81 DUP2 0649 60 PUSH1 0x05 064B 60 PUSH1 0x00 064D 33 CALLER 064E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0663 16 AND 0664 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0679 16 AND 067A 81 DUP2 067B 52 MSTORE 067C 60 PUSH1 0x20 067E 01 ADD 067F 90 SWAP1 0680 81 DUP2 0681 52 MSTORE 0682 60 PUSH1 0x20 0684 01 ADD 0685 60 PUSH1 0x00 0687 20 SHA3 0688 60 PUSH1 0x00 068A 85 DUP6 068B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06A0 16 AND 06A1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06B6 16 AND 06B7 81 DUP2 06B8 52 MSTORE 06B9 60 PUSH1 0x20 06BB 01 ADD 06BC 90 SWAP1 06BD 81 DUP2 06BE 52 MSTORE 06BF 60 PUSH1 0x20 06C1 01 ADD 06C2 60 PUSH1 0x00 06C4 20 SHA3 06C5 81 DUP2 06C6 90 SWAP1 06C7 55 SSTORE 06C8 50 POP 06C9 82 DUP3 06CA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06DF 16 AND 06E0 33 CALLER 06E1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06F6 16 AND 06F7 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0718 84 DUP5 0719 60 PUSH1 0x40 071B 51 MLOAD 071C 80 DUP1 071D 82 DUP3 071E 81 DUP2 071F 52 MSTORE 0720 60 PUSH1 0x20 0722 01 ADD 0723 91 SWAP2 0724 50 POP 0725 50 POP 0726 60 PUSH1 0x40 0728 51 MLOAD 0729 80 DUP1 072A 91 SWAP2 072B 03 SUB 072C 90 SWAP1 072D A3 LOG3 072E 60 PUSH1 0x01 0730 90 SWAP1 0731 50 POP 0732 92 SWAP3 0733 91 SWAP2 0734 50 POP 0735 50 POP 0736 56 *JUMP // Stack delta = -2 // Outputs[8] // { // @067B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0681 memory[0x20:0x40] = 0x05 // @06B8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @06BE memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @06C7 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @071F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @072D log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // @0732 stack[-3] = 0x01 // } // Block ends with unconditional jump to stack[-3] label_0737: // Incoming call from 0x01DF, returns to 0x01E0 // Inputs[4] // { // @0778 memory[0x00:0x40] // @0779 storage[keccak256(memory[0x00:0x40])] // @077C storage[0x03] // @0780 stack[-1] // } 0737 5B JUMPDEST 0738 60 PUSH1 0x00 073A 60 PUSH1 0x04 073C 60 PUSH1 0x00 073E 80 DUP1 073F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0754 16 AND 0755 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 076A 16 AND 076B 81 DUP2 076C 52 MSTORE 076D 60 PUSH1 0x20 076F 01 ADD 0770 90 SWAP1 0771 81 DUP2 0772 52 MSTORE 0773 60 PUSH1 0x20 0775 01 ADD 0776 60 PUSH1 0x00 0778 20 SHA3 0779 54 SLOAD 077A 60 PUSH1 0x03 077C 54 SLOAD 077D 03 SUB 077E 90 SWAP1 077F 50 POP 0780 90 SWAP1 0781 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @076C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // @0772 memory[0x20:0x40] = 0x04 // @0780 stack[-1] = storage[0x03] - storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-1] label_0782: // Incoming jump from 0x0261 // Inputs[4] // { // @078C stack[-3] // @07C6 memory[0x00:0x40] // @07C7 storage[keccak256(memory[0x00:0x40])] // @07C8 stack[-1] // } 0782 5B JUMPDEST 0783 60 PUSH1 0x00 0785 61 PUSH2 0x07cd 0788 60 PUSH1 0x04 078A 60 PUSH1 0x00 078C 86 DUP7 078D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07A2 16 AND 07A3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07B8 16 AND 07B9 81 DUP2 07BA 52 MSTORE 07BB 60 PUSH1 0x20 07BD 01 ADD 07BE 90 SWAP1 07BF 81 DUP2 07C0 52 MSTORE 07C1 60 PUSH1 0x20 07C3 01 ADD 07C4 60 PUSH1 0x00 07C6 20 SHA3 07C7 54 SLOAD 07C8 83 DUP4 07C9 61 PUSH2 0x0b12 07CC 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0783 stack[0] = 0x00 // @0785 stack[1] = 0x07cd // @07BA memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @07C0 memory[0x20:0x40] = 0x04 // @07C7 stack[2] = storage[keccak256(memory[0x00:0x40])] // @07C8 stack[3] = stack[-1] // } // Block ends with call to 0x0b12, returns to 0x07CD label_07CD: // Incoming return from call to 0x0B12 at 0x07CC // Inputs[8] // { // @07D2 stack[-5] // @080C memory[0x00:0x40] // @080D stack[-1] // @0852 memory[0x00:0x40] // @0855 msg.sender // @088F memory[0x00:0x40] // @0890 storage[keccak256(memory[0x00:0x40])] // @0891 stack[-3] // } 07CD 5B JUMPDEST 07CE 60 PUSH1 0x04 07D0 60 PUSH1 0x00 07D2 86 DUP7 07D3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07E8 16 AND 07E9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07FE 16 AND 07FF 81 DUP2 0800 52 MSTORE 0801 60 PUSH1 0x20 0803 01 ADD 0804 90 SWAP1 0805 81 DUP2 0806 52 MSTORE 0807 60 PUSH1 0x20 0809 01 ADD 080A 60 PUSH1 0x00 080C 20 SHA3 080D 81 DUP2 080E 90 SWAP1 080F 55 SSTORE 0810 50 POP 0811 61 PUSH2 0x0896 0814 60 PUSH1 0x05 0816 60 PUSH1 0x00 0818 86 DUP7 0819 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 082E 16 AND 082F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0844 16 AND 0845 81 DUP2 0846 52 MSTORE 0847 60 PUSH1 0x20 0849 01 ADD 084A 90 SWAP1 084B 81 DUP2 084C 52 MSTORE 084D 60 PUSH1 0x20 084F 01 ADD 0850 60 PUSH1 0x00 0852 20 SHA3 0853 60 PUSH1 0x00 0855 33 CALLER 0856 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 086B 16 AND 086C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0881 16 AND 0882 81 DUP2 0883 52 MSTORE 0884 60 PUSH1 0x20 0886 01 ADD 0887 90 SWAP1 0888 81 DUP2 0889 52 MSTORE 088A 60 PUSH1 0x20 088C 01 ADD 088D 60 PUSH1 0x00 088F 20 SHA3 0890 54 SLOAD 0891 83 DUP4 0892 61 PUSH2 0x0b12 0895 56 *JUMP // Stack delta = +2 // Outputs[10] // { // @0800 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0806 memory[0x20:0x40] = 0x04 // @080F storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0811 stack[-1] = 0x0896 // @0846 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @084C memory[0x20:0x40] = 0x05 // @0883 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0889 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0890 stack[0] = storage[keccak256(memory[0x00:0x40])] // @0891 stack[1] = stack[-3] // } // Block ends with call to 0x0b12, returns to 0x0896 label_0896: // Incoming return from call to 0x0B12 at 0x0895 // Inputs[9] // { // @089B stack[-5] // @08D5 memory[0x00:0x40] // @08D8 msg.sender // @0912 memory[0x00:0x40] // @0913 stack[-1] // @091E stack[-4] // @0958 memory[0x00:0x40] // @0959 storage[keccak256(memory[0x00:0x40])] // @095A stack[-3] // } 0896 5B JUMPDEST 0897 60 PUSH1 0x05 0899 60 PUSH1 0x00 089B 86 DUP7 089C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08B1 16 AND 08B2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08C7 16 AND 08C8 81 DUP2 08C9 52 MSTORE 08CA 60 PUSH1 0x20 08CC 01 ADD 08CD 90 SWAP1 08CE 81 DUP2 08CF 52 MSTORE 08D0 60 PUSH1 0x20 08D2 01 ADD 08D3 60 PUSH1 0x00 08D5 20 SHA3 08D6 60 PUSH1 0x00 08D8 33 CALLER 08D9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08EE 16 AND 08EF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0904 16 AND 0905 81 DUP2 0906 52 MSTORE 0907 60 PUSH1 0x20 0909 01 ADD 090A 90 SWAP1 090B 81 DUP2 090C 52 MSTORE 090D 60 PUSH1 0x20 090F 01 ADD 0910 60 PUSH1 0x00 0912 20 SHA3 0913 81 DUP2 0914 90 SWAP1 0915 55 SSTORE 0916 50 POP 0917 61 PUSH2 0x095f 091A 60 PUSH1 0x04 091C 60 PUSH1 0x00 091E 85 DUP6 091F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0934 16 AND 0935 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 094A 16 AND 094B 81 DUP2 094C 52 MSTORE 094D 60 PUSH1 0x20 094F 01 ADD 0950 90 SWAP1 0951 81 DUP2 0952 52 MSTORE 0953 60 PUSH1 0x20 0955 01 ADD 0956 60 PUSH1 0x00 0958 20 SHA3 0959 54 SLOAD 095A 83 DUP4 095B 61 PUSH2 0x0d89 095E 56 *JUMP // Stack delta = +2 // Outputs[10] // { // @08C9 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @08CF memory[0x20:0x40] = 0x05 // @0906 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @090C memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0915 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0917 stack[-1] = 0x095f // @094C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0952 memory[0x20:0x40] = 0x04 // @0959 stack[0] = storage[keccak256(memory[0x00:0x40])] // @095A stack[1] = stack[-3] // } // Block ends with call to 0x0d89, returns to 0x095F label_095F: // Incoming return from call to 0x0D89 at 0x095E // Inputs[10] // { // @0964 stack[-4] // @099E memory[0x00:0x40] // @099F stack[-1] // @09BA stack[-5] // @09F2 stack[-3] // @09F5 memory[0x40:0x60] // @0A02 memory[0x40:0x60] // @0A07 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0A0A stack[-2] // @0A0C stack[-6] // } 095F 5B JUMPDEST 0960 60 PUSH1 0x04 0962 60 PUSH1 0x00 0964 85 DUP6 0965 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 097A 16 AND 097B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0990 16 AND 0991 81 DUP2 0992 52 MSTORE 0993 60 PUSH1 0x20 0995 01 ADD 0996 90 SWAP1 0997 81 DUP2 0998 52 MSTORE 0999 60 PUSH1 0x20 099B 01 ADD 099C 60 PUSH1 0x00 099E 20 SHA3 099F 81 DUP2 09A0 90 SWAP1 09A1 55 SSTORE 09A2 50 POP 09A3 82 DUP3 09A4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09B9 16 AND 09BA 84 DUP5 09BB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09D0 16 AND 09D1 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 09F2 84 DUP5 09F3 60 PUSH1 0x40 09F5 51 MLOAD 09F6 80 DUP1 09F7 82 DUP3 09F8 81 DUP2 09F9 52 MSTORE 09FA 60 PUSH1 0x20 09FC 01 ADD 09FD 91 SWAP2 09FE 50 POP 09FF 50 POP 0A00 60 PUSH1 0x40 0A02 51 MLOAD 0A03 80 DUP1 0A04 91 SWAP2 0A05 03 SUB 0A06 90 SWAP1 0A07 A3 LOG3 0A08 60 PUSH1 0x01 0A0A 90 SWAP1 0A0B 50 POP 0A0C 93 SWAP4 0A0D 92 SWAP3 0A0E 50 POP 0A0F 50 POP 0A10 50 POP 0A11 56 *JUMP // Stack delta = -5 // Outputs[6] // { // @0992 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0998 memory[0x20:0x40] = 0x04 // @09A1 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @09F9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @0A07 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]); // @0A0C stack[-6] = 0x01 // } // Block ends with unconditional jump to stack[-6] label_0A12: // Incoming call from 0x0283, returns to 0x0284 // Inputs[2] // { // @0A18 storage[0x02] // @0A23 stack[-1] // } 0A12 5B JUMPDEST 0A13 60 PUSH1 0x02 0A15 60 PUSH1 0x00 0A17 90 SWAP1 0A18 54 SLOAD 0A19 90 SWAP1 0A1A 61 PUSH2 0x0100 0A1D 0A EXP 0A1E 90 SWAP1 0A1F 04 DIV 0A20 60 PUSH1 0xff 0A22 16 AND 0A23 81 DUP2 0A24 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A22 stack[0] = 0xff & storage[0x02] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0A25: // Incoming call from 0x02A7, returns to 0x02A8 // Inputs[2] // { // @0A28 storage[0x03] // @0A29 stack[-1] // } 0A25 5B JUMPDEST 0A26 60 PUSH1 0x03 0A28 54 SLOAD 0A29 81 DUP2 0A2A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A28 stack[0] = storage[0x03] } // Block ends with unconditional jump to stack[-1] label_0A2B: // Incoming jump from 0x02FF // Inputs[4] // { // @0A32 stack[-1] // @0A6C memory[0x00:0x40] // @0A6D storage[keccak256(memory[0x00:0x40])] // @0A70 stack[-2] // } 0A2B 5B JUMPDEST 0A2C 60 PUSH1 0x00 0A2E 60 PUSH1 0x04 0A30 60 PUSH1 0x00 0A32 83 DUP4 0A33 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A48 16 AND 0A49 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A5E 16 AND 0A5F 81 DUP2 0A60 52 MSTORE 0A61 60 PUSH1 0x20 0A63 01 ADD 0A64 90 SWAP1 0A65 81 DUP2 0A66 52 MSTORE 0A67 60 PUSH1 0x20 0A69 01 ADD 0A6A 60 PUSH1 0x00 0A6C 20 SHA3 0A6D 54 SLOAD 0A6E 90 SWAP1 0A6F 50 POP 0A70 91 SWAP2 0A71 90 SWAP1 0A72 50 POP 0A73 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0A60 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0A66 memory[0x20:0x40] = 0x04 // @0A70 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0A74: // Incoming call from 0x031D, returns to 0x031E // Inputs[3] // { // @0A78 storage[0x01] // @0A99 memory[0x40:0x60] // @0AAC storage[0x01] // } 0A74 5B JUMPDEST 0A75 60 PUSH1 0x01 0A77 80 DUP1 0A78 54 SLOAD 0A79 60 PUSH1 0x01 0A7B 81 DUP2 0A7C 60 PUSH1 0x01 0A7E 16 AND 0A7F 15 ISZERO 0A80 61 PUSH2 0x0100 0A83 02 MUL 0A84 03 SUB 0A85 16 AND 0A86 60 PUSH1 0x02 0A88 90 SWAP1 0A89 04 DIV 0A8A 80 DUP1 0A8B 60 PUSH1 0x1f 0A8D 01 ADD 0A8E 60 PUSH1 0x20 0A90 80 DUP1 0A91 91 SWAP2 0A92 04 DIV 0A93 02 MUL 0A94 60 PUSH1 0x20 0A96 01 ADD 0A97 60 PUSH1 0x40 0A99 51 MLOAD 0A9A 90 SWAP1 0A9B 81 DUP2 0A9C 01 ADD 0A9D 60 PUSH1 0x40 0A9F 52 MSTORE 0AA0 80 DUP1 0AA1 92 SWAP3 0AA2 91 SWAP2 0AA3 90 SWAP1 0AA4 81 DUP2 0AA5 81 DUP2 0AA6 52 MSTORE 0AA7 60 PUSH1 0x20 0AA9 01 ADD 0AAA 82 DUP3 0AAB 80 DUP1 0AAC 54 SLOAD 0AAD 60 PUSH1 0x01 0AAF 81 DUP2 0AB0 60 PUSH1 0x01 0AB2 16 AND 0AB3 15 ISZERO 0AB4 61 PUSH2 0x0100 0AB7 02 MUL 0AB8 03 SUB 0AB9 16 AND 0ABA 60 PUSH1 0x02 0ABC 90 SWAP1 0ABD 04 DIV 0ABE 80 DUP1 0ABF 15 ISZERO 0AC0 61 PUSH2 0x0b0a 0AC3 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @0A9F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) / 0x20 * 0x20 // @0AA1 stack[0] = memory[0x40:0x60] // @0AA2 stack[1] = 0x01 // @0AA3 stack[2] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // @0AA6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // @0AA9 stack[3] = 0x20 + memory[0x40:0x60] // @0AAA stack[4] = 0x01 // @0ABD stack[5] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // } // Block ends with conditional jump to 0x0b0a, if !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) label_0AC4: // Incoming jump from 0x0AC3, if not !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) // Inputs[1] { @0AC4 stack[-1] } 0AC4 80 DUP1 0AC5 60 PUSH1 0x1f 0AC7 10 LT 0AC8 61 PUSH2 0x0adf 0ACB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0adf, if 0x1f < stack[-1] label_0ACC: // Incoming jump from 0x0ACB, if not 0x1f < stack[-1] // Inputs[4] // { // @0AD0 stack[-2] // @0AD1 storage[stack[-2]] // @0AD4 stack[-3] // @0AD6 stack[-1] // } 0ACC 61 PUSH2 0x0100 0ACF 80 DUP1 0AD0 83 DUP4 0AD1 54 SLOAD 0AD2 04 DIV 0AD3 02 MUL 0AD4 83 DUP4 0AD5 52 MSTORE 0AD6 91 SWAP2 0AD7 60 PUSH1 0x20 0AD9 01 ADD 0ADA 91 SWAP2 0ADB 61 PUSH2 0x0b0a 0ADE 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0AD5 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0ADA stack[-1] = stack[-1] // @0ADA stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0b0a label_0ADF: // Incoming jump from 0x0ACB, if 0x1f < stack[-1] // Inputs[5] // { // @0AE0 stack[-3] // @0AE1 stack[-1] // @0AE3 stack[-2] // @0AEB memory[0x00:0x20] // @0AEF storage[keccak256(memory[0x00:0x20])] // } 0ADF 5B JUMPDEST 0AE0 82 DUP3 0AE1 01 ADD 0AE2 91 SWAP2 0AE3 90 SWAP1 0AE4 60 PUSH1 0x00 0AE6 52 MSTORE 0AE7 60 PUSH1 0x20 0AE9 60 PUSH1 0x00 0AEB 20 SHA3 0AEC 90 SWAP1 0AED 5B JUMPDEST 0AEE 81 DUP2 0AEF 54 SLOAD 0AF0 81 DUP2 0AF1 52 MSTORE 0AF2 90 SWAP1 0AF3 60 PUSH1 0x01 0AF5 01 ADD 0AF6 90 SWAP1 0AF7 60 PUSH1 0x20 0AF9 01 ADD 0AFA 80 DUP1 0AFB 83 DUP4 0AFC 11 GT 0AFD 61 PUSH2 0x0aed 0B00 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0AE2 stack[-3] = stack[-3] + stack[-1] // @0AE6 memory[0x00:0x20] = stack[-2] // @0AF1 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0AF6 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0AF9 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0aed, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0B01: // Incoming jump from 0x0B00, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0B00, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0B01 stack[-3] // @0B02 stack[-1] // } 0B01 82 DUP3 0B02 90 SWAP1 0B03 03 SUB 0B04 60 PUSH1 0x1f 0B06 16 AND 0B07 82 DUP3 0B08 01 ADD 0B09 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0B09 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0B09 stack[-1] = stack[-3] // } // Block continues label_0B0A: // Incoming jump from 0x0AC3, if !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) // Incoming jump from 0x0ADE // Incoming jump from 0x0B09 // Inputs[1] { @0B10 stack[-7] } 0B0A 5B JUMPDEST 0B0B 50 POP 0B0C 50 POP 0B0D 50 POP 0B0E 50 POP 0B0F 50 POP 0B10 81 DUP2 0B11 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0B12: // Incoming jump from 0x03CE // Incoming call from 0x0895, returns to 0x0896 // Incoming call from 0x07CC, returns to 0x07CD // Incoming call from 0x0B76, returns to 0x0B77 // Inputs[2] // { // @0B15 stack[-2] // @0B16 stack[-1] // } 0B12 5B JUMPDEST 0B13 60 PUSH1 0x00 0B15 82 DUP3 0B16 82 DUP3 0B17 11 GT 0B18 15 ISZERO 0B19 61 PUSH2 0x0b21 0B1C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B13 stack[0] = 0x00 } // Block ends with conditional jump to 0x0b21, if !(stack[-1] > stack[-2]) label_0B1D: // Incoming jump from 0x0B1C, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0B20 memory[0x00:0x00] } 0B1D 60 PUSH1 0x00 0B1F 80 DUP1 0B20 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B20 revert(memory[0x00:0x00]); } // Block terminates label_0B21: // Incoming jump from 0x0B1C, if !(stack[-1] > stack[-2]) // Inputs[4] // { // @0B22 stack[-2] // @0B23 stack[-3] // @0B25 stack[-1] // @0B27 stack[-4] // } 0B21 5B JUMPDEST 0B22 81 DUP2 0B23 83 DUP4 0B24 03 SUB 0B25 90 SWAP1 0B26 50 POP 0B27 92 SWAP3 0B28 91 SWAP2 0B29 50 POP 0B2A 50 POP 0B2B 56 *JUMP // Stack delta = -3 // Outputs[1] { @0B27 stack[-4] = stack[-3] - stack[-2] } // Block ends with unconditional jump to stack[-4] label_0B2C: // Incoming jump from 0x0430 // Inputs[4] // { // @0B36 msg.sender // @0B70 memory[0x00:0x40] // @0B71 storage[keccak256(memory[0x00:0x40])] // @0B72 stack[-1] // } 0B2C 5B JUMPDEST 0B2D 60 PUSH1 0x00 0B2F 61 PUSH2 0x0b77 0B32 60 PUSH1 0x04 0B34 60 PUSH1 0x00 0B36 33 CALLER 0B37 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B4C 16 AND 0B4D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B62 16 AND 0B63 81 DUP2 0B64 52 MSTORE 0B65 60 PUSH1 0x20 0B67 01 ADD 0B68 90 SWAP1 0B69 81 DUP2 0B6A 52 MSTORE 0B6B 60 PUSH1 0x20 0B6D 01 ADD 0B6E 60 PUSH1 0x00 0B70 20 SHA3 0B71 54 SLOAD 0B72 83 DUP4 0B73 61 PUSH2 0x0b12 0B76 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0B2D stack[0] = 0x00 // @0B2F stack[1] = 0x0b77 // @0B64 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0B6A memory[0x20:0x40] = 0x04 // @0B71 stack[2] = storage[keccak256(memory[0x00:0x40])] // @0B72 stack[3] = stack[-1] // } // Block ends with call to 0x0b12, returns to 0x0B77 label_0B77: // Incoming return from call to 0x0B12 at 0x0B76 // Inputs[7] // { // @0B7C msg.sender // @0BB6 memory[0x00:0x40] // @0BB7 stack[-1] // @0BC2 stack[-4] // @0BFC memory[0x00:0x40] // @0BFD storage[keccak256(memory[0x00:0x40])] // @0BFE stack[-3] // } 0B77 5B JUMPDEST 0B78 60 PUSH1 0x04 0B7A 60 PUSH1 0x00 0B7C 33 CALLER 0B7D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B92 16 AND 0B93 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BA8 16 AND 0BA9 81 DUP2 0BAA 52 MSTORE 0BAB 60 PUSH1 0x20 0BAD 01 ADD 0BAE 90 SWAP1 0BAF 81 DUP2 0BB0 52 MSTORE 0BB1 60 PUSH1 0x20 0BB3 01 ADD 0BB4 60 PUSH1 0x00 0BB6 20 SHA3 0BB7 81 DUP2 0BB8 90 SWAP1 0BB9 55 SSTORE 0BBA 50 POP 0BBB 61 PUSH2 0x0c03 0BBE 60 PUSH1 0x04 0BC0 60 PUSH1 0x00 0BC2 85 DUP6 0BC3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BD8 16 AND 0BD9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BEE 16 AND 0BEF 81 DUP2 0BF0 52 MSTORE 0BF1 60 PUSH1 0x20 0BF3 01 ADD 0BF4 90 SWAP1 0BF5 81 DUP2 0BF6 52 MSTORE 0BF7 60 PUSH1 0x20 0BF9 01 ADD 0BFA 60 PUSH1 0x00 0BFC 20 SHA3 0BFD 54 SLOAD 0BFE 83 DUP4 0BFF 61 PUSH2 0x0d89 0C02 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @0BAA memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0BB0 memory[0x20:0x40] = 0x04 // @0BB9 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0BBB stack[-1] = 0x0c03 // @0BF0 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0BF6 memory[0x20:0x40] = 0x04 // @0BFD stack[0] = storage[keccak256(memory[0x00:0x40])] // @0BFE stack[1] = stack[-3] // } // Block ends with call to 0x0d89, returns to 0x0C03 label_0C03: // Incoming return from call to 0x0D89 at 0x0C02 // Inputs[10] // { // @0C08 stack[-4] // @0C42 memory[0x00:0x40] // @0C43 stack[-1] // @0C5E msg.sender // @0C96 stack[-3] // @0C99 memory[0x40:0x60] // @0CA6 memory[0x40:0x60] // @0CAB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0CAE stack[-2] // @0CB0 stack[-5] // } 0C03 5B JUMPDEST 0C04 60 PUSH1 0x04 0C06 60 PUSH1 0x00 0C08 85 DUP6 0C09 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C1E 16 AND 0C1F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C34 16 AND 0C35 81 DUP2 0C36 52 MSTORE 0C37 60 PUSH1 0x20 0C39 01 ADD 0C3A 90 SWAP1 0C3B 81 DUP2 0C3C 52 MSTORE 0C3D 60 PUSH1 0x20 0C3F 01 ADD 0C40 60 PUSH1 0x00 0C42 20 SHA3 0C43 81 DUP2 0C44 90 SWAP1 0C45 55 SSTORE 0C46 50 POP 0C47 82 DUP3 0C48 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C5D 16 AND 0C5E 33 CALLER 0C5F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C74 16 AND 0C75 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0C96 84 DUP5 0C97 60 PUSH1 0x40 0C99 51 MLOAD 0C9A 80 DUP1 0C9B 82 DUP3 0C9C 81 DUP2 0C9D 52 MSTORE 0C9E 60 PUSH1 0x20 0CA0 01 ADD 0CA1 91 SWAP2 0CA2 50 POP 0CA3 50 POP 0CA4 60 PUSH1 0x40 0CA6 51 MLOAD 0CA7 80 DUP1 0CA8 91 SWAP2 0CA9 03 SUB 0CAA 90 SWAP1 0CAB A3 LOG3 0CAC 60 PUSH1 0x01 0CAE 90 SWAP1 0CAF 50 POP 0CB0 92 SWAP3 0CB1 91 SWAP2 0CB2 50 POP 0CB3 50 POP 0CB4 56 *JUMP // Stack delta = -4 // Outputs[6] // { // @0C36 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0C3C memory[0x20:0x40] = 0x04 // @0C45 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0C9D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @0CAB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, msg.sender, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]); // @0CB0 stack[-5] = 0x01 // } // Block ends with unconditional jump to stack[-5] label_0CB5: // Incoming jump from 0x0480 // Inputs[1] { @0CB9 stack[-1] } 0CB5 5B JUMPDEST 0CB6 60 PUSH1 0x00 0CB8 80 DUP1 0CB9 82 DUP3 0CBA 11 GT 0CBB 61 PUSH2 0x0cc3 0CBE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0CB6 stack[0] = 0x00 } // Block ends with conditional jump to 0x0cc3, if stack[-1] > 0x00 label_0CBF: // Incoming jump from 0x0CBE, if not stack[-1] > 0x00 // Inputs[1] { @0CC2 memory[0x00:0x00] } 0CBF 60 PUSH1 0x00 0CC1 80 DUP1 0CC2 FD *REVERT // Stack delta = +0 // Outputs[1] { @0CC2 revert(memory[0x00:0x00]); } // Block terminates label_0CC3: // Incoming jump from 0x0CBE, if stack[-1] > 0x00 // Inputs[2] // { // @0CC4 stack[-2] // @0CC5 stack[-3] // } 0CC3 5B JUMPDEST 0CC4 81 DUP2 0CC5 83 DUP4 0CC6 81 DUP2 0CC7 61 PUSH2 0x0ccc 0CCA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0CC4 stack[0] = stack[-2] // @0CC5 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x0ccc, if stack[-2] label_0CCB: // Incoming jump from 0x0CCA, if not stack[-2] 0CCB FE *ASSERT // Stack delta = +0 // Outputs[1] { @0CCB assert(); } // Block terminates label_0CCC: // Incoming jump from 0x0CCA, if stack[-2] // Inputs[5] // { // @0CCD stack[-1] // @0CCD stack[-2] // @0CCE stack[-3] // @0CD0 stack[-6] // @0CD1 stack[-5] // } 0CCC 5B JUMPDEST 0CCD 04 DIV 0CCE 90 SWAP1 0CCF 50 POP 0CD0 92 SWAP3 0CD1 91 SWAP2 0CD2 50 POP 0CD3 50 POP 0CD4 56 *JUMP // Stack delta = -5 // Outputs[1] { @0CD0 stack[-6] = stack[-1] / stack[-2] } // Block ends with unconditional jump to stack[-6] label_0CD5: // Incoming jump from 0x04CC // Inputs[2] // { // @0CD8 stack[-1] // @0CD9 stack[-2] // } 0CD5 5B JUMPDEST 0CD6 60 PUSH1 0x00 0CD8 81 DUP2 0CD9 83 DUP4 0CDA 02 MUL 0CDB 90 SWAP1 0CDC 50 POP 0CDD 60 PUSH1 0x00 0CDF 83 DUP4 0CE0 14 EQ 0CE1 80 DUP1 0CE2 61 PUSH2 0x0cf3 0CE5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0CDB stack[0] = stack[-2] * stack[-1] // @0CE0 stack[1] = stack[-2] == 0x00 // } // Block ends with conditional jump to 0x0cf3, if stack[-2] == 0x00 label_0CE6: // Incoming jump from 0x0CE5, if not stack[-2] == 0x00 // Inputs[3] // { // @0CE7 stack[-3] // @0CE8 stack[-4] // @0CE9 stack[-2] // } 0CE6 50 POP 0CE7 81 DUP2 0CE8 83 DUP4 0CE9 82 DUP3 0CEA 81 DUP2 0CEB 61 PUSH2 0x0cf0 0CEE 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0CE7 stack[-1] = stack[-3] // @0CE8 stack[0] = stack[-4] // @0CE9 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0cf0, if stack[-4] label_0CEF: // Incoming jump from 0x0CEE, if not stack[-4] 0CEF FE *ASSERT // Stack delta = +0 // Outputs[1] { @0CEF assert(); } // Block terminates label_0CF0: // Incoming jump from 0x0CEE, if stack[-4] // Inputs[3] // { // @0CF1 stack[-1] // @0CF1 stack[-2] // @0CF2 stack[-3] // } 0CF0 5B JUMPDEST 0CF1 04 DIV 0CF2 14 EQ // Stack delta = -2 // Outputs[1] { @0CF2 stack[-3] = stack[-1] / stack[-2] == stack[-3] } // Block continues label_0CF3: // Incoming jump from 0x0CE5, if stack[-2] == 0x00 // Incoming jump from 0x0CF2 // Inputs[1] { @0CF7 stack[-1] } 0CF3 5B JUMPDEST 0CF4 61 PUSH2 0x0cfc 0CF7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0cfc, if stack[-1] label_0CF8: // Incoming jump from 0x0CF7, if not stack[-1] // Inputs[1] { @0CFB memory[0x00:0x00] } 0CF8 60 PUSH1 0x00 0CFA 80 DUP1 0CFB FD *REVERT // Stack delta = +0 // Outputs[1] { @0CFB revert(memory[0x00:0x00]); } // Block terminates label_0CFC: // Incoming jump from 0x0CF7, if stack[-1] // Inputs[3] // { // @0CFD stack[-1] // @0CFD stack[-4] // @0CFE stack[-3] // } 0CFC 5B JUMPDEST 0CFD 92 SWAP3 0CFE 91 SWAP2 0CFF 50 POP 0D00 50 POP 0D01 56 *JUMP // Stack delta = -3 // Outputs[1] { @0CFD stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0D02: // Incoming jump from 0x0544 // Inputs[6] // { // @0D09 stack[-2] // @0D43 memory[0x00:0x40] // @0D46 stack[-1] // @0D80 memory[0x00:0x40] // @0D81 storage[keccak256(memory[0x00:0x40])] // @0D84 stack[-3] // } 0D02 5B JUMPDEST 0D03 60 PUSH1 0x00 0D05 60 PUSH1 0x05 0D07 60 PUSH1 0x00 0D09 84 DUP5 0D0A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D1F 16 AND 0D20 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D35 16 AND 0D36 81 DUP2 0D37 52 MSTORE 0D38 60 PUSH1 0x20 0D3A 01 ADD 0D3B 90 SWAP1 0D3C 81 DUP2 0D3D 52 MSTORE 0D3E 60 PUSH1 0x20 0D40 01 ADD 0D41 60 PUSH1 0x00 0D43 20 SHA3 0D44 60 PUSH1 0x00 0D46 83 DUP4 0D47 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D5C 16 AND 0D5D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D72 16 AND 0D73 81 DUP2 0D74 52 MSTORE 0D75 60 PUSH1 0x20 0D77 01 ADD 0D78 90 SWAP1 0D79 81 DUP2 0D7A 52 MSTORE 0D7B 60 PUSH1 0x20 0D7D 01 ADD 0D7E 60 PUSH1 0x00 0D80 20 SHA3 0D81 54 SLOAD 0D82 90 SWAP1 0D83 50 POP 0D84 92 SWAP3 0D85 91 SWAP2 0D86 50 POP 0D87 50 POP 0D88 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0D37 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0D3D memory[0x20:0x40] = 0x05 // @0D74 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0D7A memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0D84 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0D89: // Incoming jump from 0x0590 // Incoming call from 0x0C02, returns to 0x0C03 // Incoming call from 0x095E, returns to 0x095F // Inputs[2] // { // @0D8C stack[-1] // @0D8D stack[-2] // } 0D89 5B JUMPDEST 0D8A 60 PUSH1 0x00 0D8C 81 DUP2 0D8D 83 DUP4 0D8E 01 ADD 0D8F 90 SWAP1 0D90 50 POP 0D91 82 DUP3 0D92 81 DUP2 0D93 10 LT 0D94 15 ISZERO 0D95 61 PUSH2 0x0d9d 0D98 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D8F stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x0d9d, if !(stack[-2] + stack[-1] < stack[-2]) label_0D99: // Incoming jump from 0x0D98, if not !(stack[-2] + stack[-1] < stack[-2]) // Inputs[1] { @0D9C memory[0x00:0x00] } 0D99 60 PUSH1 0x00 0D9B 80 DUP1 0D9C FD *REVERT // Stack delta = +0 // Outputs[1] { @0D9C revert(memory[0x00:0x00]); } // Block terminates label_0D9D: // Incoming jump from 0x0D98, if !(stack[-2] + stack[-1] < stack[-2]) // Inputs[3] // { // @0D9E stack[-4] // @0D9E stack[-1] // @0D9F stack[-3] // } 0D9D 5B JUMPDEST 0D9E 92 SWAP3 0D9F 91 SWAP2 0DA0 50 POP 0DA1 50 POP 0DA2 56 *JUMP // Stack delta = -3 // Outputs[1] { @0D9E stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] 0DA3 FE *ASSERT 0DA4 A2 LOG2 0DA5 65 PUSH6 0x627a7a723158 0DAC 20 SHA3 0DAD D2 D2 0DAE 21 21 0DAF B8 B8 0DB0 C8 C8 0DB1 06 MOD 0DB2 7B PUSH28 0xbe1c493dd4c609afe226e9b5a67c97ad24de63210d535c4db1146473 0DCF 6F PUSH16 0x6c63430005110032