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 0x007b 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x007b, 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 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x9623609d 0019 11 GT 001A 61 PUSH2 0x004e 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x004e, if 0x9623609d > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x9623609d > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0x9623609d 0024 14 EQ 0025 61 PUSH2 0x0111 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0111, if 0x9623609d == stack[-1] label_0029: // Incoming jump from 0x0028, if not 0x9623609d == stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0x99a88ec4 002F 14 EQ 0030 61 PUSH2 0x0124 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0124, if 0x99a88ec4 == stack[-1] label_0034: // Incoming jump from 0x0033, if not 0x99a88ec4 == stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xf2fde38b 003A 14 EQ 003B 61 PUSH2 0x0144 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0144, if 0xf2fde38b == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xf2fde38b == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xf3b7dead 0045 14 EQ 0046 61 PUSH2 0x0164 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0164, if 0xf3b7dead == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xf3b7dead == stack[-1] 004A 61 PUSH2 0x007b 004D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x007b label_004E: // Incoming jump from 0x001D, if 0x9623609d > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @004F stack[-1] } 004E 5B JUMPDEST 004F 80 DUP1 0050 63 PUSH4 0x204e1c7a 0055 14 EQ 0056 61 PUSH2 0x0080 0059 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0080, if 0x204e1c7a == stack[-1] label_005A: // Incoming jump from 0x0059, if not 0x204e1c7a == stack[-1] // Inputs[1] { @005A stack[-1] } 005A 80 DUP1 005B 63 PUSH4 0x715018a6 0060 14 EQ 0061 61 PUSH2 0x00bc 0064 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00bc, if 0x715018a6 == stack[-1] label_0065: // Incoming jump from 0x0064, if not 0x715018a6 == stack[-1] // Inputs[1] { @0065 stack[-1] } 0065 80 DUP1 0066 63 PUSH4 0x7eff275e 006B 14 EQ 006C 61 PUSH2 0x00d3 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d3, if 0x7eff275e == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0x7eff275e == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0x8da5cb5b 0076 14 EQ 0077 61 PUSH2 0x00f3 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00f3, if 0x8da5cb5b == stack[-1] label_007B: // Incoming jump from 0x004D // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x007A, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @007F memory[0x00:0x00] } 007B 5B JUMPDEST 007C 60 PUSH1 0x00 007E 80 DUP1 007F FD *REVERT // Stack delta = +0 // Outputs[1] { @007F revert(memory[0x00:0x00]); } // Block terminates label_0080: // Incoming jump from 0x0059, if 0x204e1c7a == stack[-1] // Inputs[1] { @0081 msg.value } 0080 5B JUMPDEST 0081 34 CALLVALUE 0082 80 DUP1 0083 15 ISZERO 0084 61 PUSH2 0x008c 0087 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0081 stack[0] = msg.value } // Block ends with conditional jump to 0x008c, if !msg.value label_0088: // Incoming jump from 0x0087, if not !msg.value // Inputs[1] { @008B memory[0x00:0x00] } 0088 60 PUSH1 0x00 008A 80 DUP1 008B FD *REVERT // Stack delta = +0 // Outputs[1] { @008B revert(memory[0x00:0x00]); } // Block terminates label_008C: // Incoming jump from 0x0087, if !msg.value // Inputs[1] { @0094 msg.data.length } 008C 5B JUMPDEST 008D 50 POP 008E 61 PUSH2 0x00a0 0091 61 PUSH2 0x009b 0094 36 CALLDATASIZE 0095 60 PUSH1 0x04 0097 61 PUSH2 0x0515 009A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @008E stack[-1] = 0x00a0 // @0091 stack[0] = 0x009b // @0094 stack[1] = msg.data.length // @0095 stack[2] = 0x04 // } // Block ends with call to 0x0515, returns to 0x009B label_009B: // Incoming return from call to 0x0515 at 0x009A 009B 5B JUMPDEST 009C 61 PUSH2 0x0184 009F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0184 label_00A0: // Incoming jump from 0x0110 // Inputs[4] // { // @00A3 memory[0x40:0x60] // @00AD stack[-1] // @00B6 memory[0x40:0x60] // @00BB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 00A0 5B JUMPDEST 00A1 60 PUSH1 0x40 00A3 51 MLOAD 00A4 60 PUSH1 0x01 00A6 60 PUSH1 0x01 00A8 60 PUSH1 0xa0 00AA 1B SHL 00AB 03 SUB 00AC 90 SWAP1 00AD 91 SWAP2 00AE 16 AND 00AF 81 DUP2 00B0 52 MSTORE 00B1 60 PUSH1 0x20 00B3 01 ADD 00B4 60 PUSH1 0x40 00B6 51 MLOAD 00B7 80 DUP1 00B8 91 SWAP2 00B9 03 SUB 00BA 90 SWAP1 00BB F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @00B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @00BB return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_00BC: // Incoming jump from 0x0064, if 0x715018a6 == stack[-1] // Inputs[1] { @00BD msg.value } 00BC 5B JUMPDEST 00BD 34 CALLVALUE 00BE 80 DUP1 00BF 15 ISZERO 00C0 61 PUSH2 0x00c8 00C3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00BD stack[0] = msg.value } // Block ends with conditional jump to 0x00c8, if !msg.value label_00C4: // Incoming jump from 0x00C3, if not !msg.value // Inputs[1] { @00C7 memory[0x00:0x00] } 00C4 60 PUSH1 0x00 00C6 80 DUP1 00C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @00C7 revert(memory[0x00:0x00]); } // Block terminates label_00C8: // Incoming jump from 0x00C3, if !msg.value 00C8 5B JUMPDEST 00C9 50 POP 00CA 61 PUSH2 0x00d1 00CD 61 PUSH2 0x0215 00D0 56 *JUMP // Stack delta = +0 // Outputs[1] { @00CA stack[-1] = 0x00d1 } // Block ends with call to 0x0215, returns to 0x00D1 label_00D1: // Incoming return from call to 0x011F at 0x011E // Incoming return from call to 0x00EE at 0x00ED // Incoming return from call to 0x015F at 0x015E // Incoming return from call to 0x013F at 0x013E // Incoming return from call to 0x0215 at 0x00D0 00D1 5B JUMPDEST 00D2 00 *STOP // Stack delta = +0 // Outputs[1] { @00D2 stop(); } // Block terminates label_00D3: // Incoming jump from 0x006F, if 0x7eff275e == stack[-1] // Inputs[1] { @00D4 msg.value } 00D3 5B JUMPDEST 00D4 34 CALLVALUE 00D5 80 DUP1 00D6 15 ISZERO 00D7 61 PUSH2 0x00df 00DA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00D4 stack[0] = msg.value } // Block ends with conditional jump to 0x00df, if !msg.value label_00DB: // Incoming jump from 0x00DA, if not !msg.value // Inputs[1] { @00DE memory[0x00:0x00] } 00DB 60 PUSH1 0x00 00DD 80 DUP1 00DE FD *REVERT // Stack delta = +0 // Outputs[1] { @00DE revert(memory[0x00:0x00]); } // Block terminates label_00DF: // Incoming jump from 0x00DA, if !msg.value // Inputs[1] { @00E7 msg.data.length } 00DF 5B JUMPDEST 00E0 50 POP 00E1 61 PUSH2 0x00d1 00E4 61 PUSH2 0x00ee 00E7 36 CALLDATASIZE 00E8 60 PUSH1 0x04 00EA 61 PUSH2 0x0554 00ED 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @00E1 stack[-1] = 0x00d1 // @00E4 stack[0] = 0x00ee // @00E7 stack[1] = msg.data.length // @00E8 stack[2] = 0x04 // } // Block ends with call to 0x0554, returns to 0x00EE label_00EE: // Incoming return from call to 0x0554 at 0x00ED 00EE 5B JUMPDEST 00EF 61 PUSH2 0x0292 00F2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0292 label_00F3: // Incoming jump from 0x007A, if 0x8da5cb5b == stack[-1] // Inputs[1] { @00F4 msg.value } 00F3 5B JUMPDEST 00F4 34 CALLVALUE 00F5 80 DUP1 00F6 15 ISZERO 00F7 61 PUSH2 0x00ff 00FA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00F4 stack[0] = msg.value } // Block ends with conditional jump to 0x00ff, if !msg.value label_00FB: // Incoming jump from 0x00FA, if not !msg.value // Inputs[1] { @00FE memory[0x00:0x00] } 00FB 60 PUSH1 0x00 00FD 80 DUP1 00FE FD *REVERT // Stack delta = +0 // Outputs[1] { @00FE revert(memory[0x00:0x00]); } // Block terminates label_00FF: // Incoming jump from 0x00FA, if !msg.value // Inputs[1] { @0103 storage[0x00] } 00FF 5B JUMPDEST 0100 50 POP 0101 60 PUSH1 0x00 0103 54 SLOAD 0104 60 PUSH1 0x01 0106 60 PUSH1 0x01 0108 60 PUSH1 0xa0 010A 1B SHL 010B 03 SUB 010C 16 AND 010D 61 PUSH2 0x00a0 0110 56 *JUMP // Stack delta = +0 // Outputs[1] { @010C stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x00] } // Block ends with unconditional jump to 0x00a0 label_0111: // Incoming jump from 0x0028, if 0x9623609d == stack[-1] // Inputs[1] { @0118 msg.data.length } 0111 5B JUMPDEST 0112 61 PUSH2 0x00d1 0115 61 PUSH2 0x011f 0118 36 CALLDATASIZE 0119 60 PUSH1 0x04 011B 61 PUSH2 0x058c 011E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0112 stack[0] = 0x00d1 // @0115 stack[1] = 0x011f // @0118 stack[2] = msg.data.length // @0119 stack[3] = 0x04 // } // Block ends with call to 0x058c, returns to 0x011F label_011F: // Incoming return from call to 0x058C at 0x011E 011F 5B JUMPDEST 0120 61 PUSH2 0x031c 0123 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x031c label_0124: // Incoming jump from 0x0033, if 0x99a88ec4 == stack[-1] // Inputs[1] { @0125 msg.value } 0124 5B JUMPDEST 0125 34 CALLVALUE 0126 80 DUP1 0127 15 ISZERO 0128 61 PUSH2 0x0130 012B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0125 stack[0] = msg.value } // Block ends with conditional jump to 0x0130, if !msg.value label_012C: // Incoming jump from 0x012B, if not !msg.value // Inputs[1] { @012F memory[0x00:0x00] } 012C 60 PUSH1 0x00 012E 80 DUP1 012F FD *REVERT // Stack delta = +0 // Outputs[1] { @012F revert(memory[0x00:0x00]); } // Block terminates label_0130: // Incoming jump from 0x012B, if !msg.value // Inputs[1] { @0138 msg.data.length } 0130 5B JUMPDEST 0131 50 POP 0132 61 PUSH2 0x00d1 0135 61 PUSH2 0x013f 0138 36 CALLDATASIZE 0139 60 PUSH1 0x04 013B 61 PUSH2 0x0554 013E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0132 stack[-1] = 0x00d1 // @0135 stack[0] = 0x013f // @0138 stack[1] = msg.data.length // @0139 stack[2] = 0x04 // } // Block ends with call to 0x0554, returns to 0x013F label_013F: // Incoming return from call to 0x0554 at 0x013E 013F 5B JUMPDEST 0140 61 PUSH2 0x03ad 0143 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03ad label_0144: // Incoming jump from 0x003E, if 0xf2fde38b == stack[-1] // Inputs[1] { @0145 msg.value } 0144 5B JUMPDEST 0145 34 CALLVALUE 0146 80 DUP1 0147 15 ISZERO 0148 61 PUSH2 0x0150 014B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0145 stack[0] = msg.value } // Block ends with conditional jump to 0x0150, if !msg.value label_014C: // Incoming jump from 0x014B, if not !msg.value // Inputs[1] { @014F memory[0x00:0x00] } 014C 60 PUSH1 0x00 014E 80 DUP1 014F FD *REVERT // Stack delta = +0 // Outputs[1] { @014F revert(memory[0x00:0x00]); } // Block terminates label_0150: // Incoming jump from 0x014B, if !msg.value // Inputs[1] { @0158 msg.data.length } 0150 5B JUMPDEST 0151 50 POP 0152 61 PUSH2 0x00d1 0155 61 PUSH2 0x015f 0158 36 CALLDATASIZE 0159 60 PUSH1 0x04 015B 61 PUSH2 0x0515 015E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0152 stack[-1] = 0x00d1 // @0155 stack[0] = 0x015f // @0158 stack[1] = msg.data.length // @0159 stack[2] = 0x04 // } // Block ends with call to 0x0515, returns to 0x015F label_015F: // Incoming return from call to 0x0515 at 0x015E 015F 5B JUMPDEST 0160 61 PUSH2 0x0405 0163 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0405 label_0164: // Incoming jump from 0x0049, if 0xf3b7dead == stack[-1] // Inputs[1] { @0165 msg.value } 0164 5B JUMPDEST 0165 34 CALLVALUE 0166 80 DUP1 0167 15 ISZERO 0168 61 PUSH2 0x0170 016B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0165 stack[0] = msg.value } // Block ends with conditional jump to 0x0170, if !msg.value label_016C: // Incoming jump from 0x016B, if not !msg.value // Inputs[1] { @016F memory[0x00:0x00] } 016C 60 PUSH1 0x00 016E 80 DUP1 016F FD *REVERT // Stack delta = +0 // Outputs[1] { @016F revert(memory[0x00:0x00]); } // Block terminates label_0170: // Incoming jump from 0x016B, if !msg.value // Inputs[1] { @0178 msg.data.length } 0170 5B JUMPDEST 0171 50 POP 0172 61 PUSH2 0x00a0 0175 61 PUSH2 0x017f 0178 36 CALLDATASIZE 0179 60 PUSH1 0x04 017B 61 PUSH2 0x0515 017E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0172 stack[-1] = 0x00a0 // @0175 stack[0] = 0x017f // @0178 stack[1] = msg.data.length // @0179 stack[2] = 0x04 // } // Block ends with call to 0x0515, returns to 0x017F label_017F: // Incoming return from call to 0x0515 at 0x017E 017F 5B JUMPDEST 0180 61 PUSH2 0x04ef 0183 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04ef label_0184: // Incoming jump from 0x009F // Inputs[2] // { // @018A stack[-1] // @0196 memory[0x40:0x60] // } 0184 5B JUMPDEST 0185 60 PUSH1 0x00 0187 80 DUP1 0188 60 PUSH1 0x00 018A 83 DUP4 018B 60 PUSH1 0x01 018D 60 PUSH1 0x01 018F 60 PUSH1 0xa0 0191 1B SHL 0192 03 SUB 0193 16 AND 0194 60 PUSH1 0x40 0196 51 MLOAD 0197 61 PUSH2 0x01aa 019A 90 SWAP1 019B 63 PUSH4 0x5c60da1b 01A0 60 PUSH1 0xe0 01A2 1B SHL 01A3 81 DUP2 01A4 52 MSTORE 01A5 60 PUSH1 0x04 01A7 01 ADD 01A8 90 SWAP1 01A9 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @0185 stack[0] = 0x00 // @0187 stack[1] = 0x00 // @0188 stack[2] = 0x00 // @0193 stack[3] = (0x01 << 0xa0) - 0x01 & stack[-1] // @01A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5c60da1b << 0xe0 // @01A8 stack[4] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01aa label_01AA: // Incoming jump from 0x0514 // Incoming jump from 0x01A9 // Inputs[7] // { // @01AF memory[0x40:0x60] // @01B1 stack[-1] // @01B4 stack[-2] // @01B5 msg.gas // @01B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @01B6 address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @01BA returndata.length // } 01AA 5B JUMPDEST 01AB 60 PUSH1 0x00 01AD 60 PUSH1 0x40 01AF 51 MLOAD 01B0 80 DUP1 01B1 83 DUP4 01B2 03 SUB 01B3 81 DUP2 01B4 85 DUP6 01B5 5A GAS 01B6 FA STATICCALL 01B7 91 SWAP2 01B8 50 POP 01B9 50 POP 01BA 3D RETURNDATASIZE 01BB 80 DUP1 01BC 60 PUSH1 0x00 01BE 81 DUP2 01BF 14 EQ 01C0 61 PUSH2 0x01e5 01C3 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @01B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @01B7 stack[-2] = address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @01BA stack[-1] = returndata.length // @01BB stack[0] = returndata.length // } // Block ends with conditional jump to 0x01e5, if returndata.length == 0x00 label_01C4: // Incoming jump from 0x01C3, if not returndata.length == 0x00 // Inputs[6] // { // @01C6 memory[0x40:0x60] // @01C7 stack[-2] // @01CE returndata.length // @01D6 returndata.length // @01D9 returndata.length // @01E0 returndata[0x00:0x00 + returndata.length] // } 01C4 60 PUSH1 0x40 01C6 51 MLOAD 01C7 91 SWAP2 01C8 50 POP 01C9 60 PUSH1 0x1f 01CB 19 NOT 01CC 60 PUSH1 0x3f 01CE 3D RETURNDATASIZE 01CF 01 ADD 01D0 16 AND 01D1 82 DUP3 01D2 01 ADD 01D3 60 PUSH1 0x40 01D5 52 MSTORE 01D6 3D RETURNDATASIZE 01D7 82 DUP3 01D8 52 MSTORE 01D9 3D RETURNDATASIZE 01DA 60 PUSH1 0x00 01DC 60 PUSH1 0x20 01DE 84 DUP5 01DF 01 ADD 01E0 3E RETURNDATACOPY 01E1 61 PUSH2 0x01ea 01E4 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @01C7 stack[-2] = memory[0x40:0x60] // @01D5 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @01D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @01E0 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x01ea label_01E5: // Incoming jump from 0x01C3, if returndata.length == 0x00 // Inputs[4] // { // @01E8 stack[-2] // @01EC stack[-4] // @01EE stack[-5] // @01EE stack[-3] // } 01E5 5B JUMPDEST 01E6 60 PUSH1 0x60 01E8 91 SWAP2 01E9 50 POP 01EA 5B JUMPDEST 01EB 50 POP 01EC 91 SWAP2 01ED 50 POP 01EE 91 SWAP2 01EF 50 POP 01F0 81 DUP2 01F1 61 PUSH2 0x01f9 01F4 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @01EC stack[-4] = 0x60 // @01EE stack[-5] = stack[-3] // } // Block ends with conditional jump to 0x01f9, if stack[-3] label_01F5: // Incoming jump from 0x01F4, if not stack[-3] // Incoming jump from 0x01F4, if not stack[-3] // Inputs[1] { @01F8 memory[0x00:0x00] } 01F5 60 PUSH1 0x00 01F7 80 DUP1 01F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F8 revert(memory[0x00:0x00]); } // Block terminates label_01F9: // Incoming jump from 0x01F4, if stack[-3] // Incoming jump from 0x01F4, if stack[-3] // Inputs[2] // { // @01FA stack[-1] // @0200 memory[stack[-1]:stack[-1] + 0x20] // } 01F9 5B JUMPDEST 01FA 80 DUP1 01FB 80 DUP1 01FC 60 PUSH1 0x20 01FE 01 ADD 01FF 90 SWAP1 0200 51 MLOAD 0201 81 DUP2 0202 01 ADD 0203 90 SWAP1 0204 61 PUSH2 0x020d 0207 91 SWAP2 0208 90 SWAP1 0209 61 PUSH2 0x0538 020C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0207 stack[0] = 0x020d // @0208 stack[1] = 0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20] // @0208 stack[2] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0538 020D 5B JUMPDEST 020E 94 SWAP5 020F 93 SWAP4 0210 50 POP 0211 50 POP 0212 50 POP 0213 50 POP 0214 56 *JUMP label_0215: // Incoming call from 0x00D0, returns to 0x00D1 // Inputs[2] // { // @0218 storage[0x00] // @0222 msg.sender // } 0215 5B JUMPDEST 0216 60 PUSH1 0x00 0218 54 SLOAD 0219 60 PUSH1 0x01 021B 60 PUSH1 0x01 021D 60 PUSH1 0xa0 021F 1B SHL 0220 03 SUB 0221 16 AND 0222 33 CALLER 0223 14 EQ 0224 61 PUSH2 0x0248 0227 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0248, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0228: // Incoming jump from 0x0227, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @022A memory[0x40:0x60] } 0228 60 PUSH1 0x40 022A 51 MLOAD 022B 62 PUSH3 0x461bcd 022F 60 PUSH1 0xe5 0231 1B SHL 0232 81 DUP2 0233 52 MSTORE 0234 60 PUSH1 0x04 0236 01 ADD 0237 61 PUSH2 0x023f 023A 90 SWAP1 023B 61 PUSH2 0x06c0 023E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0233 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @023A stack[0] = 0x023f // @023A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x06c0, returns to 0x023F label_023F: // Incoming return from call to 0x06C0 at 0x023E // Incoming jump from 0x0493 // Incoming return from call to 0x06C0 at 0x042E // Incoming return from call to 0x06C0 at 0x02BB // Incoming return from call to 0x06C0 at 0x0345 // Incoming return from call to 0x06C0 at 0x03D6 // Inputs[3] // { // @0242 memory[0x40:0x60] // @0244 stack[-1] // @0247 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 023F 5B JUMPDEST 0240 60 PUSH1 0x40 0242 51 MLOAD 0243 80 DUP1 0244 91 SWAP2 0245 03 SUB 0246 90 SWAP1 0247 FD *REVERT // Stack delta = -1 // Outputs[1] { @0247 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0248: // Incoming jump from 0x0227, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[5] // { // @024C storage[0x00] // @024F memory[0x40:0x60] // @0280 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0284 storage[0x00] // @0291 stack[-1] // } 0248 5B JUMPDEST 0249 60 PUSH1 0x00 024B 80 DUP1 024C 54 SLOAD 024D 60 PUSH1 0x40 024F 51 MLOAD 0250 60 PUSH1 0x01 0252 60 PUSH1 0x01 0254 60 PUSH1 0xa0 0256 1B SHL 0257 03 SUB 0258 90 SWAP1 0259 91 SWAP2 025A 16 AND 025B 90 SWAP1 025C 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 027D 90 SWAP1 027E 83 DUP4 027F 90 SWAP1 0280 A3 LOG3 0281 60 PUSH1 0x00 0283 80 DUP1 0284 54 SLOAD 0285 60 PUSH1 0x01 0287 60 PUSH1 0x01 0289 60 PUSH1 0xa0 028B 1B SHL 028C 03 SUB 028D 19 NOT 028E 16 AND 028F 90 SWAP1 0290 55 SSTORE 0291 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @0280 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & (0x01 << 0xa0) - 0x01, 0x00]); // @0290 storage[0x00] = ~((0x01 << 0xa0) - 0x01) & storage[0x00] // } // Block ends with unconditional jump to stack[-1] label_0292: // Incoming jump from 0x00F2 // Inputs[2] // { // @0295 storage[0x00] // @029F msg.sender // } 0292 5B JUMPDEST 0293 60 PUSH1 0x00 0295 54 SLOAD 0296 60 PUSH1 0x01 0298 60 PUSH1 0x01 029A 60 PUSH1 0xa0 029C 1B SHL 029D 03 SUB 029E 16 AND 029F 33 CALLER 02A0 14 EQ 02A1 61 PUSH2 0x02bc 02A4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02bc, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_02A5: // Incoming jump from 0x02A4, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @02A7 memory[0x40:0x60] } 02A5 60 PUSH1 0x40 02A7 51 MLOAD 02A8 62 PUSH3 0x461bcd 02AC 60 PUSH1 0xe5 02AE 1B SHL 02AF 81 DUP2 02B0 52 MSTORE 02B1 60 PUSH1 0x04 02B3 01 ADD 02B4 61 PUSH2 0x023f 02B7 90 SWAP1 02B8 61 PUSH2 0x06c0 02BB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @02B7 stack[0] = 0x023f // @02B7 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x06c0, returns to 0x023F label_02BC: // Incoming jump from 0x02A4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[3] // { // @02BF memory[0x40:0x60] // @02D2 stack[-1] // @02DA stack[-2] // } 02BC 5B JUMPDEST 02BD 60 PUSH1 0x40 02BF 51 MLOAD 02C0 63 PUSH4 0x08f28397 02C5 60 PUSH1 0xe4 02C7 1B SHL 02C8 81 DUP2 02C9 52 MSTORE 02CA 60 PUSH1 0x01 02CC 60 PUSH1 0x01 02CE 60 PUSH1 0xa0 02D0 1B SHL 02D1 03 SUB 02D2 82 DUP3 02D3 81 DUP2 02D4 16 AND 02D5 60 PUSH1 0x04 02D7 83 DUP4 02D8 01 ADD 02D9 52 MSTORE 02DA 83 DUP4 02DB 16 AND 02DC 90 SWAP1 02DD 63 PUSH4 0x8f283970 02E2 90 SWAP1 02E3 60 PUSH1 0x24 02E5 01 ADD // Stack delta = +3 // Outputs[5] // { // @02C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08f28397 << 0xe4 // @02D9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @02DC stack[0] = stack[-2] & (0x01 << 0xa0) - 0x01 // @02E2 stack[1] = 0x8f283970 // @02E5 stack[2] = 0x24 + memory[0x40:0x60] // } // Block continues label_02E6: // Incoming jump from 0x0404 // Incoming jump from 0x02E5 // Inputs[4] // { // @02EB memory[0x40:0x60] // @02ED stack[-1] // @02F2 stack[-3] // @02F4 address(stack[-3]).code.length // } 02E6 5B JUMPDEST 02E7 60 PUSH1 0x00 02E9 60 PUSH1 0x40 02EB 51 MLOAD 02EC 80 DUP1 02ED 83 DUP4 02EE 03 SUB 02EF 81 DUP2 02F0 60 PUSH1 0x00 02F2 87 DUP8 02F3 80 DUP1 02F4 3B EXTCODESIZE 02F5 15 ISZERO 02F6 80 DUP1 02F7 15 ISZERO 02F8 61 PUSH2 0x0300 02FB 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @02E7 stack[0] = 0x00 // @02EB stack[1] = memory[0x40:0x60] // @02EE stack[2] = stack[-1] - memory[0x40:0x60] // @02EF stack[3] = memory[0x40:0x60] // @02F0 stack[4] = 0x00 // @02F2 stack[5] = stack[-3] // @02F5 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x0300, if !!address(stack[-3]).code.length label_02FC: // Incoming jump from 0x02FB, if not !!address(stack[-3]).code.length // Inputs[1] { @02FF memory[0x00:0x00] } 02FC 60 PUSH1 0x00 02FE 80 DUP1 02FF FD *REVERT // Stack delta = +0 // Outputs[1] { @02FF revert(memory[0x00:0x00]); } // Block terminates label_0300: // Incoming jump from 0x02FB, if !!address(stack[-3]).code.length // Inputs[9] // { // @0302 msg.gas // @0303 stack[-7] // @0303 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0303 memory[stack[-4]:stack[-4] + stack[-5]] // @0303 stack[-2] // @0303 stack[-3] // @0303 stack[-6] // @0303 stack[-5] // @0303 stack[-4] // } 0300 5B JUMPDEST 0301 50 POP 0302 5A GAS 0303 F1 CALL 0304 15 ISZERO 0305 80 DUP1 0306 15 ISZERO 0307 61 PUSH2 0x0314 030A 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0303 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0304 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 0x0314, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_030B: // Incoming jump from 0x030A, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @030B returndata.length // @030F returndata[0x00:0x00 + returndata.length] // @0310 returndata.length // @0313 memory[0x00:0x00 + returndata.length] // } 030B 3D RETURNDATASIZE 030C 60 PUSH1 0x00 030E 80 DUP1 030F 3E RETURNDATACOPY 0310 3D RETURNDATASIZE 0311 60 PUSH1 0x00 0313 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @030F memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0313 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0314: // Incoming jump from 0x030A, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @031B stack[-7] } 0314 5B JUMPDEST 0315 50 POP 0316 50 POP 0317 50 POP 0318 50 POP 0319 50 POP 031A 50 POP 031B 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_031C: // Incoming jump from 0x0123 // Inputs[2] // { // @031F storage[0x00] // @0329 msg.sender // } 031C 5B JUMPDEST 031D 60 PUSH1 0x00 031F 54 SLOAD 0320 60 PUSH1 0x01 0322 60 PUSH1 0x01 0324 60 PUSH1 0xa0 0326 1B SHL 0327 03 SUB 0328 16 AND 0329 33 CALLER 032A 14 EQ 032B 61 PUSH2 0x0346 032E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0346, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_032F: // Incoming jump from 0x032E, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0331 memory[0x40:0x60] } 032F 60 PUSH1 0x40 0331 51 MLOAD 0332 62 PUSH3 0x461bcd 0336 60 PUSH1 0xe5 0338 1B SHL 0339 81 DUP2 033A 52 MSTORE 033B 60 PUSH1 0x04 033D 01 ADD 033E 61 PUSH2 0x023f 0341 90 SWAP1 0342 61 PUSH2 0x06c0 0345 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @033A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0341 stack[0] = 0x023f // @0341 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x06c0, returns to 0x023F label_0346: // Incoming jump from 0x032E, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[5] // { // @0349 memory[0x40:0x60] // @035C stack[-3] // @0365 msg.value // @036B stack[-2] // @036D stack[-1] // } 0346 5B JUMPDEST 0347 60 PUSH1 0x40 0349 51 MLOAD 034A 63 PUSH4 0x278f7943 034F 60 PUSH1 0xe1 0351 1B SHL 0352 81 DUP2 0353 52 MSTORE 0354 60 PUSH1 0x01 0356 60 PUSH1 0x01 0358 60 PUSH1 0xa0 035A 1B SHL 035B 03 SUB 035C 84 DUP5 035D 16 AND 035E 90 SWAP1 035F 63 PUSH4 0x4f1ef286 0364 90 SWAP1 0365 34 CALLVALUE 0366 90 SWAP1 0367 61 PUSH2 0x0376 036A 90 SWAP1 036B 86 DUP7 036C 90 SWAP1 036D 86 DUP7 036E 90 SWAP1 036F 60 PUSH1 0x04 0371 01 ADD 0372 61 PUSH2 0x065d 0375 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @0353 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x278f7943 << 0xe1 // @035E stack[0] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0364 stack[1] = 0x4f1ef286 // @0366 stack[2] = msg.value // @036A stack[3] = 0x0376 // @036C stack[4] = stack[-2] // @036E stack[5] = stack[-1] // @0371 stack[6] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x065d, returns to 0x0376 label_0376: // Incoming return from call to 0x065D at 0x0375 // Inputs[5] // { // @037B memory[0x40:0x60] // @037D stack[-1] // @0380 stack[-2] // @0381 stack[-4] // @0383 address(stack[-4]).code.length // } 0376 5B JUMPDEST 0377 60 PUSH1 0x00 0379 60 PUSH1 0x40 037B 51 MLOAD 037C 80 DUP1 037D 83 DUP4 037E 03 SUB 037F 81 DUP2 0380 85 DUP6 0381 88 DUP9 0382 80 DUP1 0383 3B EXTCODESIZE 0384 15 ISZERO 0385 80 DUP1 0386 15 ISZERO 0387 61 PUSH2 0x038f 038A 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @0377 stack[0] = 0x00 // @037B stack[1] = memory[0x40:0x60] // @037E stack[2] = stack[-1] - memory[0x40:0x60] // @037F stack[3] = memory[0x40:0x60] // @0380 stack[4] = stack[-2] // @0381 stack[5] = stack[-4] // @0384 stack[6] = !address(stack[-4]).code.length // } // Block ends with conditional jump to 0x038f, if !!address(stack[-4]).code.length label_038B: // Incoming jump from 0x038A, if not !!address(stack[-4]).code.length // Inputs[1] { @038E memory[0x00:0x00] } 038B 60 PUSH1 0x00 038D 80 DUP1 038E FD *REVERT // Stack delta = +0 // Outputs[1] { @038E revert(memory[0x00:0x00]); } // Block terminates label_038F: // Incoming jump from 0x038A, if !!address(stack[-4]).code.length // Inputs[9] // { // @0391 msg.gas // @0392 stack[-2] // @0392 stack[-3] // @0392 stack[-5] // @0392 memory[stack[-4]:stack[-4] + stack[-5]] // @0392 stack[-4] // @0392 stack[-6] // @0392 stack[-7] // @0392 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 038F 5B JUMPDEST 0390 50 POP 0391 5A GAS 0392 F1 CALL 0393 15 ISZERO 0394 80 DUP1 0395 15 ISZERO 0396 61 PUSH2 0x03a3 0399 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0392 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0393 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 0x03a3, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_039A: // Incoming jump from 0x0399, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @039A returndata.length // @039E returndata[0x00:0x00 + returndata.length] // @039F returndata.length // @03A2 memory[0x00:0x00 + returndata.length] // } 039A 3D RETURNDATASIZE 039B 60 PUSH1 0x00 039D 80 DUP1 039E 3E RETURNDATACOPY 039F 3D RETURNDATASIZE 03A0 60 PUSH1 0x00 03A2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @039E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @03A2 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_03A3: // Incoming jump from 0x0399, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @03AC stack[-9] } 03A3 5B JUMPDEST 03A4 50 POP 03A5 50 POP 03A6 50 POP 03A7 50 POP 03A8 50 POP 03A9 50 POP 03AA 50 POP 03AB 50 POP 03AC 56 *JUMP // Stack delta = -9 // Block ends with unconditional jump to stack[-9] label_03AD: // Incoming jump from 0x0143 // Inputs[2] // { // @03B0 storage[0x00] // @03BA msg.sender // } 03AD 5B JUMPDEST 03AE 60 PUSH1 0x00 03B0 54 SLOAD 03B1 60 PUSH1 0x01 03B3 60 PUSH1 0x01 03B5 60 PUSH1 0xa0 03B7 1B SHL 03B8 03 SUB 03B9 16 AND 03BA 33 CALLER 03BB 14 EQ 03BC 61 PUSH2 0x03d7 03BF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d7, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_03C0: // Incoming jump from 0x03BF, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @03C2 memory[0x40:0x60] } 03C0 60 PUSH1 0x40 03C2 51 MLOAD 03C3 62 PUSH3 0x461bcd 03C7 60 PUSH1 0xe5 03C9 1B SHL 03CA 81 DUP2 03CB 52 MSTORE 03CC 60 PUSH1 0x04 03CE 01 ADD 03CF 61 PUSH2 0x023f 03D2 90 SWAP1 03D3 61 PUSH2 0x06c0 03D6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @03CB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @03D2 stack[0] = 0x023f // @03D2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x06c0, returns to 0x023F label_03D7: // Incoming jump from 0x03BF, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[3] // { // @03DA memory[0x40:0x60] // @03ED stack[-1] // @03F5 stack[-2] // } 03D7 5B JUMPDEST 03D8 60 PUSH1 0x40 03DA 51 MLOAD 03DB 63 PUSH4 0x1b2ce7f3 03E0 60 PUSH1 0xe1 03E2 1B SHL 03E3 81 DUP2 03E4 52 MSTORE 03E5 60 PUSH1 0x01 03E7 60 PUSH1 0x01 03E9 60 PUSH1 0xa0 03EB 1B SHL 03EC 03 SUB 03ED 82 DUP3 03EE 81 DUP2 03EF 16 AND 03F0 60 PUSH1 0x04 03F2 83 DUP4 03F3 01 ADD 03F4 52 MSTORE 03F5 83 DUP4 03F6 16 AND 03F7 90 SWAP1 03F8 63 PUSH4 0x3659cfe6 03FD 90 SWAP1 03FE 60 PUSH1 0x24 0400 01 ADD 0401 61 PUSH2 0x02e6 0404 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @03E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1b2ce7f3 << 0xe1 // @03F4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @03F7 stack[0] = stack[-2] & (0x01 << 0xa0) - 0x01 // @03FD stack[1] = 0x3659cfe6 // @0400 stack[2] = 0x24 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02e6 label_0405: // Incoming jump from 0x0163 // Inputs[2] // { // @0408 storage[0x00] // @0412 msg.sender // } 0405 5B JUMPDEST 0406 60 PUSH1 0x00 0408 54 SLOAD 0409 60 PUSH1 0x01 040B 60 PUSH1 0x01 040D 60 PUSH1 0xa0 040F 1B SHL 0410 03 SUB 0411 16 AND 0412 33 CALLER 0413 14 EQ 0414 61 PUSH2 0x042f 0417 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x042f, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0418: // Incoming jump from 0x0417, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @041A memory[0x40:0x60] } 0418 60 PUSH1 0x40 041A 51 MLOAD 041B 62 PUSH3 0x461bcd 041F 60 PUSH1 0xe5 0421 1B SHL 0422 81 DUP2 0423 52 MSTORE 0424 60 PUSH1 0x04 0426 01 ADD 0427 61 PUSH2 0x023f 042A 90 SWAP1 042B 61 PUSH2 0x06c0 042E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0423 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @042A stack[0] = 0x023f // @042A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x06c0, returns to 0x023F label_042F: // Incoming jump from 0x0417, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0438 stack[-1] } 042F 5B JUMPDEST 0430 60 PUSH1 0x01 0432 60 PUSH1 0x01 0434 60 PUSH1 0xa0 0436 1B SHL 0437 03 SUB 0438 81 DUP2 0439 16 AND 043A 61 PUSH2 0x0494 043D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0494, if stack[-1] & (0x01 << 0xa0) - 0x01 label_043E: // Incoming jump from 0x043D, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0440 memory[0x40:0x60] } 043E 60 PUSH1 0x40 0440 51 MLOAD 0441 62 PUSH3 0x461bcd 0445 60 PUSH1 0xe5 0447 1B SHL 0448 81 DUP2 0449 52 MSTORE 044A 60 PUSH1 0x20 044C 60 PUSH1 0x04 044E 82 DUP3 044F 01 ADD 0450 52 MSTORE 0451 60 PUSH1 0x26 0453 60 PUSH1 0x24 0455 82 DUP3 0456 01 ADD 0457 52 MSTORE 0458 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 0479 60 PUSH1 0x44 047B 82 DUP3 047C 01 ADD 047D 52 MSTORE 047E 65 PUSH6 0x646472657373 0485 60 PUSH1 0xd0 0487 1B SHL 0488 60 PUSH1 0x64 048A 82 DUP3 048B 01 ADD 048C 52 MSTORE 048D 60 PUSH1 0x84 048F 01 ADD 0490 61 PUSH2 0x023f 0493 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0449 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0450 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0457 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @047D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @048C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @048F stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x023f label_0494: // Incoming jump from 0x043D, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @0498 storage[0x00] // @049B memory[0x40:0x60] // @04A5 stack[-1] // @04CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @04D1 storage[0x00] // @04EE stack[-2] // } 0494 5B JUMPDEST 0495 60 PUSH1 0x00 0497 80 DUP1 0498 54 SLOAD 0499 60 PUSH1 0x40 049B 51 MLOAD 049C 60 PUSH1 0x01 049E 60 PUSH1 0x01 04A0 60 PUSH1 0xa0 04A2 1B SHL 04A3 03 SUB 04A4 80 DUP1 04A5 85 DUP6 04A6 16 AND 04A7 93 SWAP4 04A8 92 SWAP3 04A9 16 AND 04AA 91 SWAP2 04AB 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 04CC 91 SWAP2 04CD A3 LOG3 04CE 60 PUSH1 0x00 04D0 80 DUP1 04D1 54 SLOAD 04D2 60 PUSH1 0x01 04D4 60 PUSH1 0x01 04D6 60 PUSH1 0xa0 04D8 1B SHL 04D9 03 SUB 04DA 19 NOT 04DB 16 AND 04DC 60 PUSH1 0x01 04DE 60 PUSH1 0x01 04E0 60 PUSH1 0xa0 04E2 1B SHL 04E3 03 SUB 04E4 92 SWAP3 04E5 90 SWAP1 04E6 92 SWAP3 04E7 16 AND 04E8 91 SWAP2 04E9 90 SWAP1 04EA 91 SWAP2 04EB 17 OR 04EC 90 SWAP1 04ED 55 SSTORE 04EE 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @04CD log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // @04ED storage[0x00] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x00]) // } // Block ends with unconditional jump to stack[-2] label_04EF: // Incoming jump from 0x0183 // Inputs[2] // { // @04F5 stack[-1] // @0501 memory[0x40:0x60] // } 04EF 5B JUMPDEST 04F0 60 PUSH1 0x00 04F2 80 DUP1 04F3 60 PUSH1 0x00 04F5 83 DUP4 04F6 60 PUSH1 0x01 04F8 60 PUSH1 0x01 04FA 60 PUSH1 0xa0 04FC 1B SHL 04FD 03 SUB 04FE 16 AND 04FF 60 PUSH1 0x40 0501 51 MLOAD 0502 61 PUSH2 0x01aa 0505 90 SWAP1 0506 63 PUSH4 0x03e14691 050B 60 PUSH1 0xe6 050D 1B SHL 050E 81 DUP2 050F 52 MSTORE 0510 60 PUSH1 0x04 0512 01 ADD 0513 90 SWAP1 0514 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @04F0 stack[0] = 0x00 // @04F2 stack[1] = 0x00 // @04F3 stack[2] = 0x00 // @04FE stack[3] = (0x01 << 0xa0) - 0x01 & stack[-1] // @050F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x03e14691 << 0xe6 // @0513 stack[4] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01aa label_0515: // Incoming call from 0x009A, returns to 0x009B // Incoming call from 0x017E, returns to 0x017F // Incoming call from 0x015E, returns to 0x015F // Inputs[2] // { // @051A stack[-1] // @051B stack[-2] // } 0515 5B JUMPDEST 0516 60 PUSH1 0x00 0518 60 PUSH1 0x20 051A 82 DUP3 051B 84 DUP5 051C 03 SUB 051D 12 SLT 051E 15 ISZERO 051F 61 PUSH2 0x0526 0522 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0516 stack[0] = 0x00 } // Block ends with conditional jump to 0x0526, if !(stack[-2] - stack[-1] i< 0x20) label_0523: // Incoming jump from 0x0522, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @0523 stack[-1] // @0525 memory[stack[-1]:stack[-1] + stack[-1]] // } 0523 80 DUP1 0524 81 DUP2 0525 FD *REVERT // Stack delta = +0 // Outputs[1] { @0525 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_0526: // Incoming jump from 0x0522, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @0527 stack[-2] // @0528 msg.data[stack[-2]:stack[-2] + 0x20] // } 0526 5B JUMPDEST 0527 81 DUP2 0528 35 CALLDATALOAD 0529 61 PUSH2 0x0531 052C 81 DUP2 052D 61 PUSH2 0x070b 0530 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0528 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @0529 stack[1] = 0x0531 // @052C stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x070b, returns to 0x0531 label_0531: // Incoming return from call to 0x070B at 0x0553 // Incoming return from call to 0x070B at 0x0530 // Inputs[3] // { // @0532 stack[-1] // @0532 stack[-5] // @0533 stack[-4] // } 0531 5B JUMPDEST 0532 93 SWAP4 0533 92 SWAP3 0534 50 POP 0535 50 POP 0536 50 POP 0537 56 *JUMP // Stack delta = -4 // Outputs[1] { @0532 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0538: // Incoming jump from 0x020C // Inputs[2] // { // @053D stack[-1] // @053E stack[-2] // } 0538 5B JUMPDEST 0539 60 PUSH1 0x00 053B 60 PUSH1 0x20 053D 82 DUP3 053E 84 DUP5 053F 03 SUB 0540 12 SLT 0541 15 ISZERO 0542 61 PUSH2 0x0549 0545 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0539 stack[0] = 0x00 } // Block ends with conditional jump to 0x0549, if !(stack[-2] - stack[-1] i< 0x20) label_0546: // Incoming jump from 0x0545, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @0546 stack[-1] // @0548 memory[stack[-1]:stack[-1] + stack[-1]] // } 0546 80 DUP1 0547 81 DUP2 0548 FD *REVERT // Stack delta = +0 // Outputs[1] { @0548 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_0549: // Incoming jump from 0x0545, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @054A stack[-2] // @054B memory[stack[-2]:stack[-2] + 0x20] // } 0549 5B JUMPDEST 054A 81 DUP2 054B 51 MLOAD 054C 61 PUSH2 0x0531 054F 81 DUP2 0550 61 PUSH2 0x070b 0553 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @054B stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @054C stack[1] = 0x0531 // @054F stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x070b, returns to 0x0531 label_0554: // Incoming call from 0x013E, returns to 0x013F // Incoming call from 0x00ED, returns to 0x00EE // Inputs[2] // { // @055A stack[-1] // @055B stack[-2] // } 0554 5B JUMPDEST 0555 60 PUSH1 0x00 0557 80 DUP1 0558 60 PUSH1 0x40 055A 83 DUP4 055B 85 DUP6 055C 03 SUB 055D 12 SLT 055E 15 ISZERO 055F 61 PUSH2 0x0566 0562 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0555 stack[0] = 0x00 // @0557 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0566, if !(stack[-2] - stack[-1] i< 0x40) label_0563: // Incoming jump from 0x0562, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @0563 stack[-1] // @0565 memory[stack[-1]:stack[-1] + stack[-1]] // } 0563 80 DUP1 0564 81 DUP2 0565 FD *REVERT // Stack delta = +0 // Outputs[1] { @0565 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_0566: // Incoming jump from 0x0562, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @0567 stack[-3] // @0568 msg.data[stack[-3]:stack[-3] + 0x20] // } 0566 5B JUMPDEST 0567 82 DUP3 0568 35 CALLDATALOAD 0569 61 PUSH2 0x0571 056C 81 DUP2 056D 61 PUSH2 0x070b 0570 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0568 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @0569 stack[1] = 0x0571 // @056C stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x070b, returns to 0x0571 label_0571: // Incoming return from call to 0x070B at 0x0570 // Inputs[4] // { // @0572 stack[-3] // @0572 stack[-1] // @0576 stack[-4] // @0578 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 0571 5B JUMPDEST 0572 91 SWAP2 0573 50 POP 0574 60 PUSH1 0x20 0576 83 DUP4 0577 01 ADD 0578 35 CALLDATALOAD 0579 61 PUSH2 0x0581 057C 81 DUP2 057D 61 PUSH2 0x070b 0580 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0572 stack[-3] = stack[-1] // @0578 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @0579 stack[0] = 0x0581 // @057C stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x070b, returns to 0x0581 label_0581: // Incoming return from call to 0x070B at 0x0580 // Inputs[6] // { // @0582 stack[-1] // @0583 stack[-2] // @0586 stack[-5] // @0588 stack[-3] // @0588 stack[-6] // @0589 stack[-4] // } 0581 5B JUMPDEST 0582 80 DUP1 0583 91 SWAP2 0584 50 POP 0585 50 POP 0586 92 SWAP3 0587 50 POP 0588 92 SWAP3 0589 90 SWAP1 058A 50 POP 058B 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @0586 stack[-5] = stack[-1] // @0588 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_058C: // Incoming call from 0x011E, returns to 0x011F // Inputs[2] // { // @0594 stack[-1] // @0595 stack[-2] // } 058C 5B JUMPDEST 058D 60 PUSH1 0x00 058F 80 DUP1 0590 60 PUSH1 0x00 0592 60 PUSH1 0x60 0594 84 DUP5 0595 86 DUP7 0596 03 SUB 0597 12 SLT 0598 15 ISZERO 0599 61 PUSH2 0x05a0 059C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @058D stack[0] = 0x00 // @058F stack[1] = 0x00 // @0590 stack[2] = 0x00 // } // Block ends with conditional jump to 0x05a0, if !(stack[-2] - stack[-1] i< 0x60) label_059D: // Incoming jump from 0x059C, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @059D stack[-1] // @059F memory[stack[-1]:stack[-1] + stack[-1]] // } 059D 80 DUP1 059E 81 DUP2 059F FD *REVERT // Stack delta = +0 // Outputs[1] { @059F revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_05A0: // Incoming jump from 0x059C, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @05A1 stack[-4] // @05A2 msg.data[stack[-4]:stack[-4] + 0x20] // } 05A0 5B JUMPDEST 05A1 83 DUP4 05A2 35 CALLDATALOAD 05A3 61 PUSH2 0x05ab 05A6 81 DUP2 05A7 61 PUSH2 0x070b 05AA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @05A2 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @05A3 stack[1] = 0x05ab // @05A6 stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x070b, returns to 0x05AB label_05AB: // Incoming return from call to 0x070B at 0x05AA // Inputs[4] // { // @05AC stack[-4] // @05AC stack[-1] // @05B0 stack[-5] // @05B2 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 05AB 5B JUMPDEST 05AC 92 SWAP3 05AD 50 POP 05AE 60 PUSH1 0x20 05B0 84 DUP5 05B1 01 ADD 05B2 35 CALLDATALOAD 05B3 61 PUSH2 0x05bb 05B6 81 DUP2 05B7 61 PUSH2 0x070b 05BA 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @05AC stack[-4] = stack[-1] // @05B2 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @05B3 stack[0] = 0x05bb // @05B6 stack[1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x070b, returns to 0x05BB label_05BB: // Incoming return from call to 0x070B at 0x05BA // Inputs[4] // { // @05BC stack[-1] // @05BC stack[-3] // @05C0 stack[-5] // @05C2 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } 05BB 5B JUMPDEST 05BC 91 SWAP2 05BD 50 POP 05BE 60 PUSH1 0x40 05C0 84 DUP5 05C1 01 ADD 05C2 35 CALLDATALOAD 05C3 67 PUSH8 0xffffffffffffffff 05CC 80 DUP1 05CD 82 DUP3 05CE 11 GT 05CF 15 ISZERO 05D0 61 PUSH2 0x05d7 05D3 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @05BC stack[-3] = stack[-1] // @05C2 stack[-1] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @05C3 stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x05d7, if !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > 0xffffffffffffffff) label_05D4: // Incoming jump from 0x05D3, if not !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @05D4 stack[-3] // @05D6 memory[stack[-3]:stack[-3] + stack[-3]] // } 05D4 82 DUP3 05D5 83 DUP4 05D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @05D6 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_05D7: // Incoming jump from 0x05D3, if !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @05D8 stack[-2] // @05D9 stack[-6] // @05DD stack[-7] // } 05D7 5B JUMPDEST 05D8 81 DUP2 05D9 86 DUP7 05DA 01 ADD 05DB 91 SWAP2 05DC 50 POP 05DD 86 DUP7 05DE 60 PUSH1 0x1f 05E0 83 DUP4 05E1 01 ADD 05E2 12 SLT 05E3 61 PUSH2 0x05ea 05E6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @05DB stack[-2] = stack[-6] + stack[-2] } // Block ends with conditional jump to 0x05ea, if stack[-6] + stack[-2] + 0x1f i< stack[-7] label_05E7: // Incoming jump from 0x05E6, if not stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[2] // { // @05E7 stack[-3] // @05E9 memory[stack[-3]:stack[-3] + stack[-3]] // } 05E7 82 DUP3 05E8 83 DUP4 05E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @05E9 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_05EA: // Incoming jump from 0x05E6, if stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[3] // { // @05EB stack[-2] // @05EC msg.data[stack[-2]:stack[-2] + 0x20] // @05ED stack[-1] // } 05EA 5B JUMPDEST 05EB 81 DUP2 05EC 35 CALLDATALOAD 05ED 81 DUP2 05EE 81 DUP2 05EF 11 GT 05F0 15 ISZERO 05F1 61 PUSH2 0x05fc 05F4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05EC stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x05fc, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_05F5: // Incoming jump from 0x05F4, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) 05F5 61 PUSH2 0x05fc 05F8 61 PUSH2 0x06f5 05FB 56 *JUMP // Stack delta = +1 // Outputs[1] { @05F5 stack[0] = 0x05fc } // Block ends with unconditional jump to 0x06f5 label_05FC: // Incoming jump from 0x05F4, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @05FF memory[0x40:0x60] // @0602 stack[-1] // @0611 stack[-2] // } 05FC 5B JUMPDEST 05FD 60 PUSH1 0x40 05FF 51 MLOAD 0600 60 PUSH1 0x1f 0602 82 DUP3 0603 01 ADD 0604 60 PUSH1 0x1f 0606 19 NOT 0607 90 SWAP1 0608 81 DUP2 0609 16 AND 060A 60 PUSH1 0x3f 060C 01 ADD 060D 16 AND 060E 81 DUP2 060F 01 ADD 0610 90 SWAP1 0611 83 DUP4 0612 82 DUP3 0613 11 GT 0614 81 DUP2 0615 83 DUP4 0616 10 LT 0617 17 OR 0618 15 ISZERO 0619 61 PUSH2 0x0624 061C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0610 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) // @0610 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x0624, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) > stack[-2])) label_061D: // Incoming jump from 0x061C, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) > stack[-2])) 061D 61 PUSH2 0x0624 0620 61 PUSH2 0x06f5 0623 56 *JUMP // Stack delta = +1 // Outputs[1] { @061D stack[0] = 0x0624 } // Block ends with unconditional jump to 0x06f5 label_0624: // Incoming jump from 0x061C, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) > stack[-2])) // Inputs[5] // { // @0625 stack[-2] // @0629 stack[-3] // @062A stack[-1] // @062C stack[-10] // @0630 stack[-5] // } 0624 5B JUMPDEST 0625 81 DUP2 0626 60 PUSH1 0x40 0628 52 MSTORE 0629 82 DUP3 062A 81 DUP2 062B 52 MSTORE 062C 89 DUP10 062D 60 PUSH1 0x20 062F 84 DUP5 0630 87 DUP8 0631 01 ADD 0632 01 ADD 0633 11 GT 0634 15 ISZERO 0635 61 PUSH2 0x063c 0638 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0628 memory[0x40:0x60] = stack[-2] // @062B memory[stack[-1]:stack[-1] + 0x20] = stack[-3] // } // Block ends with conditional jump to 0x063c, if !(stack[-5] + stack[-3] + 0x20 > stack[-10]) label_0639: // Incoming jump from 0x0638, if not !(stack[-5] + stack[-3] + 0x20 > stack[-10]) // Inputs[2] // { // @0639 stack[-6] // @063B memory[stack[-6]:stack[-6] + stack[-6]] // } 0639 85 DUP6 063A 86 DUP7 063B FD *REVERT // Stack delta = +0 // Outputs[1] { @063B revert(memory[stack[-6]:stack[-6] + stack[-6]]); } // Block terminates label_063C: // Incoming jump from 0x0638, if !(stack[-5] + stack[-3] + 0x20 > stack[-10]) // Inputs[10] // { // @063D stack[-3] // @0640 stack[-5] // @0644 stack[-1] // @0646 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + stack[-3]] // @0647 stack[-6] // @0657 stack[-9] // @0659 stack[-10] // @0659 stack[-7] // @065B stack[-11] // @065B stack[-8] // } 063C 5B JUMPDEST 063D 82 DUP3 063E 60 PUSH1 0x20 0640 86 DUP7 0641 01 ADD 0642 60 PUSH1 0x20 0644 83 DUP4 0645 01 ADD 0646 37 CALLDATACOPY 0647 85 DUP6 0648 60 PUSH1 0x20 064A 84 DUP5 064B 83 DUP4 064C 01 ADD 064D 01 ADD 064E 52 MSTORE 064F 80 DUP1 0650 95 SWAP6 0651 50 POP 0652 50 POP 0653 50 POP 0654 50 POP 0655 50 POP 0656 50 POP 0657 92 SWAP3 0658 50 POP 0659 92 SWAP3 065A 50 POP 065B 92 SWAP3 065C 56 *JUMP // Stack delta = -8 // Outputs[5] // { // @0646 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-3]] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + stack[-3]] // @064E memory[stack[-1] + stack[-3] + 0x20:stack[-1] + stack[-3] + 0x20 + 0x20] = stack[-6] // @0657 stack[-9] = stack[-1] // @0659 stack[-10] = stack[-7] // @065B stack[-11] = stack[-8] // } // Block ends with unconditional jump to stack[-11] label_065D: // Incoming call from 0x0375, returns to 0x0376 // Inputs[4] // { // @0667 stack[-3] // @0669 stack[-1] // @0673 stack[-2] // @0674 memory[stack[-2]:stack[-2] + 0x20] // } 065D 5B JUMPDEST 065E 60 PUSH1 0x00 0660 60 PUSH1 0x01 0662 80 DUP1 0663 60 PUSH1 0xa0 0665 1B SHL 0666 03 SUB 0667 84 DUP5 0668 16 AND 0669 82 DUP3 066A 52 MSTORE 066B 60 PUSH1 0x20 066D 60 PUSH1 0x40 066F 81 DUP2 0670 84 DUP5 0671 01 ADD 0672 52 MSTORE 0673 83 DUP4 0674 51 MLOAD 0675 80 DUP1 0676 60 PUSH1 0x40 0678 85 DUP6 0679 01 ADD 067A 52 MSTORE 067B 82 DUP3 067C 5B JUMPDEST 067D 81 DUP2 067E 81 DUP2 067F 10 LT 0680 15 ISZERO 0681 61 PUSH2 0x0698 0684 57 *JUMPI // Stack delta = +4 // Outputs[7] // { // @065E stack[0] = 0x00 // @066A memory[stack[-1]:stack[-1] + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @066B stack[1] = 0x20 // @0672 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x40 // @0674 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // @067A memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @067B stack[3] = 0x00 // } // Block ends with conditional jump to 0x0698, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_0685: // Incoming jump from 0x0684, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x0684, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[5] // { // @0685 stack[-6] // @0686 stack[-1] // @0688 stack[-3] // @068A memory[stack[-3] + stack[-1] + stack[-6]:stack[-3] + stack[-1] + stack[-6] + 0x20] // @068B stack[-5] // } 0685 85 DUP6 0686 81 DUP2 0687 01 ADD 0688 83 DUP4 0689 01 ADD 068A 51 MLOAD 068B 85 DUP6 068C 82 DUP3 068D 01 ADD 068E 60 PUSH1 0x60 0690 01 ADD 0691 52 MSTORE 0692 82 DUP3 0693 01 ADD 0694 61 PUSH2 0x067c 0697 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0691 memory[0x60 + stack[-1] + stack[-5]:0x60 + stack[-1] + stack[-5] + 0x20] = memory[stack[-3] + stack[-1] + stack[-6]:stack[-3] + stack[-1] + stack[-6] + 0x20] // @0693 stack[-1] = stack[-3] + stack[-1] // } // Block ends with unconditional jump to 0x067c label_0698: // Incoming jump from 0x0684, if !(stack[-1] < stack[-2]) // Incoming jump from 0x0684, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[2] // { // @0699 stack[-2] // @069A stack[-1] // } 0698 5B JUMPDEST 0699 81 DUP2 069A 81 DUP2 069B 11 GT 069C 15 ISZERO 069D 61 PUSH2 0x06a9 06A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06a9, if !(stack[-1] > stack[-2]) label_06A1: // Incoming jump from 0x06A0, if not !(stack[-1] > stack[-2]) // Inputs[6] // { // @06A1 stack[-4] // @06A4 stack[-2] // @06A5 stack[-5] // @06B3 stack[-3] // @06B9 stack[-8] // @06BA stack[-7] // } 06A1 83 DUP4 06A2 60 PUSH1 0x60 06A4 83 DUP4 06A5 87 DUP8 06A6 01 ADD 06A7 01 ADD 06A8 52 MSTORE 06A9 5B JUMPDEST 06AA 50 POP 06AB 60 PUSH1 0x1f 06AD 01 ADD 06AE 60 PUSH1 0x1f 06B0 19 NOT 06B1 16 AND 06B2 92 SWAP3 06B3 90 SWAP1 06B4 92 SWAP3 06B5 01 ADD 06B6 60 PUSH1 0x60 06B8 01 ADD 06B9 94 SWAP5 06BA 93 SWAP4 06BB 50 POP 06BC 50 POP 06BD 50 POP 06BE 50 POP 06BF 56 *JUMP // Stack delta = -7 // Outputs[2] // { // @06A8 memory[stack[-5] + stack[-2] + 0x60:stack[-5] + stack[-2] + 0x60 + 0x20] = stack[-4] // @06B9 stack[-8] = 0x60 + (~0x1f & 0x1f + stack[-2]) + stack[-5] // } // Block ends with unconditional jump to stack[-8] label_06C0: // Incoming call from 0x023E, returns to 0x023F // Incoming call from 0x03D6, returns to 0x023F // Incoming call from 0x02BB, returns to 0x023F // Incoming call from 0x042E, returns to 0x023F // Incoming call from 0x0345, returns to 0x023F // Inputs[2] // { // @06C4 stack[-1] // @06F3 stack[-2] // } 06C0 5B JUMPDEST 06C1 60 PUSH1 0x20 06C3 80 DUP1 06C4 82 DUP3 06C5 52 MSTORE 06C6 81 DUP2 06C7 81 DUP2 06C8 01 ADD 06C9 52 MSTORE 06CA 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 06EB 60 PUSH1 0x40 06ED 82 DUP3 06EE 01 ADD 06EF 52 MSTORE 06F0 60 PUSH1 0x60 06F2 01 ADD 06F3 90 SWAP1 06F4 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @06C5 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @06C9 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @06EF memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @06F3 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_06F5: // Incoming jump from 0x0623 // Incoming jump from 0x05FB // Inputs[1] { @070A memory[0x00:0x24] } 06F5 5B JUMPDEST 06F6 63 PUSH4 0x4e487b71 06FB 60 PUSH1 0xe0 06FD 1B SHL 06FE 60 PUSH1 0x00 0700 52 MSTORE 0701 60 PUSH1 0x41 0703 60 PUSH1 0x04 0705 52 MSTORE 0706 60 PUSH1 0x24 0708 60 PUSH1 0x00 070A FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0700 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0705 memory[0x04:0x24] = 0x41 // @070A revert(memory[0x00:0x24]); // } // Block terminates label_070B: // Incoming call from 0x05BA, returns to 0x05BB // Incoming call from 0x05AA, returns to 0x05AB // Incoming call from 0x0570, returns to 0x0571 // Incoming call from 0x0530, returns to 0x0531 // Incoming call from 0x0580, returns to 0x0581 // Incoming call from 0x0553, returns to 0x0531 // Inputs[1] { @0714 stack[-1] } 070B 5B JUMPDEST 070C 60 PUSH1 0x01 070E 60 PUSH1 0x01 0710 60 PUSH1 0xa0 0712 1B SHL 0713 03 SUB 0714 81 DUP2 0715 16 AND 0716 81 DUP2 0717 14 EQ 0718 61 PUSH2 0x0720 071B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0720, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 label_071C: // Incoming jump from 0x071B, if not stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @071F memory[0x00:0x00] } 071C 60 PUSH1 0x00 071E 80 DUP1 071F FD *REVERT // Stack delta = +0 // Outputs[1] { @071F revert(memory[0x00:0x00]); } // Block terminates label_0720: // Incoming jump from 0x071B, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0722 stack[-2] } 0720 5B JUMPDEST 0721 50 POP 0722 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 0723 FE *ASSERT 0724 A2 LOG2 0725 64 PUSH5 0x6970667358 072B 22 22 072C 12 SLT 072D 20 SHA3 072E D8 D8 072F 49 49 0730 F9 F9 0731 6F PUSH16 0x3086b9f82cdcf665adb8c697ace05638 0742 DA DA 0743 1C SHR 0744 7C PUSH29 0x16ab2d26293717af6764736f6c63430008020033