Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x004c 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x004c, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x0900f010 0026 14 EQ 0027 61 PUSH2 0x0051 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0051, if 0x0900f010 == msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x0900f010 == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0x445df0ac 0031 14 EQ 0032 61 PUSH2 0x0095 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0095, if 0x445df0ac == stack[-1] label_0036: // Incoming jump from 0x0035, if not 0x445df0ac == stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0x8da5cb5b 003C 14 EQ 003D 61 PUSH2 0x00b3 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b3, if 0x8da5cb5b == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xfdacd576 0047 14 EQ 0048 61 PUSH2 0x00fd 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00fd, if 0xfdacd576 == stack[-1] label_004C: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x004B, if not 0xfdacd576 == stack[-1] // Inputs[1] { @0050 memory[0x00:0x00] } 004C 5B JUMPDEST 004D 60 PUSH1 0x00 004F 80 DUP1 0050 FD *REVERT // Stack delta = +0 // Outputs[1] { @0050 revert(memory[0x00:0x00]); } // Block terminates label_0051: // Incoming jump from 0x002A, if 0x0900f010 == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0058 msg.data.length } 0051 5B JUMPDEST 0052 61 PUSH2 0x0093 0055 60 PUSH1 0x04 0057 80 DUP1 0058 36 CALLDATASIZE 0059 03 SUB 005A 60 PUSH1 0x20 005C 81 DUP2 005D 10 LT 005E 15 ISZERO 005F 61 PUSH2 0x0067 0062 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0052 stack[0] = 0x0093 // @0055 stack[1] = 0x04 // @0059 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0067, returns to 0x0093, if !(msg.data.length - 0x04 < 0x20) label_0063: // Incoming jump from 0x0062, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0066 memory[0x00:0x00] } 0063 60 PUSH1 0x00 0065 80 DUP1 0066 FD *REVERT // Stack delta = +0 // Outputs[1] { @0066 revert(memory[0x00:0x00]); } // Block terminates label_0067: // Incoming call from 0x0062, returns to 0x0093, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0068 stack[-2] // @0069 stack[-1] // @006D msg.data[stack[-2]:stack[-2] + 0x20] // } 0067 5B JUMPDEST 0068 81 DUP2 0069 01 ADD 006A 90 SWAP1 006B 80 DUP1 006C 80 DUP1 006D 35 CALLDATALOAD 006E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0083 16 AND 0084 90 SWAP1 0085 60 PUSH1 0x20 0087 01 ADD 0088 90 SWAP1 0089 92 SWAP3 008A 91 SWAP2 008B 90 SWAP1 008C 50 POP 008D 50 POP 008E 50 POP 008F 61 PUSH2 0x012b 0092 56 *JUMP // Stack delta = -1 // Outputs[1] { @0089 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x012b label_0093: // Incoming return from call to 0x0067 at 0x0062 0093 5B JUMPDEST 0094 00 *STOP // Stack delta = +0 // Outputs[1] { @0094 stop(); } // Block terminates label_0095: // Incoming jump from 0x0035, if 0x445df0ac == stack[-1] 0095 5B JUMPDEST 0096 61 PUSH2 0x009d 0099 61 PUSH2 0x01f7 009C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0096 stack[0] = 0x009d } // Block ends with call to 0x01f7, returns to 0x009D label_009D: // Incoming return from call to 0x01F7 at 0x009C // Inputs[4] // { // @00A0 memory[0x40:0x60] // @00A2 stack[-1] // @00AD memory[0x40:0x60] // @00B2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 009D 5B JUMPDEST 009E 60 PUSH1 0x40 00A0 51 MLOAD 00A1 80 DUP1 00A2 82 DUP3 00A3 81 DUP2 00A4 52 MSTORE 00A5 60 PUSH1 0x20 00A7 01 ADD 00A8 91 SWAP2 00A9 50 POP 00AA 50 POP 00AB 60 PUSH1 0x40 00AD 51 MLOAD 00AE 80 DUP1 00AF 91 SWAP2 00B0 03 SUB 00B1 90 SWAP1 00B2 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @00A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @00B2 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_00B3: // Incoming jump from 0x0040, if 0x8da5cb5b == stack[-1] 00B3 5B JUMPDEST 00B4 61 PUSH2 0x00bb 00B7 61 PUSH2 0x01fd 00BA 56 *JUMP // Stack delta = +1 // Outputs[1] { @00B4 stack[0] = 0x00bb } // Block ends with call to 0x01fd, returns to 0x00BB label_00BB: // Incoming return from call to 0x01FD at 0x00BA // Inputs[4] // { // @00BE memory[0x40:0x60] // @00C0 stack[-1] // @00F7 memory[0x40:0x60] // @00FC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 00BB 5B JUMPDEST 00BC 60 PUSH1 0x40 00BE 51 MLOAD 00BF 80 DUP1 00C0 82 DUP3 00C1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00D6 16 AND 00D7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00EC 16 AND 00ED 81 DUP2 00EE 52 MSTORE 00EF 60 PUSH1 0x20 00F1 01 ADD 00F2 91 SWAP2 00F3 50 POP 00F4 50 POP 00F5 60 PUSH1 0x40 00F7 51 MLOAD 00F8 80 DUP1 00F9 91 SWAP2 00FA 03 SUB 00FB 90 SWAP1 00FC F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @00EE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @00FC return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_00FD: // Incoming jump from 0x004B, if 0xfdacd576 == stack[-1] // Inputs[1] { @0104 msg.data.length } 00FD 5B JUMPDEST 00FE 61 PUSH2 0x0129 0101 60 PUSH1 0x04 0103 80 DUP1 0104 36 CALLDATASIZE 0105 03 SUB 0106 60 PUSH1 0x20 0108 81 DUP2 0109 10 LT 010A 15 ISZERO 010B 61 PUSH2 0x0113 010E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @00FE stack[0] = 0x0129 // @0101 stack[1] = 0x04 // @0105 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0113, returns to 0x0129, if !(msg.data.length - 0x04 < 0x20) label_010F: // Incoming jump from 0x010E, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0112 memory[0x00:0x00] } 010F 60 PUSH1 0x00 0111 80 DUP1 0112 FD *REVERT // Stack delta = +0 // Outputs[1] { @0112 revert(memory[0x00:0x00]); } // Block terminates label_0113: // Incoming call from 0x010E, returns to 0x0129, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0114 stack[-2] // @0115 stack[-1] // @0119 msg.data[stack[-2]:stack[-2] + 0x20] // } 0113 5B JUMPDEST 0114 81 DUP2 0115 01 ADD 0116 90 SWAP1 0117 80 DUP1 0118 80 DUP1 0119 35 CALLDATALOAD 011A 90 SWAP1 011B 60 PUSH1 0x20 011D 01 ADD 011E 90 SWAP1 011F 92 SWAP3 0120 91 SWAP2 0121 90 SWAP1 0122 50 POP 0123 50 POP 0124 50 POP 0125 61 PUSH2 0x0222 0128 56 *JUMP // Stack delta = -1 // Outputs[1] { @011F stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0222 label_0129: // Incoming return from call to 0x0113 at 0x010E 0129 5B JUMPDEST 012A 00 *STOP // Stack delta = +0 // Outputs[1] { @012A stop(); } // Block terminates label_012B: // Incoming jump from 0x0092 // Inputs[2] // { // @0130 storage[0x00] // @0164 msg.sender // } 012B 5B JUMPDEST 012C 60 PUSH1 0x00 012E 80 DUP1 012F 90 SWAP1 0130 54 SLOAD 0131 90 SWAP1 0132 61 PUSH2 0x0100 0135 0A EXP 0136 90 SWAP1 0137 04 DIV 0138 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 014D 16 AND 014E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0163 16 AND 0164 33 CALLER 0165 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 017A 16 AND 017B 14 EQ 017C 15 ISZERO 017D 61 PUSH2 0x01f4 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f4, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) label_0181: // Incoming jump from 0x0180, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) // Inputs[5] // { // @0183 stack[-1] // @01A4 storage[0x01] // @01A7 memory[0x40:0x60] // @01C5 memory[0x40:0x60] // @01CE address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // } 0181 60 PUSH1 0x00 0183 81 DUP2 0184 90 SWAP1 0185 50 POP 0186 80 DUP1 0187 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 019C 16 AND 019D 63 PUSH4 0xfdacd576 01A2 60 PUSH1 0x01 01A4 54 SLOAD 01A5 60 PUSH1 0x40 01A7 51 MLOAD 01A8 82 DUP3 01A9 63 PUSH4 0xffffffff 01AE 16 AND 01AF 60 PUSH1 0xe0 01B1 1B SHL 01B2 81 DUP2 01B3 52 MSTORE 01B4 60 PUSH1 0x04 01B6 01 ADD 01B7 80 DUP1 01B8 82 DUP3 01B9 81 DUP2 01BA 52 MSTORE 01BB 60 PUSH1 0x20 01BD 01 ADD 01BE 91 SWAP2 01BF 50 POP 01C0 50 POP 01C1 60 PUSH1 0x00 01C3 60 PUSH1 0x40 01C5 51 MLOAD 01C6 80 DUP1 01C7 83 DUP4 01C8 03 SUB 01C9 81 DUP2 01CA 60 PUSH1 0x00 01CC 87 DUP8 01CD 80 DUP1 01CE 3B EXTCODESIZE 01CF 15 ISZERO 01D0 80 DUP1 01D1 15 ISZERO 01D2 61 PUSH2 0x01da 01D5 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @0184 stack[0] = stack[-1] // @019C stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @019D stack[2] = 0xfdacd576 // @01B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xfdacd576) << 0xe0 // @01BA memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = storage[0x01] // @01BE stack[3] = 0x20 + 0x04 + memory[0x40:0x60] // @01C1 stack[4] = 0x00 // @01C5 stack[5] = memory[0x40:0x60] // @01C8 stack[6] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @01C9 stack[7] = memory[0x40:0x60] // @01CA stack[8] = 0x00 // @01CC stack[9] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @01CF stack[10] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // } // Block ends with conditional jump to 0x01da, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length label_01D6: // Incoming jump from 0x01D5, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // Inputs[1] { @01D9 memory[0x00:0x00] } 01D6 60 PUSH1 0x00 01D8 80 DUP1 01D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D9 revert(memory[0x00:0x00]); } // Block terminates label_01DA: // Incoming jump from 0x01D5, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // Inputs[9] // { // @01DC msg.gas // @01DD stack[-2] // @01DD stack[-6] // @01DD stack[-7] // @01DD address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @01DD stack[-3] // @01DD stack[-5] // @01DD memory[stack[-4]:stack[-4] + stack[-5]] // @01DD stack[-4] // } 01DA 5B JUMPDEST 01DB 50 POP 01DC 5A GAS 01DD F1 CALL 01DE 15 ISZERO 01DF 80 DUP1 01E0 15 ISZERO 01E1 61 PUSH2 0x01ee 01E4 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @01DD memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @01DE 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 0x01ee, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_01E5: // Incoming jump from 0x01E4, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @01E5 returndata.length // @01E9 returndata[0x00:0x00 + returndata.length] // @01EA returndata.length // @01ED memory[0x00:0x00 + returndata.length] // } 01E5 3D RETURNDATASIZE 01E6 60 PUSH1 0x00 01E8 80 DUP1 01E9 3E RETURNDATACOPY 01EA 3D RETURNDATASIZE 01EB 60 PUSH1 0x00 01ED FD *REVERT // Stack delta = +0 // Outputs[2] // { // @01E9 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @01ED revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_01EE: // Incoming jump from 0x01E4, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 01EE 5B JUMPDEST 01EF 50 POP 01F0 50 POP 01F1 50 POP 01F2 50 POP 01F3 50 POP // Stack delta = -5 // Block continues label_01F4: // Incoming jump from 0x01F3 // Incoming jump from 0x0180, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) // Inputs[1] { @01F6 stack[-2] } 01F4 5B JUMPDEST 01F5 50 POP 01F6 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_01F7: // Incoming call from 0x009C, returns to 0x009D // Inputs[2] // { // @01FA storage[0x01] // @01FB stack[-1] // } 01F7 5B JUMPDEST 01F8 60 PUSH1 0x01 01FA 54 SLOAD 01FB 81 DUP2 01FC 56 *JUMP // Stack delta = +1 // Outputs[1] { @01FA stack[0] = storage[0x01] } // Block ends with unconditional jump to stack[-1] label_01FD: // Incoming call from 0x00BA, returns to 0x00BB // Inputs[2] // { // @0202 storage[0x00] // @0220 stack[-1] // } 01FD 5B JUMPDEST 01FE 60 PUSH1 0x00 0200 80 DUP1 0201 90 SWAP1 0202 54 SLOAD 0203 90 SWAP1 0204 61 PUSH2 0x0100 0207 0A EXP 0208 90 SWAP1 0209 04 DIV 020A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 021F 16 AND 0220 81 DUP2 0221 56 *JUMP // Stack delta = +1 // Outputs[1] { @021F stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0222: // Incoming jump from 0x0128 // Inputs[2] // { // @0227 storage[0x00] // @025B msg.sender // } 0222 5B JUMPDEST 0223 60 PUSH1 0x00 0225 80 DUP1 0226 90 SWAP1 0227 54 SLOAD 0228 90 SWAP1 0229 61 PUSH2 0x0100 022C 0A EXP 022D 90 SWAP1 022E 04 DIV 022F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0244 16 AND 0245 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 025A 16 AND 025B 33 CALLER 025C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0271 16 AND 0272 14 EQ 0273 15 ISZERO 0274 61 PUSH2 0x027f 0277 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027f, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) label_0278: // Incoming jump from 0x0277, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) // Inputs[2] // { // @0278 stack[-1] // @0281 stack[-2] // } 0278 80 DUP1 0279 60 PUSH1 0x01 027B 81 DUP2 027C 90 SWAP1 027D 55 SSTORE 027E 50 POP 027F 5B JUMPDEST 0280 50 POP 0281 56 *JUMP // Stack delta = -2 // Outputs[1] { @027D storage[0x01] = stack[-1] } // Block ends with unconditional jump to stack[-2] 0282 FE *ASSERT 0283 A2 LOG2 0284 65 PUSH6 0x627a7a723158 028B 20 SHA3 028C 1E 1E 028D D3 D3 028E 04 DIV 028F E7 E7 0290 80 DUP1 0291 AF AF 0292 8D DUP14 0293 A8 A8 0294 36 CALLDATASIZE 0295 52 MSTORE 0296 7C PUSH29 0xc1a47eaac328e5d040d802eda26b309b67d939dd5764736f6c63430005 02B4 11 GT 02B5 00 *STOP 02B6 32 ORIGIN