Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x00db 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x00db, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 002E 90 SWAP1 002F 04 DIV 0030 63 PUSH4 0xffffffff 0035 16 AND 0036 80 DUP1 0037 63 PUSH4 0x06fdde03 003C 14 EQ 003D 61 PUSH2 0x00e0 0040 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0035 stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x00e0, if 0x06fdde03 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0041: // Incoming jump from 0x0040, if not 0x06fdde03 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0x095ea7b3 0047 14 EQ 0048 61 PUSH2 0x0170 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0170, if 0x095ea7b3 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0x18160ddd 0052 14 EQ 0053 61 PUSH2 0x01d5 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d5, if 0x18160ddd == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0x18160ddd == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0x23b872dd 005D 14 EQ 005E 61 PUSH2 0x0200 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0200, if 0x23b872dd == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0x23b872dd == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0x313ce567 0068 14 EQ 0069 61 PUSH2 0x0285 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0285, if 0x313ce567 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0x313ce567 == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0x3eaaf86b 0073 14 EQ 0074 61 PUSH2 0x02b6 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b6, if 0x3eaaf86b == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0x3eaaf86b == stack[-1] // Inputs[1] { @0078 stack[-1] } 0078 80 DUP1 0079 63 PUSH4 0x70a08231 007E 14 EQ 007F 61 PUSH2 0x02e1 0082 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e1, if 0x70a08231 == stack[-1] label_0083: // Incoming jump from 0x0082, if not 0x70a08231 == stack[-1] // Inputs[1] { @0083 stack[-1] } 0083 80 DUP1 0084 63 PUSH4 0x95d89b41 0089 14 EQ 008A 61 PUSH2 0x0338 008D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0338, if 0x95d89b41 == stack[-1] label_008E: // Incoming jump from 0x008D, if not 0x95d89b41 == stack[-1] // Inputs[1] { @008E stack[-1] } 008E 80 DUP1 008F 63 PUSH4 0xa293d1e8 0094 14 EQ 0095 61 PUSH2 0x03c8 0098 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c8, if 0xa293d1e8 == stack[-1] label_0099: // Incoming jump from 0x0098, if not 0xa293d1e8 == stack[-1] // Inputs[1] { @0099 stack[-1] } 0099 80 DUP1 009A 63 PUSH4 0xa9059cbb 009F 14 EQ 00A0 61 PUSH2 0x0413 00A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0413, if 0xa9059cbb == stack[-1] label_00A4: // Incoming jump from 0x00A3, if not 0xa9059cbb == stack[-1] // Inputs[1] { @00A4 stack[-1] } 00A4 80 DUP1 00A5 63 PUSH4 0xb5931f7c 00AA 14 EQ 00AB 61 PUSH2 0x0478 00AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0478, if 0xb5931f7c == stack[-1] label_00AF: // Incoming jump from 0x00AE, if not 0xb5931f7c == stack[-1] // Inputs[1] { @00AF stack[-1] } 00AF 80 DUP1 00B0 63 PUSH4 0xcae9ca51 00B5 14 EQ 00B6 61 PUSH2 0x04c3 00B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c3, if 0xcae9ca51 == stack[-1] label_00BA: // Incoming jump from 0x00B9, if not 0xcae9ca51 == stack[-1] // Inputs[1] { @00BA stack[-1] } 00BA 80 DUP1 00BB 63 PUSH4 0xd05c78da 00C0 14 EQ 00C1 61 PUSH2 0x056e 00C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x056e, if 0xd05c78da == stack[-1] label_00C5: // Incoming jump from 0x00C4, if not 0xd05c78da == stack[-1] // Inputs[1] { @00C5 stack[-1] } 00C5 80 DUP1 00C6 63 PUSH4 0xdd62ed3e 00CB 14 EQ 00CC 61 PUSH2 0x05b9 00CF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b9, if 0xdd62ed3e == stack[-1] label_00D0: // Incoming jump from 0x00CF, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @00D0 stack[-1] } 00D0 80 DUP1 00D1 63 PUSH4 0xe6cb9013 00D6 14 EQ 00D7 61 PUSH2 0x0630 00DA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0630, if 0xe6cb9013 == stack[-1] label_00DB: // Incoming jump from 0x00DA, if not 0xe6cb9013 == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @00DF memory[0x00:0x00] } 00DB 5B JUMPDEST 00DC 60 PUSH1 0x00 00DE 80 DUP1 00DF FD *REVERT // Stack delta = +0 // Outputs[1] { @00DF revert(memory[0x00:0x00]); } // Block terminates label_00E0: // Incoming jump from 0x0040, if 0x06fdde03 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @00E1 msg.value } 00E0 5B JUMPDEST 00E1 34 CALLVALUE 00E2 80 DUP1 00E3 15 ISZERO 00E4 61 PUSH2 0x00ec 00E7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00E1 stack[0] = msg.value } // Block ends with conditional jump to 0x00ec, if !msg.value label_00E8: // Incoming jump from 0x00E7, if not !msg.value // Inputs[1] { @00EB memory[0x00:0x00] } 00E8 60 PUSH1 0x00 00EA 80 DUP1 00EB FD *REVERT // Stack delta = +0 // Outputs[1] { @00EB revert(memory[0x00:0x00]); } // Block terminates label_00EC: // Incoming jump from 0x00E7, if !msg.value 00EC 5B JUMPDEST 00ED 50 POP 00EE 61 PUSH2 0x00f5 00F1 61 PUSH2 0x067b 00F4 56 *JUMP // Stack delta = +0 // Outputs[1] { @00EE stack[-1] = 0x00f5 } // Block ends with call to 0x067b, returns to 0x00F5 label_00F5: // Incoming return from call to 0x067B at 0x00F4 // Inputs[4] // { // @00F8 memory[0x40:0x60] // @0103 stack[-1] // @0106 memory[stack[-1]:stack[-1] + 0x20] // @010F memory[stack[-1]:stack[-1] + 0x20] // } 00F5 5B JUMPDEST 00F6 60 PUSH1 0x40 00F8 51 MLOAD 00F9 80 DUP1 00FA 80 DUP1 00FB 60 PUSH1 0x20 00FD 01 ADD 00FE 82 DUP3 00FF 81 DUP2 0100 03 SUB 0101 82 DUP3 0102 52 MSTORE 0103 83 DUP4 0104 81 DUP2 0105 81 DUP2 0106 51 MLOAD 0107 81 DUP2 0108 52 MSTORE 0109 60 PUSH1 0x20 010B 01 ADD 010C 91 SWAP2 010D 50 POP 010E 80 DUP1 010F 51 MLOAD 0110 90 SWAP1 0111 60 PUSH1 0x20 0113 01 ADD 0114 90 SWAP1 0115 80 DUP1 0116 83 DUP4 0117 83 DUP4 0118 60 PUSH1 0x00 011A 5B JUMPDEST 011B 83 DUP4 011C 81 DUP2 011D 10 LT 011E 15 ISZERO 011F 61 PUSH2 0x0135 0122 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @00F8 stack[0] = memory[0x40:0x60] // @00F9 stack[1] = memory[0x40:0x60] // @0102 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0108 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @010C stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0114 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0114 stack[3] = 0x20 + stack[-1] // @0115 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0116 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0117 stack[7] = 0x20 + stack[-1] // @0118 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0135, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0123: // Incoming jump from 0x0122, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0122, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0123 stack[-1] // @0124 stack[-2] // @0126 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0128 stack[-3] // } 0123 80 DUP1 0124 82 DUP3 0125 01 ADD 0126 51 MLOAD 0127 81 DUP2 0128 84 DUP5 0129 01 ADD 012A 52 MSTORE 012B 60 PUSH1 0x20 012D 81 DUP2 012E 01 ADD 012F 90 SWAP1 0130 50 POP 0131 61 PUSH2 0x011a 0134 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @012A memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @012F stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x011a label_0135: // Incoming jump from 0x0122, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0122, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @013A stack[-6] // @013A stack[-5] // @013C stack[-7] // } 0135 5B JUMPDEST 0136 50 POP 0137 50 POP 0138 50 POP 0139 50 POP 013A 90 SWAP1 013B 50 POP 013C 90 SWAP1 013D 81 DUP2 013E 01 ADD 013F 90 SWAP1 0140 60 PUSH1 0x1f 0142 16 AND 0143 80 DUP1 0144 15 ISZERO 0145 61 PUSH2 0x0162 0148 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @013F stack[-7] = stack[-5] + stack[-7] // @0142 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0162, if !(0x1f & stack[-5]) label_0149: // Incoming jump from 0x0148, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0149 stack[-1] // @014A stack[-2] // @014D memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0164 stack[-5] // @016A memory[0x40:0x60] // @016F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0149 80 DUP1 014A 82 DUP3 014B 03 SUB 014C 80 DUP1 014D 51 MLOAD 014E 60 PUSH1 0x01 0150 83 DUP4 0151 60 PUSH1 0x20 0153 03 SUB 0154 61 PUSH2 0x0100 0157 0A EXP 0158 03 SUB 0159 19 NOT 015A 16 AND 015B 81 DUP2 015C 52 MSTORE 015D 60 PUSH1 0x20 015F 01 ADD 0160 91 SWAP2 0161 50 POP 0162 5B JUMPDEST 0163 50 POP 0164 92 SWAP3 0165 50 POP 0166 50 POP 0167 50 POP 0168 60 PUSH1 0x40 016A 51 MLOAD 016B 80 DUP1 016C 91 SWAP2 016D 03 SUB 016E 90 SWAP1 016F F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @015C 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] // @016F return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0170: // Incoming jump from 0x004B, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0171 msg.value } 0170 5B JUMPDEST 0171 34 CALLVALUE 0172 80 DUP1 0173 15 ISZERO 0174 61 PUSH2 0x017c 0177 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0171 stack[0] = msg.value } // Block ends with conditional jump to 0x017c, if !msg.value label_0178: // Incoming jump from 0x0177, if not !msg.value // Inputs[1] { @017B memory[0x00:0x00] } 0178 60 PUSH1 0x00 017A 80 DUP1 017B FD *REVERT // Stack delta = +0 // Outputs[1] { @017B revert(memory[0x00:0x00]); } // Block terminates label_017C: // Incoming jump from 0x0177, if !msg.value // Inputs[3] // { // @0184 msg.data.length // @018B msg.data[0x04:0x24] // @01AB msg.data[0x24:0x44] // } 017C 5B JUMPDEST 017D 50 POP 017E 61 PUSH2 0x01bb 0181 60 PUSH1 0x04 0183 80 DUP1 0184 36 CALLDATASIZE 0185 03 SUB 0186 81 DUP2 0187 01 ADD 0188 90 SWAP1 0189 80 DUP1 018A 80 DUP1 018B 35 CALLDATALOAD 018C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01A1 16 AND 01A2 90 SWAP1 01A3 60 PUSH1 0x20 01A5 01 ADD 01A6 90 SWAP1 01A7 92 SWAP3 01A8 91 SWAP2 01A9 90 SWAP1 01AA 80 DUP1 01AB 35 CALLDATALOAD 01AC 90 SWAP1 01AD 60 PUSH1 0x20 01AF 01 ADD 01B0 90 SWAP1 01B1 92 SWAP3 01B2 91 SWAP2 01B3 90 SWAP1 01B4 50 POP 01B5 50 POP 01B6 50 POP 01B7 61 PUSH2 0x0719 01BA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @017E stack[-1] = 0x01bb // @01A7 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @01B1 stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x0719, returns to 0x01BB label_01BB: // Incoming return from call to 0x0719 at 0x01BA // Inputs[4] // { // @01BE memory[0x40:0x60] // @01C0 stack[-1] // @01CF memory[0x40:0x60] // @01D4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01BB 5B JUMPDEST 01BC 60 PUSH1 0x40 01BE 51 MLOAD 01BF 80 DUP1 01C0 82 DUP3 01C1 15 ISZERO 01C2 15 ISZERO 01C3 15 ISZERO 01C4 15 ISZERO 01C5 81 DUP2 01C6 52 MSTORE 01C7 60 PUSH1 0x20 01C9 01 ADD 01CA 91 SWAP2 01CB 50 POP 01CC 50 POP 01CD 60 PUSH1 0x40 01CF 51 MLOAD 01D0 80 DUP1 01D1 91 SWAP2 01D2 03 SUB 01D3 90 SWAP1 01D4 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01C6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @01D4 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01D5: // Incoming jump from 0x0056, if 0x18160ddd == stack[-1] // Inputs[1] { @01D6 msg.value } 01D5 5B JUMPDEST 01D6 34 CALLVALUE 01D7 80 DUP1 01D8 15 ISZERO 01D9 61 PUSH2 0x01e1 01DC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01D6 stack[0] = msg.value } // Block ends with conditional jump to 0x01e1, if !msg.value label_01DD: // Incoming jump from 0x01DC, if not !msg.value // Inputs[1] { @01E0 memory[0x00:0x00] } 01DD 60 PUSH1 0x00 01DF 80 DUP1 01E0 FD *REVERT // Stack delta = +0 // Outputs[1] { @01E0 revert(memory[0x00:0x00]); } // Block terminates label_01E1: // Incoming jump from 0x01DC, if !msg.value 01E1 5B JUMPDEST 01E2 50 POP 01E3 61 PUSH2 0x01ea 01E6 61 PUSH2 0x080b 01E9 56 *JUMP // Stack delta = +0 // Outputs[1] { @01E3 stack[-1] = 0x01ea } // Block ends with call to 0x080b, returns to 0x01EA label_01EA: // Incoming return from call to 0x080B at 0x01E9 // Inputs[4] // { // @01ED memory[0x40:0x60] // @01EF stack[-1] // @01FA memory[0x40:0x60] // @01FF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01EA 5B JUMPDEST 01EB 60 PUSH1 0x40 01ED 51 MLOAD 01EE 80 DUP1 01EF 82 DUP3 01F0 81 DUP2 01F1 52 MSTORE 01F2 60 PUSH1 0x20 01F4 01 ADD 01F5 91 SWAP2 01F6 50 POP 01F7 50 POP 01F8 60 PUSH1 0x40 01FA 51 MLOAD 01FB 80 DUP1 01FC 91 SWAP2 01FD 03 SUB 01FE 90 SWAP1 01FF F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @01FF return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0200: // Incoming jump from 0x0061, if 0x23b872dd == stack[-1] // Inputs[1] { @0201 msg.value } 0200 5B JUMPDEST 0201 34 CALLVALUE 0202 80 DUP1 0203 15 ISZERO 0204 61 PUSH2 0x020c 0207 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0201 stack[0] = msg.value } // Block ends with conditional jump to 0x020c, if !msg.value label_0208: // Incoming jump from 0x0207, if not !msg.value // 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 jump from 0x0207, if !msg.value // Inputs[4] // { // @0214 msg.data.length // @021B msg.data[0x04:0x24] // @023B msg.data[0x24:0x44] // @025B msg.data[0x44:0x64] // } 020C 5B JUMPDEST 020D 50 POP 020E 61 PUSH2 0x026b 0211 60 PUSH1 0x04 0213 80 DUP1 0214 36 CALLDATASIZE 0215 03 SUB 0216 81 DUP2 0217 01 ADD 0218 90 SWAP1 0219 80 DUP1 021A 80 DUP1 021B 35 CALLDATALOAD 021C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0231 16 AND 0232 90 SWAP1 0233 60 PUSH1 0x20 0235 01 ADD 0236 90 SWAP1 0237 92 SWAP3 0238 91 SWAP2 0239 90 SWAP1 023A 80 DUP1 023B 35 CALLDATALOAD 023C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0251 16 AND 0252 90 SWAP1 0253 60 PUSH1 0x20 0255 01 ADD 0256 90 SWAP1 0257 92 SWAP3 0258 91 SWAP2 0259 90 SWAP1 025A 80 DUP1 025B 35 CALLDATALOAD 025C 90 SWAP1 025D 60 PUSH1 0x20 025F 01 ADD 0260 90 SWAP1 0261 92 SWAP3 0262 91 SWAP2 0263 90 SWAP1 0264 50 POP 0265 50 POP 0266 50 POP 0267 61 PUSH2 0x0856 026A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @020E stack[-1] = 0x026b // @0237 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @0257 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x24:0x44] // @0261 stack[2] = msg.data[0x44:0x64] // } // Block ends with call to 0x0856, returns to 0x026B label_026B: // Incoming return from call to 0x0856 at 0x026A // Inputs[4] // { // @026E memory[0x40:0x60] // @0270 stack[-1] // @027F memory[0x40:0x60] // @0284 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 026B 5B JUMPDEST 026C 60 PUSH1 0x40 026E 51 MLOAD 026F 80 DUP1 0270 82 DUP3 0271 15 ISZERO 0272 15 ISZERO 0273 15 ISZERO 0274 15 ISZERO 0275 81 DUP2 0276 52 MSTORE 0277 60 PUSH1 0x20 0279 01 ADD 027A 91 SWAP2 027B 50 POP 027C 50 POP 027D 60 PUSH1 0x40 027F 51 MLOAD 0280 80 DUP1 0281 91 SWAP2 0282 03 SUB 0283 90 SWAP1 0284 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0276 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0284 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0285: // Incoming jump from 0x006C, if 0x313ce567 == stack[-1] // Inputs[1] { @0286 msg.value } 0285 5B JUMPDEST 0286 34 CALLVALUE 0287 80 DUP1 0288 15 ISZERO 0289 61 PUSH2 0x0291 028C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0286 stack[0] = msg.value } // Block ends with conditional jump to 0x0291, if !msg.value label_028D: // Incoming jump from 0x028C, if not !msg.value // Inputs[1] { @0290 memory[0x00:0x00] } 028D 60 PUSH1 0x00 028F 80 DUP1 0290 FD *REVERT // Stack delta = +0 // Outputs[1] { @0290 revert(memory[0x00:0x00]); } // Block terminates label_0291: // Incoming jump from 0x028C, if !msg.value 0291 5B JUMPDEST 0292 50 POP 0293 61 PUSH2 0x029a 0296 61 PUSH2 0x0ae6 0299 56 *JUMP // Stack delta = +0 // Outputs[1] { @0293 stack[-1] = 0x029a } // Block ends with call to 0x0ae6, returns to 0x029A label_029A: // Incoming return from call to 0x0AE6 at 0x0299 // Inputs[4] // { // @029D memory[0x40:0x60] // @029F stack[-1] // @02B0 memory[0x40:0x60] // @02B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 029A 5B JUMPDEST 029B 60 PUSH1 0x40 029D 51 MLOAD 029E 80 DUP1 029F 82 DUP3 02A0 60 PUSH1 0xff 02A2 16 AND 02A3 60 PUSH1 0xff 02A5 16 AND 02A6 81 DUP2 02A7 52 MSTORE 02A8 60 PUSH1 0x20 02AA 01 ADD 02AB 91 SWAP2 02AC 50 POP 02AD 50 POP 02AE 60 PUSH1 0x40 02B0 51 MLOAD 02B1 80 DUP1 02B2 91 SWAP2 02B3 03 SUB 02B4 90 SWAP1 02B5 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02A7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xff & 0xff & stack[-1] // @02B5 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02B6: // Incoming jump from 0x0077, if 0x3eaaf86b == stack[-1] // Inputs[1] { @02B7 msg.value } 02B6 5B JUMPDEST 02B7 34 CALLVALUE 02B8 80 DUP1 02B9 15 ISZERO 02BA 61 PUSH2 0x02c2 02BD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02B7 stack[0] = msg.value } // Block ends with conditional jump to 0x02c2, if !msg.value label_02BE: // Incoming jump from 0x02BD, if not !msg.value // Inputs[1] { @02C1 memory[0x00:0x00] } 02BE 60 PUSH1 0x00 02C0 80 DUP1 02C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @02C1 revert(memory[0x00:0x00]); } // Block terminates label_02C2: // Incoming jump from 0x02BD, if !msg.value 02C2 5B JUMPDEST 02C3 50 POP 02C4 61 PUSH2 0x02cb 02C7 61 PUSH2 0x0af9 02CA 56 *JUMP // Stack delta = +0 // Outputs[1] { @02C4 stack[-1] = 0x02cb } // Block ends with call to 0x0af9, returns to 0x02CB label_02CB: // Incoming return from call to 0x0AF9 at 0x02CA // Inputs[4] // { // @02CE memory[0x40:0x60] // @02D0 stack[-1] // @02DB memory[0x40:0x60] // @02E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02CB 5B JUMPDEST 02CC 60 PUSH1 0x40 02CE 51 MLOAD 02CF 80 DUP1 02D0 82 DUP3 02D1 81 DUP2 02D2 52 MSTORE 02D3 60 PUSH1 0x20 02D5 01 ADD 02D6 91 SWAP2 02D7 50 POP 02D8 50 POP 02D9 60 PUSH1 0x40 02DB 51 MLOAD 02DC 80 DUP1 02DD 91 SWAP2 02DE 03 SUB 02DF 90 SWAP1 02E0 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02E0 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02E1: // Incoming jump from 0x0082, if 0x70a08231 == stack[-1] // Inputs[1] { @02E2 msg.value } 02E1 5B JUMPDEST 02E2 34 CALLVALUE 02E3 80 DUP1 02E4 15 ISZERO 02E5 61 PUSH2 0x02ed 02E8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02E2 stack[0] = msg.value } // Block ends with conditional jump to 0x02ed, if !msg.value label_02E9: // Incoming jump from 0x02E8, if not !msg.value // Inputs[1] { @02EC memory[0x00:0x00] } 02E9 60 PUSH1 0x00 02EB 80 DUP1 02EC FD *REVERT // Stack delta = +0 // Outputs[1] { @02EC revert(memory[0x00:0x00]); } // Block terminates label_02ED: // Incoming jump from 0x02E8, if !msg.value // Inputs[2] // { // @02F5 msg.data.length // @02FC msg.data[0x04:0x24] // } 02ED 5B JUMPDEST 02EE 50 POP 02EF 61 PUSH2 0x0322 02F2 60 PUSH1 0x04 02F4 80 DUP1 02F5 36 CALLDATASIZE 02F6 03 SUB 02F7 81 DUP2 02F8 01 ADD 02F9 90 SWAP1 02FA 80 DUP1 02FB 80 DUP1 02FC 35 CALLDATALOAD 02FD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0312 16 AND 0313 90 SWAP1 0314 60 PUSH1 0x20 0316 01 ADD 0317 90 SWAP1 0318 92 SWAP3 0319 91 SWAP2 031A 90 SWAP1 031B 50 POP 031C 50 POP 031D 50 POP 031E 61 PUSH2 0x0aff 0321 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @02EF stack[-1] = 0x0322 // @0318 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x0aff, returns to 0x0322 label_0322: // Incoming return from call to 0x0AFF at 0x0321 // Inputs[4] // { // @0325 memory[0x40:0x60] // @0327 stack[-1] // @0332 memory[0x40:0x60] // @0337 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0322 5B JUMPDEST 0323 60 PUSH1 0x40 0325 51 MLOAD 0326 80 DUP1 0327 82 DUP3 0328 81 DUP2 0329 52 MSTORE 032A 60 PUSH1 0x20 032C 01 ADD 032D 91 SWAP2 032E 50 POP 032F 50 POP 0330 60 PUSH1 0x40 0332 51 MLOAD 0333 80 DUP1 0334 91 SWAP2 0335 03 SUB 0336 90 SWAP1 0337 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0329 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0337 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0338: // Incoming jump from 0x008D, if 0x95d89b41 == stack[-1] // Inputs[1] { @0339 msg.value } 0338 5B JUMPDEST 0339 34 CALLVALUE 033A 80 DUP1 033B 15 ISZERO 033C 61 PUSH2 0x0344 033F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0339 stack[0] = msg.value } // Block ends with conditional jump to 0x0344, if !msg.value label_0340: // Incoming jump from 0x033F, if not !msg.value // Inputs[1] { @0343 memory[0x00:0x00] } 0340 60 PUSH1 0x00 0342 80 DUP1 0343 FD *REVERT // Stack delta = +0 // Outputs[1] { @0343 revert(memory[0x00:0x00]); } // Block terminates label_0344: // Incoming jump from 0x033F, if !msg.value 0344 5B JUMPDEST 0345 50 POP 0346 61 PUSH2 0x034d 0349 61 PUSH2 0x0b48 034C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0346 stack[-1] = 0x034d } // Block ends with call to 0x0b48, returns to 0x034D label_034D: // Incoming return from call to 0x0B48 at 0x034C // Inputs[4] // { // @0350 memory[0x40:0x60] // @035B stack[-1] // @035E memory[stack[-1]:stack[-1] + 0x20] // @0367 memory[stack[-1]:stack[-1] + 0x20] // } 034D 5B JUMPDEST 034E 60 PUSH1 0x40 0350 51 MLOAD 0351 80 DUP1 0352 80 DUP1 0353 60 PUSH1 0x20 0355 01 ADD 0356 82 DUP3 0357 81 DUP2 0358 03 SUB 0359 82 DUP3 035A 52 MSTORE 035B 83 DUP4 035C 81 DUP2 035D 81 DUP2 035E 51 MLOAD 035F 81 DUP2 0360 52 MSTORE 0361 60 PUSH1 0x20 0363 01 ADD 0364 91 SWAP2 0365 50 POP 0366 80 DUP1 0367 51 MLOAD 0368 90 SWAP1 0369 60 PUSH1 0x20 036B 01 ADD 036C 90 SWAP1 036D 80 DUP1 036E 83 DUP4 036F 83 DUP4 0370 60 PUSH1 0x00 0372 5B JUMPDEST 0373 83 DUP4 0374 81 DUP2 0375 10 LT 0376 15 ISZERO 0377 61 PUSH2 0x038d 037A 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0350 stack[0] = memory[0x40:0x60] // @0351 stack[1] = memory[0x40:0x60] // @035A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0360 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0364 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @036C stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @036C stack[3] = 0x20 + stack[-1] // @036D stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @036E stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @036F stack[7] = 0x20 + stack[-1] // @0370 stack[8] = 0x00 // } // Block ends with conditional jump to 0x038d, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_037B: // Incoming jump from 0x037A, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x037A, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @037B stack[-1] // @037C stack[-2] // @037E memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0380 stack[-3] // } 037B 80 DUP1 037C 82 DUP3 037D 01 ADD 037E 51 MLOAD 037F 81 DUP2 0380 84 DUP5 0381 01 ADD 0382 52 MSTORE 0383 60 PUSH1 0x20 0385 81 DUP2 0386 01 ADD 0387 90 SWAP1 0388 50 POP 0389 61 PUSH2 0x0372 038C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0382 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0387 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0372 label_038D: // Incoming jump from 0x037A, if !(stack[-1] < stack[-4]) // Incoming jump from 0x037A, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0392 stack[-6] // @0392 stack[-5] // @0394 stack[-7] // } 038D 5B JUMPDEST 038E 50 POP 038F 50 POP 0390 50 POP 0391 50 POP 0392 90 SWAP1 0393 50 POP 0394 90 SWAP1 0395 81 DUP2 0396 01 ADD 0397 90 SWAP1 0398 60 PUSH1 0x1f 039A 16 AND 039B 80 DUP1 039C 15 ISZERO 039D 61 PUSH2 0x03ba 03A0 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0397 stack[-7] = stack[-5] + stack[-7] // @039A stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x03ba, if !(0x1f & stack[-5]) label_03A1: // Incoming jump from 0x03A0, if not !(0x1f & stack[-5]) // Inputs[6] // { // @03A1 stack[-1] // @03A2 stack[-2] // @03A5 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @03BC stack[-5] // @03C2 memory[0x40:0x60] // @03C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 03A1 80 DUP1 03A2 82 DUP3 03A3 03 SUB 03A4 80 DUP1 03A5 51 MLOAD 03A6 60 PUSH1 0x01 03A8 83 DUP4 03A9 60 PUSH1 0x20 03AB 03 SUB 03AC 61 PUSH2 0x0100 03AF 0A EXP 03B0 03 SUB 03B1 19 NOT 03B2 16 AND 03B3 81 DUP2 03B4 52 MSTORE 03B5 60 PUSH1 0x20 03B7 01 ADD 03B8 91 SWAP2 03B9 50 POP 03BA 5B JUMPDEST 03BB 50 POP 03BC 92 SWAP3 03BD 50 POP 03BE 50 POP 03BF 50 POP 03C0 60 PUSH1 0x40 03C2 51 MLOAD 03C3 80 DUP1 03C4 91 SWAP2 03C5 03 SUB 03C6 90 SWAP1 03C7 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @03B4 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] // @03C7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_03C8: // Incoming jump from 0x0098, if 0xa293d1e8 == stack[-1] // Inputs[1] { @03C9 msg.value } 03C8 5B JUMPDEST 03C9 34 CALLVALUE 03CA 80 DUP1 03CB 15 ISZERO 03CC 61 PUSH2 0x03d4 03CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C9 stack[0] = msg.value } // Block ends with conditional jump to 0x03d4, if !msg.value label_03D0: // Incoming jump from 0x03CF, if not !msg.value // Inputs[1] { @03D3 memory[0x00:0x00] } 03D0 60 PUSH1 0x00 03D2 80 DUP1 03D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D3 revert(memory[0x00:0x00]); } // Block terminates label_03D4: // Incoming jump from 0x03CF, if !msg.value // Inputs[3] // { // @03DC msg.data.length // @03E3 msg.data[0x04:0x24] // @03ED msg.data[0x24:0x44] // } 03D4 5B JUMPDEST 03D5 50 POP 03D6 61 PUSH2 0x03fd 03D9 60 PUSH1 0x04 03DB 80 DUP1 03DC 36 CALLDATASIZE 03DD 03 SUB 03DE 81 DUP2 03DF 01 ADD 03E0 90 SWAP1 03E1 80 DUP1 03E2 80 DUP1 03E3 35 CALLDATALOAD 03E4 90 SWAP1 03E5 60 PUSH1 0x20 03E7 01 ADD 03E8 90 SWAP1 03E9 92 SWAP3 03EA 91 SWAP2 03EB 90 SWAP1 03EC 80 DUP1 03ED 35 CALLDATALOAD 03EE 90 SWAP1 03EF 60 PUSH1 0x20 03F1 01 ADD 03F2 90 SWAP1 03F3 92 SWAP3 03F4 91 SWAP2 03F5 90 SWAP1 03F6 50 POP 03F7 50 POP 03F8 50 POP 03F9 61 PUSH2 0x0be6 03FC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @03D6 stack[-1] = 0x03fd // @03E9 stack[0] = msg.data[0x04:0x24] // @03F3 stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x0be6, returns to 0x03FD label_03FD: // Incoming return from call to 0x0BE6 at 0x03FC // Inputs[4] // { // @0400 memory[0x40:0x60] // @0402 stack[-1] // @040D memory[0x40:0x60] // @0412 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03FD 5B JUMPDEST 03FE 60 PUSH1 0x40 0400 51 MLOAD 0401 80 DUP1 0402 82 DUP3 0403 81 DUP2 0404 52 MSTORE 0405 60 PUSH1 0x20 0407 01 ADD 0408 91 SWAP2 0409 50 POP 040A 50 POP 040B 60 PUSH1 0x40 040D 51 MLOAD 040E 80 DUP1 040F 91 SWAP2 0410 03 SUB 0411 90 SWAP1 0412 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0404 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0412 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0413: // Incoming jump from 0x00A3, if 0xa9059cbb == stack[-1] // Inputs[1] { @0414 msg.value } 0413 5B JUMPDEST 0414 34 CALLVALUE 0415 80 DUP1 0416 15 ISZERO 0417 61 PUSH2 0x041f 041A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0414 stack[0] = msg.value } // Block ends with conditional jump to 0x041f, if !msg.value label_041B: // Incoming jump from 0x041A, if not !msg.value // Inputs[1] { @041E memory[0x00:0x00] } 041B 60 PUSH1 0x00 041D 80 DUP1 041E FD *REVERT // Stack delta = +0 // Outputs[1] { @041E revert(memory[0x00:0x00]); } // Block terminates label_041F: // Incoming jump from 0x041A, if !msg.value // Inputs[3] // { // @0427 msg.data.length // @042E msg.data[0x04:0x24] // @044E msg.data[0x24:0x44] // } 041F 5B JUMPDEST 0420 50 POP 0421 61 PUSH2 0x045e 0424 60 PUSH1 0x04 0426 80 DUP1 0427 36 CALLDATASIZE 0428 03 SUB 0429 81 DUP2 042A 01 ADD 042B 90 SWAP1 042C 80 DUP1 042D 80 DUP1 042E 35 CALLDATALOAD 042F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0444 16 AND 0445 90 SWAP1 0446 60 PUSH1 0x20 0448 01 ADD 0449 90 SWAP1 044A 92 SWAP3 044B 91 SWAP2 044C 90 SWAP1 044D 80 DUP1 044E 35 CALLDATALOAD 044F 90 SWAP1 0450 60 PUSH1 0x20 0452 01 ADD 0453 90 SWAP1 0454 92 SWAP3 0455 91 SWAP2 0456 90 SWAP1 0457 50 POP 0458 50 POP 0459 50 POP 045A 61 PUSH2 0x0c02 045D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0421 stack[-1] = 0x045e // @044A stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @0454 stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x0c02, returns to 0x045E label_045E: // Incoming return from call to 0x0C02 at 0x045D // Inputs[4] // { // @0461 memory[0x40:0x60] // @0463 stack[-1] // @0472 memory[0x40:0x60] // @0477 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 045E 5B JUMPDEST 045F 60 PUSH1 0x40 0461 51 MLOAD 0462 80 DUP1 0463 82 DUP3 0464 15 ISZERO 0465 15 ISZERO 0466 15 ISZERO 0467 15 ISZERO 0468 81 DUP2 0469 52 MSTORE 046A 60 PUSH1 0x20 046C 01 ADD 046D 91 SWAP2 046E 50 POP 046F 50 POP 0470 60 PUSH1 0x40 0472 51 MLOAD 0473 80 DUP1 0474 91 SWAP2 0475 03 SUB 0476 90 SWAP1 0477 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0469 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0477 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0478: // Incoming jump from 0x00AE, if 0xb5931f7c == stack[-1] // Inputs[1] { @0479 msg.value } 0478 5B JUMPDEST 0479 34 CALLVALUE 047A 80 DUP1 047B 15 ISZERO 047C 61 PUSH2 0x0484 047F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0479 stack[0] = msg.value } // Block ends with conditional jump to 0x0484, if !msg.value label_0480: // Incoming jump from 0x047F, if not !msg.value // Inputs[1] { @0483 memory[0x00:0x00] } 0480 60 PUSH1 0x00 0482 80 DUP1 0483 FD *REVERT // Stack delta = +0 // Outputs[1] { @0483 revert(memory[0x00:0x00]); } // Block terminates label_0484: // Incoming jump from 0x047F, if !msg.value // Inputs[3] // { // @048C msg.data.length // @0493 msg.data[0x04:0x24] // @049D msg.data[0x24:0x44] // } 0484 5B JUMPDEST 0485 50 POP 0486 61 PUSH2 0x04ad 0489 60 PUSH1 0x04 048B 80 DUP1 048C 36 CALLDATASIZE 048D 03 SUB 048E 81 DUP2 048F 01 ADD 0490 90 SWAP1 0491 80 DUP1 0492 80 DUP1 0493 35 CALLDATALOAD 0494 90 SWAP1 0495 60 PUSH1 0x20 0497 01 ADD 0498 90 SWAP1 0499 92 SWAP3 049A 91 SWAP2 049B 90 SWAP1 049C 80 DUP1 049D 35 CALLDATALOAD 049E 90 SWAP1 049F 60 PUSH1 0x20 04A1 01 ADD 04A2 90 SWAP1 04A3 92 SWAP3 04A4 91 SWAP2 04A5 90 SWAP1 04A6 50 POP 04A7 50 POP 04A8 50 POP 04A9 61 PUSH2 0x0d8b 04AC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0486 stack[-1] = 0x04ad // @0499 stack[0] = msg.data[0x04:0x24] // @04A3 stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x0d8b, returns to 0x04AD label_04AD: // Incoming return from call to 0x0D8B at 0x04AC // Inputs[4] // { // @04B0 memory[0x40:0x60] // @04B2 stack[-1] // @04BD memory[0x40:0x60] // @04C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 04AD 5B JUMPDEST 04AE 60 PUSH1 0x40 04B0 51 MLOAD 04B1 80 DUP1 04B2 82 DUP3 04B3 81 DUP2 04B4 52 MSTORE 04B5 60 PUSH1 0x20 04B7 01 ADD 04B8 91 SWAP2 04B9 50 POP 04BA 50 POP 04BB 60 PUSH1 0x40 04BD 51 MLOAD 04BE 80 DUP1 04BF 91 SWAP2 04C0 03 SUB 04C1 90 SWAP1 04C2 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @04B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @04C2 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_04C3: // Incoming jump from 0x00B9, if 0xcae9ca51 == stack[-1] // Inputs[1] { @04C4 msg.value } 04C3 5B JUMPDEST 04C4 34 CALLVALUE 04C5 80 DUP1 04C6 15 ISZERO 04C7 61 PUSH2 0x04cf 04CA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04C4 stack[0] = msg.value } // Block ends with conditional jump to 0x04cf, if !msg.value label_04CB: // Incoming jump from 0x04CA, if not !msg.value // Inputs[1] { @04CE memory[0x00:0x00] } 04CB 60 PUSH1 0x00 04CD 80 DUP1 04CE FD *REVERT // Stack delta = +0 // Outputs[1] { @04CE revert(memory[0x00:0x00]); } // Block terminates label_04CF: // Incoming jump from 0x04CA, if !msg.value // Inputs[7] // { // @04D7 msg.data.length // @04DE msg.data[0x04:0x24] // @04FE msg.data[0x24:0x44] // @0508 msg.data[0x44:0x64] // @0511 msg.data[0x04 + msg.data[0x44:0x64]:0x04 + msg.data[0x44:0x64] + 0x20] // @0527 memory[0x40:0x60] // @053E msg.data[0x20 + 0x04 + msg.data[0x44:0x64]:0x20 + 0x04 + msg.data[0x44:0x64] + msg.data[0x04 + msg.data[0x44:0x64]:0x04 + msg.data[0x44:0x64] + 0x20]] // } 04CF 5B JUMPDEST 04D0 50 POP 04D1 61 PUSH2 0x0554 04D4 60 PUSH1 0x04 04D6 80 DUP1 04D7 36 CALLDATASIZE 04D8 03 SUB 04D9 81 DUP2 04DA 01 ADD 04DB 90 SWAP1 04DC 80 DUP1 04DD 80 DUP1 04DE 35 CALLDATALOAD 04DF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04F4 16 AND 04F5 90 SWAP1 04F6 60 PUSH1 0x20 04F8 01 ADD 04F9 90 SWAP1 04FA 92 SWAP3 04FB 91 SWAP2 04FC 90 SWAP1 04FD 80 DUP1 04FE 35 CALLDATALOAD 04FF 90 SWAP1 0500 60 PUSH1 0x20 0502 01 ADD 0503 90 SWAP1 0504 92 SWAP3 0505 91 SWAP2 0506 90 SWAP1 0507 80 DUP1 0508 35 CALLDATALOAD 0509 90 SWAP1 050A 60 PUSH1 0x20 050C 01 ADD 050D 90 SWAP1 050E 82 DUP3 050F 01 ADD 0510 80 DUP1 0511 35 CALLDATALOAD 0512 90 SWAP1 0513 60 PUSH1 0x20 0515 01 ADD 0516 90 SWAP1 0517 80 DUP1 0518 80 DUP1 0519 60 PUSH1 0x1f 051B 01 ADD 051C 60 PUSH1 0x20 051E 80 DUP1 051F 91 SWAP2 0520 04 DIV 0521 02 MUL 0522 60 PUSH1 0x20 0524 01 ADD 0525 60 PUSH1 0x40 0527 51 MLOAD 0528 90 SWAP1 0529 81 DUP2 052A 01 ADD 052B 60 PUSH1 0x40 052D 52 MSTORE 052E 80 DUP1 052F 93 SWAP4 0530 92 SWAP3 0531 91 SWAP2 0532 90 SWAP1 0533 81 DUP2 0534 81 DUP2 0535 52 MSTORE 0536 60 PUSH1 0x20 0538 01 ADD 0539 83 DUP4 053A 83 DUP4 053B 80 DUP1 053C 82 DUP3 053D 84 DUP5 053E 37 CALLDATACOPY 053F 82 DUP3 0540 01 ADD 0541 91 SWAP2 0542 50 POP 0543 50 POP 0544 50 POP 0545 50 POP 0546 50 POP 0547 50 POP 0548 91 SWAP2 0549 92 SWAP3 054A 91 SWAP2 054B 92 SWAP3 054C 90 SWAP1 054D 50 POP 054E 50 POP 054F 50 POP 0550 61 PUSH2 0x0daf 0553 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @04D1 stack[-1] = 0x0554 // @04FA stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @0504 stack[1] = msg.data[0x24:0x44] // @052D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data[0x04 + msg.data[0x44:0x64]:0x04 + msg.data[0x44:0x64] + 0x20]) / 0x20 * 0x20 // @0535 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x44:0x64]:0x04 + msg.data[0x44:0x64] + 0x20] // @053E memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + msg.data[0x04 + msg.data[0x44:0x64]:0x04 + msg.data[0x44:0x64] + 0x20]] = msg.data[0x20 + 0x04 + msg.data[0x44:0x64]:0x20 + 0x04 + msg.data[0x44:0x64] + msg.data[0x04 + msg.data[0x44:0x64]:0x04 + msg.data[0x44:0x64] + 0x20]] // @054B stack[2] = memory[0x40:0x60] // } // Block ends with call to 0x0daf, returns to 0x0554 label_0554: // Incoming return from call to 0x0DAF at 0x0553 // Inputs[4] // { // @0557 memory[0x40:0x60] // @0559 stack[-1] // @0568 memory[0x40:0x60] // @056D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0554 5B JUMPDEST 0555 60 PUSH1 0x40 0557 51 MLOAD 0558 80 DUP1 0559 82 DUP3 055A 15 ISZERO 055B 15 ISZERO 055C 15 ISZERO 055D 15 ISZERO 055E 81 DUP2 055F 52 MSTORE 0560 60 PUSH1 0x20 0562 01 ADD 0563 91 SWAP2 0564 50 POP 0565 50 POP 0566 60 PUSH1 0x40 0568 51 MLOAD 0569 80 DUP1 056A 91 SWAP2 056B 03 SUB 056C 90 SWAP1 056D F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @055F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @056D return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_056E: // Incoming jump from 0x00C4, if 0xd05c78da == stack[-1] // Inputs[1] { @056F msg.value } 056E 5B JUMPDEST 056F 34 CALLVALUE 0570 80 DUP1 0571 15 ISZERO 0572 61 PUSH2 0x057a 0575 57 *JUMPI // Stack delta = +1 // Outputs[1] { @056F stack[0] = msg.value } // Block ends with conditional jump to 0x057a, if !msg.value label_0576: // Incoming jump from 0x0575, if not !msg.value // Inputs[1] { @0579 memory[0x00:0x00] } 0576 60 PUSH1 0x00 0578 80 DUP1 0579 FD *REVERT // Stack delta = +0 // Outputs[1] { @0579 revert(memory[0x00:0x00]); } // Block terminates label_057A: // Incoming jump from 0x0575, if !msg.value // Inputs[3] // { // @0582 msg.data.length // @0589 msg.data[0x04:0x24] // @0593 msg.data[0x24:0x44] // } 057A 5B JUMPDEST 057B 50 POP 057C 61 PUSH2 0x05a3 057F 60 PUSH1 0x04 0581 80 DUP1 0582 36 CALLDATASIZE 0583 03 SUB 0584 81 DUP2 0585 01 ADD 0586 90 SWAP1 0587 80 DUP1 0588 80 DUP1 0589 35 CALLDATALOAD 058A 90 SWAP1 058B 60 PUSH1 0x20 058D 01 ADD 058E 90 SWAP1 058F 92 SWAP3 0590 91 SWAP2 0591 90 SWAP1 0592 80 DUP1 0593 35 CALLDATALOAD 0594 90 SWAP1 0595 60 PUSH1 0x20 0597 01 ADD 0598 90 SWAP1 0599 92 SWAP3 059A 91 SWAP2 059B 90 SWAP1 059C 50 POP 059D 50 POP 059E 50 POP 059F 61 PUSH2 0x0ffe 05A2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @057C stack[-1] = 0x05a3 // @058F stack[0] = msg.data[0x04:0x24] // @0599 stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x0ffe, returns to 0x05A3 label_05A3: // Incoming return from call to 0x0FFE at 0x05A2 // Inputs[4] // { // @05A6 memory[0x40:0x60] // @05A8 stack[-1] // @05B3 memory[0x40:0x60] // @05B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05A3 5B JUMPDEST 05A4 60 PUSH1 0x40 05A6 51 MLOAD 05A7 80 DUP1 05A8 82 DUP3 05A9 81 DUP2 05AA 52 MSTORE 05AB 60 PUSH1 0x20 05AD 01 ADD 05AE 91 SWAP2 05AF 50 POP 05B0 50 POP 05B1 60 PUSH1 0x40 05B3 51 MLOAD 05B4 80 DUP1 05B5 91 SWAP2 05B6 03 SUB 05B7 90 SWAP1 05B8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @05AA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @05B8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_05B9: // Incoming jump from 0x00CF, if 0xdd62ed3e == stack[-1] // Inputs[1] { @05BA msg.value } 05B9 5B JUMPDEST 05BA 34 CALLVALUE 05BB 80 DUP1 05BC 15 ISZERO 05BD 61 PUSH2 0x05c5 05C0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05BA stack[0] = msg.value } // Block ends with conditional jump to 0x05c5, if !msg.value label_05C1: // Incoming jump from 0x05C0, if not !msg.value // Inputs[1] { @05C4 memory[0x00:0x00] } 05C1 60 PUSH1 0x00 05C3 80 DUP1 05C4 FD *REVERT // Stack delta = +0 // Outputs[1] { @05C4 revert(memory[0x00:0x00]); } // Block terminates label_05C5: // Incoming jump from 0x05C0, if !msg.value // Inputs[3] // { // @05CD msg.data.length // @05D4 msg.data[0x04:0x24] // @05F4 msg.data[0x24:0x44] // } 05C5 5B JUMPDEST 05C6 50 POP 05C7 61 PUSH2 0x061a 05CA 60 PUSH1 0x04 05CC 80 DUP1 05CD 36 CALLDATASIZE 05CE 03 SUB 05CF 81 DUP2 05D0 01 ADD 05D1 90 SWAP1 05D2 80 DUP1 05D3 80 DUP1 05D4 35 CALLDATALOAD 05D5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05EA 16 AND 05EB 90 SWAP1 05EC 60 PUSH1 0x20 05EE 01 ADD 05EF 90 SWAP1 05F0 92 SWAP3 05F1 91 SWAP2 05F2 90 SWAP1 05F3 80 DUP1 05F4 35 CALLDATALOAD 05F5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 060A 16 AND 060B 90 SWAP1 060C 60 PUSH1 0x20 060E 01 ADD 060F 90 SWAP1 0610 92 SWAP3 0611 91 SWAP2 0612 90 SWAP1 0613 50 POP 0614 50 POP 0615 50 POP 0616 61 PUSH2 0x102f 0619 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05C7 stack[-1] = 0x061a // @05F0 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @0610 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x24:0x44] // } // Block ends with call to 0x102f, returns to 0x061A label_061A: // Incoming return from call to 0x102F at 0x0619 // Inputs[4] // { // @061D memory[0x40:0x60] // @061F stack[-1] // @062A memory[0x40:0x60] // @062F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 061A 5B JUMPDEST 061B 60 PUSH1 0x40 061D 51 MLOAD 061E 80 DUP1 061F 82 DUP3 0620 81 DUP2 0621 52 MSTORE 0622 60 PUSH1 0x20 0624 01 ADD 0625 91 SWAP2 0626 50 POP 0627 50 POP 0628 60 PUSH1 0x40 062A 51 MLOAD 062B 80 DUP1 062C 91 SWAP2 062D 03 SUB 062E 90 SWAP1 062F F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0621 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @062F return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0630: // Incoming jump from 0x00DA, if 0xe6cb9013 == stack[-1] // Inputs[1] { @0631 msg.value } 0630 5B JUMPDEST 0631 34 CALLVALUE 0632 80 DUP1 0633 15 ISZERO 0634 61 PUSH2 0x063c 0637 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0631 stack[0] = msg.value } // Block ends with conditional jump to 0x063c, if !msg.value label_0638: // Incoming jump from 0x0637, if not !msg.value // Inputs[1] { @063B memory[0x00:0x00] } 0638 60 PUSH1 0x00 063A 80 DUP1 063B FD *REVERT // Stack delta = +0 // Outputs[1] { @063B revert(memory[0x00:0x00]); } // Block terminates label_063C: // Incoming jump from 0x0637, if !msg.value // Inputs[3] // { // @0644 msg.data.length // @064B msg.data[0x04:0x24] // @0655 msg.data[0x24:0x44] // } 063C 5B JUMPDEST 063D 50 POP 063E 61 PUSH2 0x0665 0641 60 PUSH1 0x04 0643 80 DUP1 0644 36 CALLDATASIZE 0645 03 SUB 0646 81 DUP2 0647 01 ADD 0648 90 SWAP1 0649 80 DUP1 064A 80 DUP1 064B 35 CALLDATALOAD 064C 90 SWAP1 064D 60 PUSH1 0x20 064F 01 ADD 0650 90 SWAP1 0651 92 SWAP3 0652 91 SWAP2 0653 90 SWAP1 0654 80 DUP1 0655 35 CALLDATALOAD 0656 90 SWAP1 0657 60 PUSH1 0x20 0659 01 ADD 065A 90 SWAP1 065B 92 SWAP3 065C 91 SWAP2 065D 90 SWAP1 065E 50 POP 065F 50 POP 0660 50 POP 0661 61 PUSH2 0x10b6 0664 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @063E stack[-1] = 0x0665 // @0651 stack[0] = msg.data[0x04:0x24] // @065B stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x10b6, returns to 0x0665 label_0665: // Incoming return from call to 0x10B6 at 0x0664 // Inputs[4] // { // @0668 memory[0x40:0x60] // @066A stack[-1] // @0675 memory[0x40:0x60] // @067A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0665 5B JUMPDEST 0666 60 PUSH1 0x40 0668 51 MLOAD 0669 80 DUP1 066A 82 DUP3 066B 81 DUP2 066C 52 MSTORE 066D 60 PUSH1 0x20 066F 01 ADD 0670 91 SWAP2 0671 50 POP 0672 50 POP 0673 60 PUSH1 0x40 0675 51 MLOAD 0676 80 DUP1 0677 91 SWAP2 0678 03 SUB 0679 90 SWAP1 067A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @066C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @067A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_067B: // Incoming call from 0x00F4, returns to 0x00F5 // Inputs[3] // { // @067F storage[0x01] // @06A0 memory[0x40:0x60] // @06B3 storage[0x01] // } 067B 5B JUMPDEST 067C 60 PUSH1 0x01 067E 80 DUP1 067F 54 SLOAD 0680 60 PUSH1 0x01 0682 81 DUP2 0683 60 PUSH1 0x01 0685 16 AND 0686 15 ISZERO 0687 61 PUSH2 0x0100 068A 02 MUL 068B 03 SUB 068C 16 AND 068D 60 PUSH1 0x02 068F 90 SWAP1 0690 04 DIV 0691 80 DUP1 0692 60 PUSH1 0x1f 0694 01 ADD 0695 60 PUSH1 0x20 0697 80 DUP1 0698 91 SWAP2 0699 04 DIV 069A 02 MUL 069B 60 PUSH1 0x20 069D 01 ADD 069E 60 PUSH1 0x40 06A0 51 MLOAD 06A1 90 SWAP1 06A2 81 DUP2 06A3 01 ADD 06A4 60 PUSH1 0x40 06A6 52 MSTORE 06A7 80 DUP1 06A8 92 SWAP3 06A9 91 SWAP2 06AA 90 SWAP1 06AB 81 DUP2 06AC 81 DUP2 06AD 52 MSTORE 06AE 60 PUSH1 0x20 06B0 01 ADD 06B1 82 DUP3 06B2 80 DUP1 06B3 54 SLOAD 06B4 60 PUSH1 0x01 06B6 81 DUP2 06B7 60 PUSH1 0x01 06B9 16 AND 06BA 15 ISZERO 06BB 61 PUSH2 0x0100 06BE 02 MUL 06BF 03 SUB 06C0 16 AND 06C1 60 PUSH1 0x02 06C3 90 SWAP1 06C4 04 DIV 06C5 80 DUP1 06C6 15 ISZERO 06C7 61 PUSH2 0x0711 06CA 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @06A6 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) / 0x20 * 0x20 // @06A8 stack[0] = memory[0x40:0x60] // @06A9 stack[1] = 0x01 // @06AA stack[2] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // @06AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // @06B0 stack[3] = 0x20 + memory[0x40:0x60] // @06B1 stack[4] = 0x01 // @06C4 stack[5] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // } // Block ends with conditional jump to 0x0711, if !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) label_06CB: // Incoming jump from 0x06CA, if not !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) // Inputs[1] { @06CB stack[-1] } 06CB 80 DUP1 06CC 60 PUSH1 0x1f 06CE 10 LT 06CF 61 PUSH2 0x06e6 06D2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06e6, if 0x1f < stack[-1] label_06D3: // Incoming jump from 0x06D2, if not 0x1f < stack[-1] // Inputs[4] // { // @06D7 stack[-2] // @06D8 storage[stack[-2]] // @06DB stack[-3] // @06DD stack[-1] // } 06D3 61 PUSH2 0x0100 06D6 80 DUP1 06D7 83 DUP4 06D8 54 SLOAD 06D9 04 DIV 06DA 02 MUL 06DB 83 DUP4 06DC 52 MSTORE 06DD 91 SWAP2 06DE 60 PUSH1 0x20 06E0 01 ADD 06E1 91 SWAP2 06E2 61 PUSH2 0x0711 06E5 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @06DC memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @06E1 stack[-1] = stack[-1] // @06E1 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0711 label_06E6: // Incoming jump from 0x06D2, if 0x1f < stack[-1] // Inputs[5] // { // @06E7 stack[-3] // @06E8 stack[-1] // @06EA stack[-2] // @06F2 memory[0x00:0x20] // @06F6 storage[keccak256(memory[0x00:0x20])] // } 06E6 5B JUMPDEST 06E7 82 DUP3 06E8 01 ADD 06E9 91 SWAP2 06EA 90 SWAP1 06EB 60 PUSH1 0x00 06ED 52 MSTORE 06EE 60 PUSH1 0x20 06F0 60 PUSH1 0x00 06F2 20 SHA3 06F3 90 SWAP1 06F4 5B JUMPDEST 06F5 81 DUP2 06F6 54 SLOAD 06F7 81 DUP2 06F8 52 MSTORE 06F9 90 SWAP1 06FA 60 PUSH1 0x01 06FC 01 ADD 06FD 90 SWAP1 06FE 60 PUSH1 0x20 0700 01 ADD 0701 80 DUP1 0702 83 DUP4 0703 11 GT 0704 61 PUSH2 0x06f4 0707 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @06E9 stack[-3] = stack[-3] + stack[-1] // @06ED memory[0x00:0x20] = stack[-2] // @06F8 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @06FD stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0700 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x06f4, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0708: // Incoming jump from 0x0707, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0707, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0708 stack[-3] // @0709 stack[-1] // } 0708 82 DUP3 0709 90 SWAP1 070A 03 SUB 070B 60 PUSH1 0x1f 070D 16 AND 070E 82 DUP3 070F 01 ADD 0710 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0710 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0710 stack[-1] = stack[-3] // } // Block continues label_0711: // Incoming jump from 0x06CA, if !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) // Incoming jump from 0x0710 // Incoming jump from 0x06E5 // Inputs[1] { @0717 stack[-7] } 0711 5B JUMPDEST 0712 50 POP 0713 50 POP 0714 50 POP 0715 50 POP 0716 50 POP 0717 81 DUP2 0718 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0719: // Incoming call from 0x01BA, returns to 0x01BB // Inputs[10] // { // @071C stack[-1] // @0721 msg.sender // @075B memory[0x00:0x40] // @075E stack[-2] // @0798 memory[0x00:0x40] // @07B4 msg.sender // @07EF memory[0x40:0x60] // @07FC memory[0x40:0x60] // @0801 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0806 stack[-3] // } 0719 5B JUMPDEST 071A 60 PUSH1 0x00 071C 81 DUP2 071D 60 PUSH1 0x05 071F 60 PUSH1 0x00 0721 33 CALLER 0722 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0737 16 AND 0738 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 074D 16 AND 074E 81 DUP2 074F 52 MSTORE 0750 60 PUSH1 0x20 0752 01 ADD 0753 90 SWAP1 0754 81 DUP2 0755 52 MSTORE 0756 60 PUSH1 0x20 0758 01 ADD 0759 60 PUSH1 0x00 075B 20 SHA3 075C 60 PUSH1 0x00 075E 85 DUP6 075F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0774 16 AND 0775 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 078A 16 AND 078B 81 DUP2 078C 52 MSTORE 078D 60 PUSH1 0x20 078F 01 ADD 0790 90 SWAP1 0791 81 DUP2 0792 52 MSTORE 0793 60 PUSH1 0x20 0795 01 ADD 0796 60 PUSH1 0x00 0798 20 SHA3 0799 81 DUP2 079A 90 SWAP1 079B 55 SSTORE 079C 50 POP 079D 82 DUP3 079E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07B3 16 AND 07B4 33 CALLER 07B5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07CA 16 AND 07CB 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 07EC 84 DUP5 07ED 60 PUSH1 0x40 07EF 51 MLOAD 07F0 80 DUP1 07F1 82 DUP3 07F2 81 DUP2 07F3 52 MSTORE 07F4 60 PUSH1 0x20 07F6 01 ADD 07F7 91 SWAP2 07F8 50 POP 07F9 50 POP 07FA 60 PUSH1 0x40 07FC 51 MLOAD 07FD 80 DUP1 07FE 91 SWAP2 07FF 03 SUB 0800 90 SWAP1 0801 A3 LOG3 0802 60 PUSH1 0x01 0804 90 SWAP1 0805 50 POP 0806 92 SWAP3 0807 91 SWAP2 0808 50 POP 0809 50 POP 080A 56 *JUMP // Stack delta = -2 // Outputs[8] // { // @074F memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0755 memory[0x20:0x40] = 0x05 // @078C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0792 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @079B storage[keccak256(memory[0x00:0x40])] = stack[-1] // @07F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0801 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // @0806 stack[-3] = 0x01 // } // Block ends with unconditional jump to stack[-3] label_080B: // Incoming call from 0x01E9, returns to 0x01EA // Inputs[4] // { // @084C memory[0x00:0x40] // @084D storage[keccak256(memory[0x00:0x40])] // @0850 storage[0x03] // @0854 stack[-1] // } 080B 5B JUMPDEST 080C 60 PUSH1 0x00 080E 60 PUSH1 0x04 0810 60 PUSH1 0x00 0812 80 DUP1 0813 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0828 16 AND 0829 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 083E 16 AND 083F 81 DUP2 0840 52 MSTORE 0841 60 PUSH1 0x20 0843 01 ADD 0844 90 SWAP1 0845 81 DUP2 0846 52 MSTORE 0847 60 PUSH1 0x20 0849 01 ADD 084A 60 PUSH1 0x00 084C 20 SHA3 084D 54 SLOAD 084E 60 PUSH1 0x03 0850 54 SLOAD 0851 03 SUB 0852 90 SWAP1 0853 50 POP 0854 90 SWAP1 0855 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0840 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // @0846 memory[0x20:0x40] = 0x04 // @0854 stack[-1] = storage[0x03] - storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-1] label_0856: // Incoming call from 0x026A, returns to 0x026B // Inputs[4] // { // @0860 stack[-3] // @089A memory[0x00:0x40] // @089B storage[keccak256(memory[0x00:0x40])] // @089C stack[-1] // } 0856 5B JUMPDEST 0857 60 PUSH1 0x00 0859 61 PUSH2 0x08a1 085C 60 PUSH1 0x04 085E 60 PUSH1 0x00 0860 86 DUP7 0861 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0876 16 AND 0877 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 088C 16 AND 088D 81 DUP2 088E 52 MSTORE 088F 60 PUSH1 0x20 0891 01 ADD 0892 90 SWAP1 0893 81 DUP2 0894 52 MSTORE 0895 60 PUSH1 0x20 0897 01 ADD 0898 60 PUSH1 0x00 089A 20 SHA3 089B 54 SLOAD 089C 83 DUP4 089D 61 PUSH2 0x0be6 08A0 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0857 stack[0] = 0x00 // @0859 stack[1] = 0x08a1 // @088E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0894 memory[0x20:0x40] = 0x04 // @089B stack[2] = storage[keccak256(memory[0x00:0x40])] // @089C stack[3] = stack[-1] // } // Block ends with call to 0x0be6, returns to 0x08A1 label_08A1: // Incoming return from call to 0x0BE6 at 0x08A0 // Inputs[8] // { // @08A6 stack[-5] // @08E0 memory[0x00:0x40] // @08E1 stack[-1] // @0926 memory[0x00:0x40] // @0929 msg.sender // @0963 memory[0x00:0x40] // @0964 storage[keccak256(memory[0x00:0x40])] // @0965 stack[-3] // } 08A1 5B JUMPDEST 08A2 60 PUSH1 0x04 08A4 60 PUSH1 0x00 08A6 86 DUP7 08A7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08BC 16 AND 08BD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08D2 16 AND 08D3 81 DUP2 08D4 52 MSTORE 08D5 60 PUSH1 0x20 08D7 01 ADD 08D8 90 SWAP1 08D9 81 DUP2 08DA 52 MSTORE 08DB 60 PUSH1 0x20 08DD 01 ADD 08DE 60 PUSH1 0x00 08E0 20 SHA3 08E1 81 DUP2 08E2 90 SWAP1 08E3 55 SSTORE 08E4 50 POP 08E5 61 PUSH2 0x096a 08E8 60 PUSH1 0x05 08EA 60 PUSH1 0x00 08EC 86 DUP7 08ED 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0902 16 AND 0903 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0918 16 AND 0919 81 DUP2 091A 52 MSTORE 091B 60 PUSH1 0x20 091D 01 ADD 091E 90 SWAP1 091F 81 DUP2 0920 52 MSTORE 0921 60 PUSH1 0x20 0923 01 ADD 0924 60 PUSH1 0x00 0926 20 SHA3 0927 60 PUSH1 0x00 0929 33 CALLER 092A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 093F 16 AND 0940 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0955 16 AND 0956 81 DUP2 0957 52 MSTORE 0958 60 PUSH1 0x20 095A 01 ADD 095B 90 SWAP1 095C 81 DUP2 095D 52 MSTORE 095E 60 PUSH1 0x20 0960 01 ADD 0961 60 PUSH1 0x00 0963 20 SHA3 0964 54 SLOAD 0965 83 DUP4 0966 61 PUSH2 0x0be6 0969 56 *JUMP // Stack delta = +2 // Outputs[10] // { // @08D4 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @08DA memory[0x20:0x40] = 0x04 // @08E3 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @08E5 stack[-1] = 0x096a // @091A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0920 memory[0x20:0x40] = 0x05 // @0957 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @095D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0964 stack[0] = storage[keccak256(memory[0x00:0x40])] // @0965 stack[1] = stack[-3] // } // Block ends with call to 0x0be6, returns to 0x096A label_096A: // Incoming return from call to 0x0BE6 at 0x0969 // Inputs[9] // { // @096F stack[-5] // @09A9 memory[0x00:0x40] // @09AC msg.sender // @09E6 memory[0x00:0x40] // @09E7 stack[-1] // @09F2 stack[-4] // @0A2C memory[0x00:0x40] // @0A2D storage[keccak256(memory[0x00:0x40])] // @0A2E stack[-3] // } 096A 5B JUMPDEST 096B 60 PUSH1 0x05 096D 60 PUSH1 0x00 096F 86 DUP7 0970 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0985 16 AND 0986 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 099B 16 AND 099C 81 DUP2 099D 52 MSTORE 099E 60 PUSH1 0x20 09A0 01 ADD 09A1 90 SWAP1 09A2 81 DUP2 09A3 52 MSTORE 09A4 60 PUSH1 0x20 09A6 01 ADD 09A7 60 PUSH1 0x00 09A9 20 SHA3 09AA 60 PUSH1 0x00 09AC 33 CALLER 09AD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09C2 16 AND 09C3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09D8 16 AND 09D9 81 DUP2 09DA 52 MSTORE 09DB 60 PUSH1 0x20 09DD 01 ADD 09DE 90 SWAP1 09DF 81 DUP2 09E0 52 MSTORE 09E1 60 PUSH1 0x20 09E3 01 ADD 09E4 60 PUSH1 0x00 09E6 20 SHA3 09E7 81 DUP2 09E8 90 SWAP1 09E9 55 SSTORE 09EA 50 POP 09EB 61 PUSH2 0x0a33 09EE 60 PUSH1 0x04 09F0 60 PUSH1 0x00 09F2 85 DUP6 09F3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A08 16 AND 0A09 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A1E 16 AND 0A1F 81 DUP2 0A20 52 MSTORE 0A21 60 PUSH1 0x20 0A23 01 ADD 0A24 90 SWAP1 0A25 81 DUP2 0A26 52 MSTORE 0A27 60 PUSH1 0x20 0A29 01 ADD 0A2A 60 PUSH1 0x00 0A2C 20 SHA3 0A2D 54 SLOAD 0A2E 83 DUP4 0A2F 61 PUSH2 0x10b6 0A32 56 *JUMP // Stack delta = +2 // Outputs[10] // { // @099D memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @09A3 memory[0x20:0x40] = 0x05 // @09DA memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @09E0 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @09E9 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @09EB stack[-1] = 0x0a33 // @0A20 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0A26 memory[0x20:0x40] = 0x04 // @0A2D stack[0] = storage[keccak256(memory[0x00:0x40])] // @0A2E stack[1] = stack[-3] // } // Block ends with call to 0x10b6, returns to 0x0A33 label_0A33: // Incoming return from call to 0x10B6 at 0x0A32 // Inputs[10] // { // @0A38 stack[-4] // @0A72 memory[0x00:0x40] // @0A73 stack[-1] // @0A8E stack[-5] // @0AC6 stack[-3] // @0AC9 memory[0x40:0x60] // @0AD6 memory[0x40:0x60] // @0ADB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0ADE stack[-2] // @0AE0 stack[-6] // } 0A33 5B JUMPDEST 0A34 60 PUSH1 0x04 0A36 60 PUSH1 0x00 0A38 85 DUP6 0A39 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A4E 16 AND 0A4F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A64 16 AND 0A65 81 DUP2 0A66 52 MSTORE 0A67 60 PUSH1 0x20 0A69 01 ADD 0A6A 90 SWAP1 0A6B 81 DUP2 0A6C 52 MSTORE 0A6D 60 PUSH1 0x20 0A6F 01 ADD 0A70 60 PUSH1 0x00 0A72 20 SHA3 0A73 81 DUP2 0A74 90 SWAP1 0A75 55 SSTORE 0A76 50 POP 0A77 82 DUP3 0A78 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A8D 16 AND 0A8E 84 DUP5 0A8F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AA4 16 AND 0AA5 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0AC6 84 DUP5 0AC7 60 PUSH1 0x40 0AC9 51 MLOAD 0ACA 80 DUP1 0ACB 82 DUP3 0ACC 81 DUP2 0ACD 52 MSTORE 0ACE 60 PUSH1 0x20 0AD0 01 ADD 0AD1 91 SWAP2 0AD2 50 POP 0AD3 50 POP 0AD4 60 PUSH1 0x40 0AD6 51 MLOAD 0AD7 80 DUP1 0AD8 91 SWAP2 0AD9 03 SUB 0ADA 90 SWAP1 0ADB A3 LOG3 0ADC 60 PUSH1 0x01 0ADE 90 SWAP1 0ADF 50 POP 0AE0 93 SWAP4 0AE1 92 SWAP3 0AE2 50 POP 0AE3 50 POP 0AE4 50 POP 0AE5 56 *JUMP // Stack delta = -5 // Outputs[6] // { // @0A66 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0A6C memory[0x20:0x40] = 0x04 // @0A75 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0ACD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @0ADB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]); // @0AE0 stack[-6] = 0x01 // } // Block ends with unconditional jump to stack[-6] label_0AE6: // Incoming call from 0x0299, returns to 0x029A // Inputs[2] // { // @0AEC storage[0x02] // @0AF7 stack[-1] // } 0AE6 5B JUMPDEST 0AE7 60 PUSH1 0x02 0AE9 60 PUSH1 0x00 0AEB 90 SWAP1 0AEC 54 SLOAD 0AED 90 SWAP1 0AEE 61 PUSH2 0x0100 0AF1 0A EXP 0AF2 90 SWAP1 0AF3 04 DIV 0AF4 60 PUSH1 0xff 0AF6 16 AND 0AF7 81 DUP2 0AF8 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AF6 stack[0] = 0xff & storage[0x02] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0AF9: // Incoming call from 0x02CA, returns to 0x02CB // Inputs[2] // { // @0AFC storage[0x03] // @0AFD stack[-1] // } 0AF9 5B JUMPDEST 0AFA 60 PUSH1 0x03 0AFC 54 SLOAD 0AFD 81 DUP2 0AFE 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AFC stack[0] = storage[0x03] } // Block ends with unconditional jump to stack[-1] label_0AFF: // Incoming call from 0x0321, returns to 0x0322 // Inputs[4] // { // @0B06 stack[-1] // @0B40 memory[0x00:0x40] // @0B41 storage[keccak256(memory[0x00:0x40])] // @0B44 stack[-2] // } 0AFF 5B JUMPDEST 0B00 60 PUSH1 0x00 0B02 60 PUSH1 0x04 0B04 60 PUSH1 0x00 0B06 83 DUP4 0B07 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B1C 16 AND 0B1D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B32 16 AND 0B33 81 DUP2 0B34 52 MSTORE 0B35 60 PUSH1 0x20 0B37 01 ADD 0B38 90 SWAP1 0B39 81 DUP2 0B3A 52 MSTORE 0B3B 60 PUSH1 0x20 0B3D 01 ADD 0B3E 60 PUSH1 0x00 0B40 20 SHA3 0B41 54 SLOAD 0B42 90 SWAP1 0B43 50 POP 0B44 91 SWAP2 0B45 90 SWAP1 0B46 50 POP 0B47 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0B34 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0B3A memory[0x20:0x40] = 0x04 // @0B44 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0B48: // Incoming call from 0x034C, returns to 0x034D // Inputs[3] // { // @0B4C storage[0x00] // @0B6D memory[0x40:0x60] // @0B80 storage[0x00] // } 0B48 5B JUMPDEST 0B49 60 PUSH1 0x00 0B4B 80 DUP1 0B4C 54 SLOAD 0B4D 60 PUSH1 0x01 0B4F 81 DUP2 0B50 60 PUSH1 0x01 0B52 16 AND 0B53 15 ISZERO 0B54 61 PUSH2 0x0100 0B57 02 MUL 0B58 03 SUB 0B59 16 AND 0B5A 60 PUSH1 0x02 0B5C 90 SWAP1 0B5D 04 DIV 0B5E 80 DUP1 0B5F 60 PUSH1 0x1f 0B61 01 ADD 0B62 60 PUSH1 0x20 0B64 80 DUP1 0B65 91 SWAP2 0B66 04 DIV 0B67 02 MUL 0B68 60 PUSH1 0x20 0B6A 01 ADD 0B6B 60 PUSH1 0x40 0B6D 51 MLOAD 0B6E 90 SWAP1 0B6F 81 DUP2 0B70 01 ADD 0B71 60 PUSH1 0x40 0B73 52 MSTORE 0B74 80 DUP1 0B75 92 SWAP3 0B76 91 SWAP2 0B77 90 SWAP1 0B78 81 DUP2 0B79 81 DUP2 0B7A 52 MSTORE 0B7B 60 PUSH1 0x20 0B7D 01 ADD 0B7E 82 DUP3 0B7F 80 DUP1 0B80 54 SLOAD 0B81 60 PUSH1 0x01 0B83 81 DUP2 0B84 60 PUSH1 0x01 0B86 16 AND 0B87 15 ISZERO 0B88 61 PUSH2 0x0100 0B8B 02 MUL 0B8C 03 SUB 0B8D 16 AND 0B8E 60 PUSH1 0x02 0B90 90 SWAP1 0B91 04 DIV 0B92 80 DUP1 0B93 15 ISZERO 0B94 61 PUSH2 0x0bde 0B97 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @0B73 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) / 0x20 * 0x20 // @0B75 stack[0] = memory[0x40:0x60] // @0B76 stack[1] = 0x00 // @0B77 stack[2] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // @0B7A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // @0B7D stack[3] = 0x20 + memory[0x40:0x60] // @0B7E stack[4] = 0x00 // @0B91 stack[5] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // } // Block ends with conditional jump to 0x0bde, if !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) label_0B98: // Incoming jump from 0x0B97, if not !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) // Inputs[1] { @0B98 stack[-1] } 0B98 80 DUP1 0B99 60 PUSH1 0x1f 0B9B 10 LT 0B9C 61 PUSH2 0x0bb3 0B9F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bb3, if 0x1f < stack[-1] label_0BA0: // Incoming jump from 0x0B9F, if not 0x1f < stack[-1] // Inputs[4] // { // @0BA4 stack[-2] // @0BA5 storage[stack[-2]] // @0BA8 stack[-3] // @0BAA stack[-1] // } 0BA0 61 PUSH2 0x0100 0BA3 80 DUP1 0BA4 83 DUP4 0BA5 54 SLOAD 0BA6 04 DIV 0BA7 02 MUL 0BA8 83 DUP4 0BA9 52 MSTORE 0BAA 91 SWAP2 0BAB 60 PUSH1 0x20 0BAD 01 ADD 0BAE 91 SWAP2 0BAF 61 PUSH2 0x0bde 0BB2 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0BA9 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0BAE stack[-1] = stack[-1] // @0BAE stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0bde label_0BB3: // Incoming jump from 0x0B9F, if 0x1f < stack[-1] // Inputs[5] // { // @0BB4 stack[-3] // @0BB5 stack[-1] // @0BB7 stack[-2] // @0BBF memory[0x00:0x20] // @0BC3 storage[keccak256(memory[0x00:0x20])] // } 0BB3 5B JUMPDEST 0BB4 82 DUP3 0BB5 01 ADD 0BB6 91 SWAP2 0BB7 90 SWAP1 0BB8 60 PUSH1 0x00 0BBA 52 MSTORE 0BBB 60 PUSH1 0x20 0BBD 60 PUSH1 0x00 0BBF 20 SHA3 0BC0 90 SWAP1 0BC1 5B JUMPDEST 0BC2 81 DUP2 0BC3 54 SLOAD 0BC4 81 DUP2 0BC5 52 MSTORE 0BC6 90 SWAP1 0BC7 60 PUSH1 0x01 0BC9 01 ADD 0BCA 90 SWAP1 0BCB 60 PUSH1 0x20 0BCD 01 ADD 0BCE 80 DUP1 0BCF 83 DUP4 0BD0 11 GT 0BD1 61 PUSH2 0x0bc1 0BD4 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0BB6 stack[-3] = stack[-3] + stack[-1] // @0BBA memory[0x00:0x20] = stack[-2] // @0BC5 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0BCA stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0BCD stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0bc1, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0BD5: // Incoming jump from 0x0BD4, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0BD4, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0BD5 stack[-3] // @0BD6 stack[-1] // } 0BD5 82 DUP3 0BD6 90 SWAP1 0BD7 03 SUB 0BD8 60 PUSH1 0x1f 0BDA 16 AND 0BDB 82 DUP3 0BDC 01 ADD 0BDD 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0BDD stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0BDD stack[-1] = stack[-3] // } // Block continues label_0BDE: // Incoming jump from 0x0BB2 // Incoming jump from 0x0B97, if !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) // Incoming jump from 0x0BDD // Inputs[1] { @0BE4 stack[-7] } 0BDE 5B JUMPDEST 0BDF 50 POP 0BE0 50 POP 0BE1 50 POP 0BE2 50 POP 0BE3 50 POP 0BE4 81 DUP2 0BE5 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0BE6: // Incoming call from 0x0969, returns to 0x096A // Incoming call from 0x0C4C, returns to 0x0C4D // Incoming call from 0x08A0, returns to 0x08A1 // Incoming call from 0x03FC, returns to 0x03FD // Inputs[2] // { // @0BE9 stack[-2] // @0BEA stack[-1] // } 0BE6 5B JUMPDEST 0BE7 60 PUSH1 0x00 0BE9 82 DUP3 0BEA 82 DUP3 0BEB 11 GT 0BEC 15 ISZERO 0BED 15 ISZERO 0BEE 15 ISZERO 0BEF 61 PUSH2 0x0bf7 0BF2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BE7 stack[0] = 0x00 } // Block ends with conditional jump to 0x0bf7, if !!!(stack[-1] > stack[-2]) label_0BF3: // Incoming jump from 0x0BF2, if not !!!(stack[-1] > stack[-2]) // Inputs[1] { @0BF6 memory[0x00:0x00] } 0BF3 60 PUSH1 0x00 0BF5 80 DUP1 0BF6 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BF6 revert(memory[0x00:0x00]); } // Block terminates label_0BF7: // Incoming jump from 0x0BF2, if !!!(stack[-1] > stack[-2]) // Inputs[4] // { // @0BF8 stack[-2] // @0BF9 stack[-3] // @0BFB stack[-1] // @0BFD stack[-4] // } 0BF7 5B JUMPDEST 0BF8 81 DUP2 0BF9 83 DUP4 0BFA 03 SUB 0BFB 90 SWAP1 0BFC 50 POP 0BFD 92 SWAP3 0BFE 91 SWAP2 0BFF 50 POP 0C00 50 POP 0C01 56 *JUMP // Stack delta = -3 // Outputs[1] { @0BFD stack[-4] = stack[-3] - stack[-2] } // Block ends with unconditional jump to stack[-4] label_0C02: // Incoming call from 0x045D, returns to 0x045E // Inputs[4] // { // @0C0C msg.sender // @0C46 memory[0x00:0x40] // @0C47 storage[keccak256(memory[0x00:0x40])] // @0C48 stack[-1] // } 0C02 5B JUMPDEST 0C03 60 PUSH1 0x00 0C05 61 PUSH2 0x0c4d 0C08 60 PUSH1 0x04 0C0A 60 PUSH1 0x00 0C0C 33 CALLER 0C0D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C22 16 AND 0C23 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C38 16 AND 0C39 81 DUP2 0C3A 52 MSTORE 0C3B 60 PUSH1 0x20 0C3D 01 ADD 0C3E 90 SWAP1 0C3F 81 DUP2 0C40 52 MSTORE 0C41 60 PUSH1 0x20 0C43 01 ADD 0C44 60 PUSH1 0x00 0C46 20 SHA3 0C47 54 SLOAD 0C48 83 DUP4 0C49 61 PUSH2 0x0be6 0C4C 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0C03 stack[0] = 0x00 // @0C05 stack[1] = 0x0c4d // @0C3A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0C40 memory[0x20:0x40] = 0x04 // @0C47 stack[2] = storage[keccak256(memory[0x00:0x40])] // @0C48 stack[3] = stack[-1] // } // Block ends with call to 0x0be6, returns to 0x0C4D label_0C4D: // Incoming return from call to 0x0BE6 at 0x0C4C // Inputs[7] // { // @0C52 msg.sender // @0C8C memory[0x00:0x40] // @0C8D stack[-1] // @0C98 stack[-4] // @0CD2 memory[0x00:0x40] // @0CD3 storage[keccak256(memory[0x00:0x40])] // @0CD4 stack[-3] // } 0C4D 5B JUMPDEST 0C4E 60 PUSH1 0x04 0C50 60 PUSH1 0x00 0C52 33 CALLER 0C53 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C68 16 AND 0C69 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C7E 16 AND 0C7F 81 DUP2 0C80 52 MSTORE 0C81 60 PUSH1 0x20 0C83 01 ADD 0C84 90 SWAP1 0C85 81 DUP2 0C86 52 MSTORE 0C87 60 PUSH1 0x20 0C89 01 ADD 0C8A 60 PUSH1 0x00 0C8C 20 SHA3 0C8D 81 DUP2 0C8E 90 SWAP1 0C8F 55 SSTORE 0C90 50 POP 0C91 61 PUSH2 0x0cd9 0C94 60 PUSH1 0x04 0C96 60 PUSH1 0x00 0C98 85 DUP6 0C99 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CAE 16 AND 0CAF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CC4 16 AND 0CC5 81 DUP2 0CC6 52 MSTORE 0CC7 60 PUSH1 0x20 0CC9 01 ADD 0CCA 90 SWAP1 0CCB 81 DUP2 0CCC 52 MSTORE 0CCD 60 PUSH1 0x20 0CCF 01 ADD 0CD0 60 PUSH1 0x00 0CD2 20 SHA3 0CD3 54 SLOAD 0CD4 83 DUP4 0CD5 61 PUSH2 0x10b6 0CD8 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @0C80 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0C86 memory[0x20:0x40] = 0x04 // @0C8F storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0C91 stack[-1] = 0x0cd9 // @0CC6 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0CCC memory[0x20:0x40] = 0x04 // @0CD3 stack[0] = storage[keccak256(memory[0x00:0x40])] // @0CD4 stack[1] = stack[-3] // } // Block ends with call to 0x10b6, returns to 0x0CD9 label_0CD9: // Incoming return from call to 0x10B6 at 0x0CD8 // Inputs[10] // { // @0CDE stack[-4] // @0D18 memory[0x00:0x40] // @0D19 stack[-1] // @0D34 msg.sender // @0D6C stack[-3] // @0D6F memory[0x40:0x60] // @0D7C memory[0x40:0x60] // @0D81 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0D84 stack[-2] // @0D86 stack[-5] // } 0CD9 5B JUMPDEST 0CDA 60 PUSH1 0x04 0CDC 60 PUSH1 0x00 0CDE 85 DUP6 0CDF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CF4 16 AND 0CF5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D0A 16 AND 0D0B 81 DUP2 0D0C 52 MSTORE 0D0D 60 PUSH1 0x20 0D0F 01 ADD 0D10 90 SWAP1 0D11 81 DUP2 0D12 52 MSTORE 0D13 60 PUSH1 0x20 0D15 01 ADD 0D16 60 PUSH1 0x00 0D18 20 SHA3 0D19 81 DUP2 0D1A 90 SWAP1 0D1B 55 SSTORE 0D1C 50 POP 0D1D 82 DUP3 0D1E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D33 16 AND 0D34 33 CALLER 0D35 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D4A 16 AND 0D4B 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0D6C 84 DUP5 0D6D 60 PUSH1 0x40 0D6F 51 MLOAD 0D70 80 DUP1 0D71 82 DUP3 0D72 81 DUP2 0D73 52 MSTORE 0D74 60 PUSH1 0x20 0D76 01 ADD 0D77 91 SWAP2 0D78 50 POP 0D79 50 POP 0D7A 60 PUSH1 0x40 0D7C 51 MLOAD 0D7D 80 DUP1 0D7E 91 SWAP2 0D7F 03 SUB 0D80 90 SWAP1 0D81 A3 LOG3 0D82 60 PUSH1 0x01 0D84 90 SWAP1 0D85 50 POP 0D86 92 SWAP3 0D87 91 SWAP2 0D88 50 POP 0D89 50 POP 0D8A 56 *JUMP // Stack delta = -4 // Outputs[6] // { // @0D0C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0D12 memory[0x20:0x40] = 0x04 // @0D1B storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0D73 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @0D81 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, msg.sender, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]); // @0D86 stack[-5] = 0x01 // } // Block ends with unconditional jump to stack[-5] label_0D8B: // Incoming call from 0x04AC, returns to 0x04AD // Inputs[1] { @0D8F stack[-1] } 0D8B 5B JUMPDEST 0D8C 60 PUSH1 0x00 0D8E 80 DUP1 0D8F 82 DUP3 0D90 11 GT 0D91 15 ISZERO 0D92 15 ISZERO 0D93 61 PUSH2 0x0d9b 0D96 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D8C stack[0] = 0x00 } // Block ends with conditional jump to 0x0d9b, if !!(stack[-1] > 0x00) label_0D97: // Incoming jump from 0x0D96, if not !!(stack[-1] > 0x00) // Inputs[1] { @0D9A memory[0x00:0x00] } 0D97 60 PUSH1 0x00 0D99 80 DUP1 0D9A FD *REVERT // Stack delta = +0 // Outputs[1] { @0D9A revert(memory[0x00:0x00]); } // Block terminates label_0D9B: // Incoming jump from 0x0D96, if !!(stack[-1] > 0x00) // Inputs[2] // { // @0D9C stack[-2] // @0D9D stack[-3] // } 0D9B 5B JUMPDEST 0D9C 81 DUP2 0D9D 83 DUP4 0D9E 81 DUP2 0D9F 15 ISZERO 0DA0 15 ISZERO 0DA1 61 PUSH2 0x0da6 0DA4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0D9C stack[0] = stack[-2] // @0D9D stack[1] = stack[-3] // } // Block ends with conditional jump to 0x0da6, if !!stack[-2] label_0DA5: // Incoming jump from 0x0DA4, if not !!stack[-2] 0DA5 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0DA5 assert(); } // Block terminates label_0DA6: // Incoming jump from 0x0DA4, if !!stack[-2] // Inputs[5] // { // @0DA7 stack[-1] // @0DA7 stack[-2] // @0DA8 stack[-3] // @0DAA stack[-6] // @0DAB stack[-5] // } 0DA6 5B JUMPDEST 0DA7 04 DIV 0DA8 90 SWAP1 0DA9 50 POP 0DAA 92 SWAP3 0DAB 91 SWAP2 0DAC 50 POP 0DAD 50 POP 0DAE 56 *JUMP // Stack delta = -5 // Outputs[1] { @0DAA stack[-6] = stack[-1] / stack[-2] } // Block ends with unconditional jump to stack[-6] label_0DAF: // Incoming call from 0x0553, returns to 0x0554 // Inputs[15] // { // @0DB2 stack[-2] // @0DB7 msg.sender // @0DF1 memory[0x00:0x40] // @0DF4 stack[-3] // @0E2E memory[0x00:0x40] // @0E4A msg.sender // @0E85 memory[0x40:0x60] // @0E92 memory[0x40:0x60] // @0E97 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0EB4 msg.sender // @0EB6 address(this) // @0EB7 stack[-1] // @0EBA memory[0x40:0x60] // @0F5D memory[stack[-1]:stack[-1] + 0x20] // @0F66 memory[stack[-1]:stack[-1] + 0x20] // } 0DAF 5B JUMPDEST 0DB0 60 PUSH1 0x00 0DB2 82 DUP3 0DB3 60 PUSH1 0x05 0DB5 60 PUSH1 0x00 0DB7 33 CALLER 0DB8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DCD 16 AND 0DCE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DE3 16 AND 0DE4 81 DUP2 0DE5 52 MSTORE 0DE6 60 PUSH1 0x20 0DE8 01 ADD 0DE9 90 SWAP1 0DEA 81 DUP2 0DEB 52 MSTORE 0DEC 60 PUSH1 0x20 0DEE 01 ADD 0DEF 60 PUSH1 0x00 0DF1 20 SHA3 0DF2 60 PUSH1 0x00 0DF4 86 DUP7 0DF5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E0A 16 AND 0E0B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E20 16 AND 0E21 81 DUP2 0E22 52 MSTORE 0E23 60 PUSH1 0x20 0E25 01 ADD 0E26 90 SWAP1 0E27 81 DUP2 0E28 52 MSTORE 0E29 60 PUSH1 0x20 0E2B 01 ADD 0E2C 60 PUSH1 0x00 0E2E 20 SHA3 0E2F 81 DUP2 0E30 90 SWAP1 0E31 55 SSTORE 0E32 50 POP 0E33 83 DUP4 0E34 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E49 16 AND 0E4A 33 CALLER 0E4B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E60 16 AND 0E61 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0E82 85 DUP6 0E83 60 PUSH1 0x40 0E85 51 MLOAD 0E86 80 DUP1 0E87 82 DUP3 0E88 81 DUP2 0E89 52 MSTORE 0E8A 60 PUSH1 0x20 0E8C 01 ADD 0E8D 91 SWAP2 0E8E 50 POP 0E8F 50 POP 0E90 60 PUSH1 0x40 0E92 51 MLOAD 0E93 80 DUP1 0E94 91 SWAP2 0E95 03 SUB 0E96 90 SWAP1 0E97 A3 LOG3 0E98 83 DUP4 0E99 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EAE 16 AND 0EAF 63 PUSH4 0x8f4ffcb1 0EB4 33 CALLER 0EB5 85 DUP6 0EB6 30 ADDRESS 0EB7 86 DUP7 0EB8 60 PUSH1 0x40 0EBA 51 MLOAD 0EBB 85 DUP6 0EBC 63 PUSH4 0xffffffff 0EC1 16 AND 0EC2 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 0EE0 02 MUL 0EE1 81 DUP2 0EE2 52 MSTORE 0EE3 60 PUSH1 0x04 0EE5 01 ADD 0EE6 80 DUP1 0EE7 85 DUP6 0EE8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EFD 16 AND 0EFE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F13 16 AND 0F14 81 DUP2 0F15 52 MSTORE 0F16 60 PUSH1 0x20 0F18 01 ADD 0F19 84 DUP5 0F1A 81 DUP2 0F1B 52 MSTORE 0F1C 60 PUSH1 0x20 0F1E 01 ADD 0F1F 83 DUP4 0F20 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F35 16 AND 0F36 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F4B 16 AND 0F4C 81 DUP2 0F4D 52 MSTORE 0F4E 60 PUSH1 0x20 0F50 01 ADD 0F51 80 DUP1 0F52 60 PUSH1 0x20 0F54 01 ADD 0F55 82 DUP3 0F56 81 DUP2 0F57 03 SUB 0F58 82 DUP3 0F59 52 MSTORE 0F5A 83 DUP4 0F5B 81 DUP2 0F5C 81 DUP2 0F5D 51 MLOAD 0F5E 81 DUP2 0F5F 52 MSTORE 0F60 60 PUSH1 0x20 0F62 01 ADD 0F63 91 SWAP2 0F64 50 POP 0F65 80 DUP1 0F66 51 MLOAD 0F67 90 SWAP1 0F68 60 PUSH1 0x20 0F6A 01 ADD 0F6B 90 SWAP1 0F6C 80 DUP1 0F6D 83 DUP4 0F6E 83 DUP4 0F6F 60 PUSH1 0x00 0F71 5B JUMPDEST 0F72 83 DUP4 0F73 81 DUP2 0F74 10 LT 0F75 15 ISZERO 0F76 61 PUSH2 0x0f8c 0F79 57 *JUMPI // Stack delta = +16 // Outputs[29] // { // @0DB0 stack[0] = 0x00 // @0DE5 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0DEB memory[0x20:0x40] = 0x05 // @0E22 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0E28 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0E31 storage[keccak256(memory[0x00:0x40])] = stack[-2] // @0E89 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0E97 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]); // @0EAE stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0EAF stack[2] = 0x8f4ffcb1 // @0EB4 stack[3] = msg.sender // @0EB5 stack[4] = stack[-2] // @0EB6 stack[5] = address(this) // @0EB7 stack[6] = stack[-1] // @0EE2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0x8f4ffcb1) // @0EE5 stack[7] = 0x04 + memory[0x40:0x60] // @0F15 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0F1B memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-2] // @0F4D memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @0F50 stack[8] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @0F59 memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0F5F memory[0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0F63 stack[9] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @0F6B stack[11] = memory[stack[-1]:stack[-1] + 0x20] // @0F6B stack[10] = 0x20 + stack[-1] // @0F6C stack[12] = memory[stack[-1]:stack[-1] + 0x20] // @0F6D stack[13] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @0F6E stack[14] = 0x20 + stack[-1] // @0F6F stack[15] = 0x00 // } // Block ends with conditional jump to 0x0f8c, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0F7A: // Incoming jump from 0x0F79, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0F79, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0F7A stack[-1] // @0F7B stack[-2] // @0F7D memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0F7F stack[-3] // } 0F7A 80 DUP1 0F7B 82 DUP3 0F7C 01 ADD 0F7D 51 MLOAD 0F7E 81 DUP2 0F7F 84 DUP5 0F80 01 ADD 0F81 52 MSTORE 0F82 60 PUSH1 0x20 0F84 81 DUP2 0F85 01 ADD 0F86 90 SWAP1 0F87 50 POP 0F88 61 PUSH2 0x0f71 0F8B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0F81 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0F86 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0f71 label_0F8C: // Incoming jump from 0x0F79, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0F79, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0F91 stack[-6] // @0F91 stack[-5] // @0F93 stack[-7] // } 0F8C 5B JUMPDEST 0F8D 50 POP 0F8E 50 POP 0F8F 50 POP 0F90 50 POP 0F91 90 SWAP1 0F92 50 POP 0F93 90 SWAP1 0F94 81 DUP2 0F95 01 ADD 0F96 90 SWAP1 0F97 60 PUSH1 0x1f 0F99 16 AND 0F9A 80 DUP1 0F9B 15 ISZERO 0F9C 61 PUSH2 0x0fb9 0F9F 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0F96 stack[-7] = stack[-5] + stack[-7] // @0F99 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0fb9, if !(0x1f & stack[-5]) label_0FA0: // Incoming jump from 0x0F9F, if not !(0x1f & stack[-5]) // Inputs[7] // { // @0FA0 stack[-1] // @0FA1 stack[-2] // @0FA4 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0FBB stack[-8] // @0FC6 memory[0x40:0x60] // @0FCD stack[-10] // @0FCF address(stack[-10]).code.length // } 0FA0 80 DUP1 0FA1 82 DUP3 0FA2 03 SUB 0FA3 80 DUP1 0FA4 51 MLOAD 0FA5 60 PUSH1 0x01 0FA7 83 DUP4 0FA8 60 PUSH1 0x20 0FAA 03 SUB 0FAB 61 PUSH2 0x0100 0FAE 0A EXP 0FAF 03 SUB 0FB0 19 NOT 0FB1 16 AND 0FB2 81 DUP2 0FB3 52 MSTORE 0FB4 60 PUSH1 0x20 0FB6 01 ADD 0FB7 91 SWAP2 0FB8 50 POP 0FB9 5B JUMPDEST 0FBA 50 POP 0FBB 95 SWAP6 0FBC 50 POP 0FBD 50 POP 0FBE 50 POP 0FBF 50 POP 0FC0 50 POP 0FC1 50 POP 0FC2 60 PUSH1 0x00 0FC4 60 PUSH1 0x40 0FC6 51 MLOAD 0FC7 80 DUP1 0FC8 83 DUP4 0FC9 03 SUB 0FCA 81 DUP2 0FCB 60 PUSH1 0x00 0FCD 87 DUP8 0FCE 80 DUP1 0FCF 3B EXTCODESIZE 0FD0 15 ISZERO 0FD1 80 DUP1 0FD2 15 ISZERO 0FD3 61 PUSH2 0x0fdb 0FD6 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0FB3 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] // @0FBB stack[-8] = 0x20 + (stack[-2] - stack[-1]) // @0FC2 stack[-7] = 0x00 // @0FC6 stack[-6] = memory[0x40:0x60] // @0FC9 stack[-5] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @0FCA stack[-4] = memory[0x40:0x60] // @0FCB stack[-3] = 0x00 // @0FCD stack[-2] = stack[-10] // @0FD0 stack[-1] = !address(stack[-10]).code.length // } // Block ends with conditional jump to 0x0fdb, if !!address(stack[-10]).code.length label_0FD7: // Incoming jump from 0x0FD6, if not !!address(stack[-10]).code.length // Incoming jump from 0x0FD6, if not !!address(stack[-10]).code.length // Inputs[1] { @0FDA memory[0x00:0x00] } 0FD7 60 PUSH1 0x00 0FD9 80 DUP1 0FDA FD *REVERT // Stack delta = +0 // Outputs[1] { @0FDA revert(memory[0x00:0x00]); } // Block terminates label_0FDB: // Incoming jump from 0x0FD6, if !!address(stack[-10]).code.length // Incoming jump from 0x0FD6, if !!address(stack[-10]).code.length // Inputs[9] // { // @0FDD msg.gas // @0FDE stack[-6] // @0FDE stack[-4] // @0FDE address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0FDE stack[-3] // @0FDE memory[stack[-4]:stack[-4] + stack[-5]] // @0FDE stack[-7] // @0FDE stack[-5] // @0FDE stack[-2] // } 0FDB 5B JUMPDEST 0FDC 50 POP 0FDD 5A GAS 0FDE F1 CALL 0FDF 15 ISZERO 0FE0 80 DUP1 0FE1 15 ISZERO 0FE2 61 PUSH2 0x0fef 0FE5 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0FDE memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0FDF stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x0fef, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0FE6: // Incoming jump from 0x0FE5, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0FE6 returndata.length // @0FEA returndata[0x00:0x00 + returndata.length] // @0FEB returndata.length // @0FEE memory[0x00:0x00 + returndata.length] // } 0FE6 3D RETURNDATASIZE 0FE7 60 PUSH1 0x00 0FE9 80 DUP1 0FEA 3E RETURNDATACOPY 0FEB 3D RETURNDATASIZE 0FEC 60 PUSH1 0x00 0FEE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0FEA memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0FEE revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0FEF: // Incoming jump from 0x0FE5, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[3] // { // @0FF6 stack[-5] // @0FF8 stack[-9] // @0FF9 stack[-8] // } 0FEF 5B JUMPDEST 0FF0 50 POP 0FF1 50 POP 0FF2 50 POP 0FF3 50 POP 0FF4 60 PUSH1 0x01 0FF6 90 SWAP1 0FF7 50 POP 0FF8 93 SWAP4 0FF9 92 SWAP3 0FFA 50 POP 0FFB 50 POP 0FFC 50 POP 0FFD 56 *JUMP // Stack delta = -8 // Outputs[1] { @0FF8 stack[-9] = 0x01 } // Block ends with unconditional jump to stack[-9] label_0FFE: // Incoming call from 0x05A2, returns to 0x05A3 // Inputs[2] // { // @1001 stack[-1] // @1002 stack[-2] // } 0FFE 5B JUMPDEST 0FFF 60 PUSH1 0x00 1001 81 DUP2 1002 83 DUP4 1003 02 MUL 1004 90 SWAP1 1005 50 POP 1006 60 PUSH1 0x00 1008 83 DUP4 1009 14 EQ 100A 80 DUP1 100B 61 PUSH2 0x101e 100E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1004 stack[0] = stack[-2] * stack[-1] // @1009 stack[1] = stack[-2] == 0x00 // } // Block ends with conditional jump to 0x101e, if stack[-2] == 0x00 label_100F: // Incoming jump from 0x100E, if not stack[-2] == 0x00 // Inputs[3] // { // @1010 stack[-3] // @1011 stack[-4] // @1012 stack[-2] // } 100F 50 POP 1010 81 DUP2 1011 83 DUP4 1012 82 DUP3 1013 81 DUP2 1014 15 ISZERO 1015 15 ISZERO 1016 61 PUSH2 0x101b 1019 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1010 stack[-1] = stack[-3] // @1011 stack[0] = stack[-4] // @1012 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x101b, if !!stack[-4] label_101A: // Incoming jump from 0x1019, if not !!stack[-4] 101A FE *ASSERT // Stack delta = +0 // Outputs[1] { @101A assert(); } // Block terminates label_101B: // Incoming jump from 0x1019, if !!stack[-4] // Inputs[3] // { // @101C stack[-1] // @101C stack[-2] // @101D stack[-3] // } 101B 5B JUMPDEST 101C 04 DIV 101D 14 EQ // Stack delta = -2 // Outputs[1] { @101D stack[-3] = stack[-1] / stack[-2] == stack[-3] } // Block continues label_101E: // Incoming jump from 0x100E, if stack[-2] == 0x00 // Incoming jump from 0x101D // Inputs[1] { @101F stack[-1] } 101E 5B JUMPDEST 101F 15 ISZERO 1020 15 ISZERO 1021 61 PUSH2 0x1029 1024 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1029, if !!stack[-1] label_1025: // Incoming jump from 0x1024, if not !!stack[-1] // Inputs[1] { @1028 memory[0x00:0x00] } 1025 60 PUSH1 0x00 1027 80 DUP1 1028 FD *REVERT // Stack delta = +0 // Outputs[1] { @1028 revert(memory[0x00:0x00]); } // Block terminates label_1029: // Incoming jump from 0x1024, if !!stack[-1] // Inputs[3] // { // @102A stack[-1] // @102A stack[-4] // @102B stack[-3] // } 1029 5B JUMPDEST 102A 92 SWAP3 102B 91 SWAP2 102C 50 POP 102D 50 POP 102E 56 *JUMP // Stack delta = -3 // Outputs[1] { @102A stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_102F: // Incoming call from 0x0619, returns to 0x061A // Inputs[6] // { // @1036 stack[-2] // @1070 memory[0x00:0x40] // @1073 stack[-1] // @10AD memory[0x00:0x40] // @10AE storage[keccak256(memory[0x00:0x40])] // @10B1 stack[-3] // } 102F 5B JUMPDEST 1030 60 PUSH1 0x00 1032 60 PUSH1 0x05 1034 60 PUSH1 0x00 1036 84 DUP5 1037 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 104C 16 AND 104D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1062 16 AND 1063 81 DUP2 1064 52 MSTORE 1065 60 PUSH1 0x20 1067 01 ADD 1068 90 SWAP1 1069 81 DUP2 106A 52 MSTORE 106B 60 PUSH1 0x20 106D 01 ADD 106E 60 PUSH1 0x00 1070 20 SHA3 1071 60 PUSH1 0x00 1073 83 DUP4 1074 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1089 16 AND 108A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 109F 16 AND 10A0 81 DUP2 10A1 52 MSTORE 10A2 60 PUSH1 0x20 10A4 01 ADD 10A5 90 SWAP1 10A6 81 DUP2 10A7 52 MSTORE 10A8 60 PUSH1 0x20 10AA 01 ADD 10AB 60 PUSH1 0x00 10AD 20 SHA3 10AE 54 SLOAD 10AF 90 SWAP1 10B0 50 POP 10B1 92 SWAP3 10B2 91 SWAP2 10B3 50 POP 10B4 50 POP 10B5 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @1064 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @106A memory[0x20:0x40] = 0x05 // @10A1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @10A7 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @10B1 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_10B6: // Incoming call from 0x0CD8, returns to 0x0CD9 // Incoming call from 0x0664, returns to 0x0665 // Incoming call from 0x0A32, returns to 0x0A33 // Inputs[2] // { // @10B9 stack[-1] // @10BA stack[-2] // } 10B6 5B JUMPDEST 10B7 60 PUSH1 0x00 10B9 81 DUP2 10BA 83 DUP4 10BB 01 ADD 10BC 90 SWAP1 10BD 50 POP 10BE 82 DUP3 10BF 81 DUP2 10C0 10 LT 10C1 15 ISZERO 10C2 15 ISZERO 10C3 15 ISZERO 10C4 61 PUSH2 0x10cc 10C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @10BC stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x10cc, if !!!(stack[-2] + stack[-1] < stack[-2]) label_10C8: // Incoming jump from 0x10C7, if not !!!(stack[-2] + stack[-1] < stack[-2]) // Inputs[1] { @10CB memory[0x00:0x00] } 10C8 60 PUSH1 0x00 10CA 80 DUP1 10CB FD *REVERT // Stack delta = +0 // Outputs[1] { @10CB revert(memory[0x00:0x00]); } // Block terminates label_10CC: // Incoming jump from 0x10C7, if !!!(stack[-2] + stack[-1] < stack[-2]) // Inputs[3] // { // @10CD stack[-4] // @10CD stack[-1] // @10CE stack[-3] // } 10CC 5B JUMPDEST 10CD 92 SWAP3 10CE 91 SWAP2 10CF 50 POP 10D0 50 POP 10D1 56 *JUMP // Stack delta = -3 // Outputs[1] { @10CD stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] 10D2 00 *STOP 10D3 A1 LOG1 10D4 65 PUSH6 0x627a7a723058 10DB 20 SHA3 10DC B2 SWAP 10DD B6 B6 10DE CA CA 10DF 1A BYTE 10E0 BA BA 10E1 19 NOT 10E2 8C DUP13 10E3 AD AD 10E4 11 GT 10E5 87 DUP8 10E6 E7 E7 10E7 28 28 10E8 11 GT 10E9 1A BYTE 10EA 59 MSIZE 10EB 78 PUSH25 0xc05015e469476b96bd6a42b32a83c1090029