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 0x0062 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0062, 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 0x50f760e9 003C 14 EQ 003D 61 PUSH2 0x0067 0040 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0035 stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x0067, if 0x50f760e9 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0041: // Incoming jump from 0x0040, if not 0x50f760e9 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0x715018a6 0047 14 EQ 0048 61 PUSH2 0x00ca 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ca, if 0x715018a6 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0x715018a6 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0x8da5cb5b 0052 14 EQ 0053 61 PUSH2 0x00e1 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00e1, if 0x8da5cb5b == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf2fde38b 005D 14 EQ 005E 61 PUSH2 0x0138 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0138, if 0xf2fde38b == stack[-1] label_0062: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x0061, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0066 memory[0x00:0x00] } 0062 5B JUMPDEST 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 jump from 0x0040, if 0x50f760e9 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0068 msg.value } 0067 5B JUMPDEST 0068 34 CALLVALUE 0069 80 DUP1 006A 15 ISZERO 006B 61 PUSH2 0x0073 006E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0068 stack[0] = msg.value } // Block ends with conditional jump to 0x0073, if !msg.value label_006F: // Incoming jump from 0x006E, if not !msg.value // Inputs[1] { @0072 memory[0x00:0x00] } 006F 60 PUSH1 0x00 0071 80 DUP1 0072 FD *REVERT // Stack delta = +0 // Outputs[1] { @0072 revert(memory[0x00:0x00]); } // Block terminates label_0073: // Incoming jump from 0x006E, if !msg.value // Inputs[3] // { // @007B msg.data.length // @0082 msg.data[0x04:0x24] // @00A2 msg.data[0x24:0x44] // } 0073 5B JUMPDEST 0074 50 POP 0075 61 PUSH2 0x00c8 0078 60 PUSH1 0x04 007A 80 DUP1 007B 36 CALLDATASIZE 007C 03 SUB 007D 81 DUP2 007E 01 ADD 007F 90 SWAP1 0080 80 DUP1 0081 80 DUP1 0082 35 CALLDATALOAD 0083 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0098 16 AND 0099 90 SWAP1 009A 60 PUSH1 0x20 009C 01 ADD 009D 90 SWAP1 009E 92 SWAP3 009F 91 SWAP2 00A0 90 SWAP1 00A1 80 DUP1 00A2 35 CALLDATALOAD 00A3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00B8 16 AND 00B9 90 SWAP1 00BA 60 PUSH1 0x20 00BC 01 ADD 00BD 90 SWAP1 00BE 92 SWAP3 00BF 91 SWAP2 00C0 90 SWAP1 00C1 50 POP 00C2 50 POP 00C3 50 POP 00C4 61 PUSH2 0x017b 00C7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0075 stack[-1] = 0x00c8 // @009E stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @00BE stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x24:0x44] // } // Block ends with call to 0x017b, returns to 0x00C8 label_00C8: // Incoming return from call to 0x017B at 0x00C7 00C8 5B JUMPDEST 00C9 00 *STOP // Stack delta = +0 // Outputs[1] { @00C9 stop(); } // Block terminates label_00CA: // Incoming jump from 0x004B, if 0x715018a6 == stack[-1] // Inputs[1] { @00CB msg.value } 00CA 5B JUMPDEST 00CB 34 CALLVALUE 00CC 80 DUP1 00CD 15 ISZERO 00CE 61 PUSH2 0x00d6 00D1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00CB stack[0] = msg.value } // Block ends with conditional jump to 0x00d6, if !msg.value label_00D2: // Incoming jump from 0x00D1, if not !msg.value // Inputs[1] { @00D5 memory[0x00:0x00] } 00D2 60 PUSH1 0x00 00D4 80 DUP1 00D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D5 revert(memory[0x00:0x00]); } // Block terminates label_00D6: // Incoming jump from 0x00D1, if !msg.value 00D6 5B JUMPDEST 00D7 50 POP 00D8 61 PUSH2 0x00df 00DB 61 PUSH2 0x039e 00DE 56 *JUMP // Stack delta = +0 // Outputs[1] { @00D8 stack[-1] = 0x00df } // Block ends with call to 0x039e, returns to 0x00DF label_00DF: // Incoming return from call to 0x039E at 0x00DE 00DF 5B JUMPDEST 00E0 00 *STOP // Stack delta = +0 // Outputs[1] { @00E0 stop(); } // Block terminates label_00E1: // Incoming jump from 0x0056, if 0x8da5cb5b == stack[-1] // Inputs[1] { @00E2 msg.value } 00E1 5B JUMPDEST 00E2 34 CALLVALUE 00E3 80 DUP1 00E4 15 ISZERO 00E5 61 PUSH2 0x00ed 00E8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00E2 stack[0] = msg.value } // Block ends with conditional jump to 0x00ed, if !msg.value label_00E9: // Incoming jump from 0x00E8, if not !msg.value // Inputs[1] { @00EC memory[0x00:0x00] } 00E9 60 PUSH1 0x00 00EB 80 DUP1 00EC FD *REVERT // Stack delta = +0 // Outputs[1] { @00EC revert(memory[0x00:0x00]); } // Block terminates label_00ED: // Incoming jump from 0x00E8, if !msg.value 00ED 5B JUMPDEST 00EE 50 POP 00EF 61 PUSH2 0x00f6 00F2 61 PUSH2 0x04a0 00F5 56 *JUMP // Stack delta = +0 // Outputs[1] { @00EF stack[-1] = 0x00f6 } // Block ends with call to 0x04a0, returns to 0x00F6 label_00F6: // Incoming return from call to 0x04A0 at 0x00F5 // Inputs[4] // { // @00F9 memory[0x40:0x60] // @00FB stack[-1] // @0132 memory[0x40:0x60] // @0137 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 00F6 5B JUMPDEST 00F7 60 PUSH1 0x40 00F9 51 MLOAD 00FA 80 DUP1 00FB 82 DUP3 00FC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0111 16 AND 0112 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0127 16 AND 0128 81 DUP2 0129 52 MSTORE 012A 60 PUSH1 0x20 012C 01 ADD 012D 91 SWAP2 012E 50 POP 012F 50 POP 0130 60 PUSH1 0x40 0132 51 MLOAD 0133 80 DUP1 0134 91 SWAP2 0135 03 SUB 0136 90 SWAP1 0137 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0129 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0137 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0138: // Incoming jump from 0x0061, if 0xf2fde38b == stack[-1] // Inputs[1] { @0139 msg.value } 0138 5B JUMPDEST 0139 34 CALLVALUE 013A 80 DUP1 013B 15 ISZERO 013C 61 PUSH2 0x0144 013F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0139 stack[0] = msg.value } // Block ends with conditional jump to 0x0144, if !msg.value label_0140: // Incoming jump from 0x013F, if not !msg.value // Inputs[1] { @0143 memory[0x00:0x00] } 0140 60 PUSH1 0x00 0142 80 DUP1 0143 FD *REVERT // Stack delta = +0 // Outputs[1] { @0143 revert(memory[0x00:0x00]); } // Block terminates label_0144: // Incoming jump from 0x013F, if !msg.value // Inputs[2] // { // @014C msg.data.length // @0153 msg.data[0x04:0x24] // } 0144 5B JUMPDEST 0145 50 POP 0146 61 PUSH2 0x0179 0149 60 PUSH1 0x04 014B 80 DUP1 014C 36 CALLDATASIZE 014D 03 SUB 014E 81 DUP2 014F 01 ADD 0150 90 SWAP1 0151 80 DUP1 0152 80 DUP1 0153 35 CALLDATALOAD 0154 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0169 16 AND 016A 90 SWAP1 016B 60 PUSH1 0x20 016D 01 ADD 016E 90 SWAP1 016F 92 SWAP3 0170 91 SWAP2 0171 90 SWAP1 0172 50 POP 0173 50 POP 0174 50 POP 0175 61 PUSH2 0x04c5 0178 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0146 stack[-1] = 0x0179 // @016F stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x04c5, returns to 0x0179 label_0179: // Incoming return from call to 0x04C5 at 0x0178 0179 5B JUMPDEST 017A 00 *STOP // Stack delta = +0 // Outputs[1] { @017A stop(); } // Block terminates label_017B: // Incoming call from 0x00C7, returns to 0x00C8 // Inputs[2] // { // @0182 storage[0x00] // @01B6 msg.sender // } 017B 5B JUMPDEST 017C 60 PUSH1 0x00 017E 80 DUP1 017F 60 PUSH1 0x00 0181 90 SWAP1 0182 54 SLOAD 0183 90 SWAP1 0184 61 PUSH2 0x0100 0187 0A EXP 0188 90 SWAP1 0189 04 DIV 018A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 019F 16 AND 01A0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01B5 16 AND 01B6 33 CALLER 01B7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01CC 16 AND 01CD 14 EQ 01CE 15 ISZERO 01CF 15 ISZERO 01D0 61 PUSH2 0x01d8 01D3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @017C stack[0] = 0x00 } // Block ends with conditional jump to 0x01d8, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) label_01D4: // Incoming jump from 0x01D3, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) // Inputs[1] { @01D7 memory[0x00:0x00] } 01D4 60 PUSH1 0x00 01D6 80 DUP1 01D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D7 revert(memory[0x00:0x00]); } // Block terminates label_01D8: // Incoming jump from 0x01D3, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) // Inputs[5] // { // @01D9 stack[-2] // @01F5 address(this) // @01F8 memory[0x40:0x60] // @025E memory[0x40:0x60] // @0267 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-2]).code.length // } 01D8 5B JUMPDEST 01D9 81 DUP2 01DA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01EF 16 AND 01F0 63 PUSH4 0x70a08231 01F5 30 ADDRESS 01F6 60 PUSH1 0x40 01F8 51 MLOAD 01F9 82 DUP3 01FA 63 PUSH4 0xffffffff 01FF 16 AND 0200 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 021E 02 MUL 021F 81 DUP2 0220 52 MSTORE 0221 60 PUSH1 0x04 0223 01 ADD 0224 80 DUP1 0225 82 DUP3 0226 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 023B 16 AND 023C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0251 16 AND 0252 81 DUP2 0253 52 MSTORE 0254 60 PUSH1 0x20 0256 01 ADD 0257 91 SWAP2 0258 50 POP 0259 50 POP 025A 60 PUSH1 0x20 025C 60 PUSH1 0x40 025E 51 MLOAD 025F 80 DUP1 0260 83 DUP4 0261 03 SUB 0262 81 DUP2 0263 60 PUSH1 0x00 0265 87 DUP8 0266 80 DUP1 0267 3B EXTCODESIZE 0268 15 ISZERO 0269 80 DUP1 026A 15 ISZERO 026B 61 PUSH2 0x0273 026E 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @01EF stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @01F0 stack[1] = 0x70a08231 // @0220 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0x70a08231) // @0253 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @0257 stack[2] = 0x20 + 0x04 + memory[0x40:0x60] // @025A stack[3] = 0x20 // @025E stack[4] = memory[0x40:0x60] // @0261 stack[5] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0262 stack[6] = memory[0x40:0x60] // @0263 stack[7] = 0x00 // @0265 stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0268 stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-2]).code.length // } // Block ends with conditional jump to 0x0273, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-2]).code.length label_026F: // Incoming jump from 0x026E, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-2]).code.length // Inputs[1] { @0272 memory[0x00:0x00] } 026F 60 PUSH1 0x00 0271 80 DUP1 0272 FD *REVERT // Stack delta = +0 // Outputs[1] { @0272 revert(memory[0x00:0x00]); } // Block terminates label_0273: // Incoming jump from 0x026E, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-2]).code.length // Inputs[9] // { // @0275 msg.gas // @0276 stack[-7] // @0276 stack[-6] // @0276 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0276 stack[-4] // @0276 memory[stack[-4]:stack[-4] + stack[-5]] // @0276 stack[-3] // @0276 stack[-2] // @0276 stack[-5] // } 0273 5B JUMPDEST 0274 50 POP 0275 5A GAS 0276 F1 CALL 0277 15 ISZERO 0278 80 DUP1 0279 15 ISZERO 027A 61 PUSH2 0x0287 027D 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0276 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0277 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 0x0287, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_027E: // Incoming jump from 0x027D, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @027E returndata.length // @0282 returndata[0x00:0x00 + returndata.length] // @0283 returndata.length // @0286 memory[0x00:0x00 + returndata.length] // } 027E 3D RETURNDATASIZE 027F 60 PUSH1 0x00 0281 80 DUP1 0282 3E RETURNDATACOPY 0283 3D RETURNDATASIZE 0284 60 PUSH1 0x00 0286 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0282 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0286 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0287: // Incoming jump from 0x027D, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @028E memory[0x40:0x60] // @028F returndata.length // } 0287 5B JUMPDEST 0288 50 POP 0289 50 POP 028A 50 POP 028B 50 POP 028C 60 PUSH1 0x40 028E 51 MLOAD 028F 3D RETURNDATASIZE 0290 60 PUSH1 0x20 0292 81 DUP2 0293 10 LT 0294 15 ISZERO 0295 61 PUSH2 0x029d 0298 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @028E stack[-4] = memory[0x40:0x60] // @028F stack[-3] = returndata.length // } // Block ends with conditional jump to 0x029d, if !(returndata.length < 0x20) label_0299: // Incoming jump from 0x0298, if not !(returndata.length < 0x20) // Inputs[1] { @029C memory[0x00:0x00] } 0299 60 PUSH1 0x00 029B 80 DUP1 029C FD *REVERT // Stack delta = +0 // Outputs[1] { @029C revert(memory[0x00:0x00]); } // Block terminates label_029D: // Incoming jump from 0x0298, if !(returndata.length < 0x20) // Inputs[9] // { // @029E stack[-2] // @029F stack[-1] // @02A3 memory[stack[-2]:stack[-2] + 0x20] // @02AF stack[-3] // @02B1 stack[-4] // @02CD stack[-5] // @02D1 memory[0x40:0x60] // @033E memory[0x40:0x60] // @0347 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).code.length // } 029D 5B JUMPDEST 029E 81 DUP2 029F 01 ADD 02A0 90 SWAP1 02A1 80 DUP1 02A2 80 DUP1 02A3 51 MLOAD 02A4 90 SWAP1 02A5 60 PUSH1 0x20 02A7 01 ADD 02A8 90 SWAP1 02A9 92 SWAP3 02AA 91 SWAP2 02AB 90 SWAP1 02AC 50 POP 02AD 50 POP 02AE 50 POP 02AF 90 SWAP1 02B0 50 POP 02B1 81 DUP2 02B2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02C7 16 AND 02C8 63 PUSH4 0xa9059cbb 02CD 84 DUP5 02CE 83 DUP4 02CF 60 PUSH1 0x40 02D1 51 MLOAD 02D2 83 DUP4 02D3 63 PUSH4 0xffffffff 02D8 16 AND 02D9 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 02F7 02 MUL 02F8 81 DUP2 02F9 52 MSTORE 02FA 60 PUSH1 0x04 02FC 01 ADD 02FD 80 DUP1 02FE 83 DUP4 02FF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0314 16 AND 0315 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 032A 16 AND 032B 81 DUP2 032C 52 MSTORE 032D 60 PUSH1 0x20 032F 01 ADD 0330 82 DUP3 0331 81 DUP2 0332 52 MSTORE 0333 60 PUSH1 0x20 0335 01 ADD 0336 92 SWAP3 0337 50 POP 0338 50 POP 0339 50 POP 033A 60 PUSH1 0x20 033C 60 PUSH1 0x40 033E 51 MLOAD 033F 80 DUP1 0340 83 DUP4 0341 03 SUB 0342 81 DUP2 0343 60 PUSH1 0x00 0345 87 DUP8 0346 80 DUP1 0347 3B EXTCODESIZE 0348 15 ISZERO 0349 80 DUP1 034A 15 ISZERO 034B 61 PUSH2 0x0353 034E 57 *JUMPI // Stack delta = +8 // Outputs[14] // { // @02AF stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @02C7 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @02C8 stack[-1] = 0xa9059cbb // @02F9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0xa9059cbb) // @032C memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0332 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @0336 stack[0] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @033A stack[1] = 0x20 // @033E stack[2] = memory[0x40:0x60] // @0341 stack[3] = (0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0342 stack[4] = memory[0x40:0x60] // @0343 stack[5] = 0x00 // @0345 stack[6] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0348 stack[7] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).code.length // } // Block ends with conditional jump to 0x0353, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).code.length label_034F: // Incoming jump from 0x034E, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).code.length // Inputs[1] { @0352 memory[0x00:0x00] } 034F 60 PUSH1 0x00 0351 80 DUP1 0352 FD *REVERT // Stack delta = +0 // Outputs[1] { @0352 revert(memory[0x00:0x00]); } // Block terminates label_0353: // Incoming jump from 0x034E, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).code.length // Inputs[9] // { // @0355 msg.gas // @0356 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0356 stack[-4] // @0356 stack[-5] // @0356 stack[-7] // @0356 stack[-3] // @0356 memory[stack[-4]:stack[-4] + stack[-5]] // @0356 stack[-2] // @0356 stack[-6] // } 0353 5B JUMPDEST 0354 50 POP 0355 5A GAS 0356 F1 CALL 0357 15 ISZERO 0358 80 DUP1 0359 15 ISZERO 035A 61 PUSH2 0x0367 035D 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0356 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0357 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 0x0367, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_035E: // Incoming jump from 0x035D, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @035E returndata.length // @0362 returndata[0x00:0x00 + returndata.length] // @0363 returndata.length // @0366 memory[0x00:0x00 + returndata.length] // } 035E 3D RETURNDATASIZE 035F 60 PUSH1 0x00 0361 80 DUP1 0362 3E RETURNDATACOPY 0363 3D RETURNDATASIZE 0364 60 PUSH1 0x00 0366 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0362 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0366 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0367: // Incoming jump from 0x035D, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @036E memory[0x40:0x60] // @036F returndata.length // } 0367 5B JUMPDEST 0368 50 POP 0369 50 POP 036A 50 POP 036B 50 POP 036C 60 PUSH1 0x40 036E 51 MLOAD 036F 3D RETURNDATASIZE 0370 60 PUSH1 0x20 0372 81 DUP2 0373 10 LT 0374 15 ISZERO 0375 61 PUSH2 0x037d 0378 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @036E stack[-4] = memory[0x40:0x60] // @036F stack[-3] = returndata.length // } // Block ends with conditional jump to 0x037d, if !(returndata.length < 0x20) label_0379: // Incoming jump from 0x0378, if not !(returndata.length < 0x20) // Inputs[1] { @037C memory[0x00:0x00] } 0379 60 PUSH1 0x00 037B 80 DUP1 037C FD *REVERT // Stack delta = +0 // Outputs[1] { @037C revert(memory[0x00:0x00]); } // Block terminates label_037D: // Incoming jump from 0x0378, if !(returndata.length < 0x20) // Inputs[3] // { // @037E stack[-2] // @037F stack[-1] // @0383 memory[stack[-2]:stack[-2] + 0x20] // } 037D 5B JUMPDEST 037E 81 DUP2 037F 01 ADD 0380 90 SWAP1 0381 80 DUP1 0382 80 DUP1 0383 51 MLOAD 0384 90 SWAP1 0385 60 PUSH1 0x20 0387 01 ADD 0388 90 SWAP1 0389 92 SWAP3 038A 91 SWAP2 038B 90 SWAP1 038C 50 POP 038D 50 POP 038E 50 POP 038F 15 ISZERO 0390 15 ISZERO 0391 61 PUSH2 0x0399 0394 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0399, if !!memory[stack[-2]:stack[-2] + 0x20] label_0395: // Incoming jump from 0x0394, if not !!memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @0398 memory[0x00:0x00] } 0395 60 PUSH1 0x00 0397 80 DUP1 0398 FD *REVERT // Stack delta = +0 // Outputs[1] { @0398 revert(memory[0x00:0x00]); } // Block terminates label_0399: // Incoming jump from 0x0394, if !!memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @039D stack[-4] } 0399 5B JUMPDEST 039A 50 POP 039B 50 POP 039C 50 POP 039D 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_039E: // Incoming call from 0x00DE, returns to 0x00DF // Inputs[2] // { // @03A3 storage[0x00] // @03D7 msg.sender // } 039E 5B JUMPDEST 039F 60 PUSH1 0x00 03A1 80 DUP1 03A2 90 SWAP1 03A3 54 SLOAD 03A4 90 SWAP1 03A5 61 PUSH2 0x0100 03A8 0A EXP 03A9 90 SWAP1 03AA 04 DIV 03AB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03C0 16 AND 03C1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03D6 16 AND 03D7 33 CALLER 03D8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03ED 16 AND 03EE 14 EQ 03EF 15 ISZERO 03F0 15 ISZERO 03F1 61 PUSH2 0x03f9 03F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f9, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) label_03F5: // Incoming jump from 0x03F4, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) // Inputs[1] { @03F8 memory[0x00:0x00] } 03F5 60 PUSH1 0x00 03F7 80 DUP1 03F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F8 revert(memory[0x00:0x00]); } // Block terminates label_03F9: // Incoming jump from 0x03F4, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) // Inputs[6] // { // @03FE storage[0x00] // @0455 memory[0x40:0x60] // @0458 memory[0x40:0x60] // @045D memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0468 storage[0x00] // @049F stack[-1] // } 03F9 5B JUMPDEST 03FA 60 PUSH1 0x00 03FC 80 DUP1 03FD 90 SWAP1 03FE 54 SLOAD 03FF 90 SWAP1 0400 61 PUSH2 0x0100 0403 0A EXP 0404 90 SWAP1 0405 04 DIV 0406 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 041B 16 AND 041C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0431 16 AND 0432 7F PUSH32 0xf8df31144d9c2f0f6b59d69b8b98abd5459d07f2742c4df920b25aae33c64820 0453 60 PUSH1 0x40 0455 51 MLOAD 0456 60 PUSH1 0x40 0458 51 MLOAD 0459 80 DUP1 045A 91 SWAP2 045B 03 SUB 045C 90 SWAP1 045D A2 LOG2 045E 60 PUSH1 0x00 0460 80 DUP1 0461 60 PUSH1 0x00 0463 61 PUSH2 0x0100 0466 0A EXP 0467 81 DUP2 0468 54 SLOAD 0469 81 DUP2 046A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 047F 02 MUL 0480 19 NOT 0481 16 AND 0482 90 SWAP1 0483 83 DUP4 0484 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0499 16 AND 049A 02 MUL 049B 17 OR 049C 90 SWAP1 049D 55 SSTORE 049E 50 POP 049F 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @045D log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xf8df31144d9c2f0f6b59d69b8b98abd5459d07f2742c4df920b25aae33c64820, storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff]); // @049D storage[0x00] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x00]) // } // Block ends with unconditional jump to stack[-1] label_04A0: // Incoming call from 0x00F5, returns to 0x00F6 // Inputs[2] // { // @04A5 storage[0x00] // @04C3 stack[-1] // } 04A0 5B JUMPDEST 04A1 60 PUSH1 0x00 04A3 80 DUP1 04A4 90 SWAP1 04A5 54 SLOAD 04A6 90 SWAP1 04A7 61 PUSH2 0x0100 04AA 0A EXP 04AB 90 SWAP1 04AC 04 DIV 04AD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04C2 16 AND 04C3 81 DUP2 04C4 56 *JUMP // Stack delta = +1 // Outputs[1] { @04C2 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_04C5: // Incoming call from 0x0178, returns to 0x0179 // Inputs[2] // { // @04CA storage[0x00] // @04FE msg.sender // } 04C5 5B JUMPDEST 04C6 60 PUSH1 0x00 04C8 80 DUP1 04C9 90 SWAP1 04CA 54 SLOAD 04CB 90 SWAP1 04CC 61 PUSH2 0x0100 04CF 0A EXP 04D0 90 SWAP1 04D1 04 DIV 04D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04E7 16 AND 04E8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04FD 16 AND 04FE 33 CALLER 04FF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0514 16 AND 0515 14 EQ 0516 15 ISZERO 0517 15 ISZERO 0518 61 PUSH2 0x0520 051B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0520, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) label_051C: // Incoming jump from 0x051B, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) // Inputs[1] { @051F memory[0x00:0x00] } 051C 60 PUSH1 0x00 051E 80 DUP1 051F FD *REVERT // Stack delta = +0 // Outputs[1] { @051F revert(memory[0x00:0x00]); } // Block terminates label_0520: // Incoming jump from 0x051B, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00) // Inputs[1] { @0524 stack[-1] } 0520 5B JUMPDEST 0521 61 PUSH2 0x0529 0524 81 DUP2 0525 61 PUSH2 0x052c 0528 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0521 stack[0] = 0x0529 // @0524 stack[1] = stack[-1] // } // Block ends with call to 0x052c, returns to 0x0529 label_0529: // Incoming return from call to 0x052C at 0x0528 // Inputs[1] { @052B stack[-2] } 0529 5B JUMPDEST 052A 50 POP 052B 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_052C: // Incoming call from 0x0528, returns to 0x0529 // Inputs[1] { @0545 stack[-1] } 052C 5B JUMPDEST 052D 60 PUSH1 0x00 052F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0544 16 AND 0545 81 DUP2 0546 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 055B 16 AND 055C 14 EQ 055D 15 ISZERO 055E 15 ISZERO 055F 15 ISZERO 0560 61 PUSH2 0x0568 0563 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0568, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0564: // Incoming jump from 0x0563, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0567 memory[0x00:0x00] } 0564 60 PUSH1 0x00 0566 80 DUP1 0567 FD *REVERT // Stack delta = +0 // Outputs[1] { @0567 revert(memory[0x00:0x00]); } // Block terminates label_0568: // Incoming jump from 0x0563, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[7] // { // @0569 stack[-1] // @0584 storage[0x00] // @05DB memory[0x40:0x60] // @05DE memory[0x40:0x60] // @05E3 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @05ED storage[0x00] // @0625 stack[-2] // } 0568 5B JUMPDEST 0569 80 DUP1 056A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 057F 16 AND 0580 60 PUSH1 0x00 0582 80 DUP1 0583 90 SWAP1 0584 54 SLOAD 0585 90 SWAP1 0586 61 PUSH2 0x0100 0589 0A EXP 058A 90 SWAP1 058B 04 DIV 058C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05A1 16 AND 05A2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05B7 16 AND 05B8 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 05D9 60 PUSH1 0x40 05DB 51 MLOAD 05DC 60 PUSH1 0x40 05DE 51 MLOAD 05DF 80 DUP1 05E0 91 SWAP2 05E1 03 SUB 05E2 90 SWAP1 05E3 A3 LOG3 05E4 80 DUP1 05E5 60 PUSH1 0x00 05E7 80 DUP1 05E8 61 PUSH2 0x0100 05EB 0A EXP 05EC 81 DUP2 05ED 54 SLOAD 05EE 81 DUP2 05EF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0604 02 MUL 0605 19 NOT 0606 16 AND 0607 90 SWAP1 0608 83 DUP4 0609 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 061E 16 AND 061F 02 MUL 0620 17 OR 0621 90 SWAP1 0622 55 SSTORE 0623 50 POP 0624 50 POP 0625 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @05E3 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // @0622 storage[0x00] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x00]) // } // Block ends with unconditional jump to stack[-2] 0626 00 *STOP 0627 A1 LOG1 0628 65 PUSH6 0x627a7a723058 062F 20 SHA3 0630 95 SWAP6 0631 27 27 0632 93 SWAP4 0633 D2 D2 0634 D2 D2 0635 5D 5D 0636 CF CF 0637 E3 E3 0638 2B 2B 0639 45 GASLIMIT 063A D5 D5 063B A6 A6 063C 6C PUSH13 0x10e15377cfa0dbb9ce2e4f574c 064A A5 A5 064B 7A PUSH27 0x08d9c0e60029