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 0x004e 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x004e, 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 0x3659cfe6 0019 14 EQ 001A 61 PUSH2 0x0065 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0065, if 0x3659cfe6 == msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x3659cfe6 == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0x4f1ef286 0024 14 EQ 0025 61 PUSH2 0x0085 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0085, if 0x4f1ef286 == stack[-1] label_0029: // Incoming jump from 0x0028, if not 0x4f1ef286 == stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0x5c60da1b 002F 14 EQ 0030 61 PUSH2 0x0098 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0098, if 0x5c60da1b == stack[-1] label_0034: // Incoming jump from 0x0033, if not 0x5c60da1b == stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0x8f283970 003A 14 EQ 003B 61 PUSH2 0x00c9 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c9, if 0x8f283970 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0x8f283970 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xf851a440 0045 14 EQ 0046 61 PUSH2 0x00e9 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00e9, if 0xf851a440 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xf851a440 == stack[-1] 004A 61 PUSH2 0x005d 004D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x005d label_004E: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @004F msg.data.length } 004E 5B JUMPDEST 004F 36 CALLDATASIZE 0050 61 PUSH2 0x005d 0053 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x005d, if msg.data.length label_0054: // Incoming jump from 0x0053, if not msg.data.length 0054 61 PUSH2 0x005b 0057 61 PUSH2 0x00fe 005A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0054 stack[0] = 0x005b } // Block ends with unconditional jump to 0x00fe label_005B: // Incoming return from call to 0x00E4 at 0x00E3 005B 5B JUMPDEST 005C 00 *STOP // Stack delta = +0 // Outputs[1] { @005C stop(); } // Block terminates label_005D: // Incoming jump from 0x004D // Incoming jump from 0x0053, if msg.data.length 005D 5B JUMPDEST 005E 61 PUSH2 0x005b 0061 61 PUSH2 0x00fe 0064 56 *JUMP // Stack delta = +1 // Outputs[1] { @005E stack[0] = 0x005b } // Block ends with unconditional jump to 0x00fe label_0065: // Incoming jump from 0x001D, if 0x3659cfe6 == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0066 msg.value } 0065 5B JUMPDEST 0066 34 CALLVALUE 0067 80 DUP1 0068 15 ISZERO 0069 61 PUSH2 0x0071 006C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0066 stack[0] = msg.value } // Block ends with conditional jump to 0x0071, if !msg.value label_006D: // Incoming jump from 0x006C, if not !msg.value // Inputs[1] { @0070 memory[0x00:0x00] } 006D 60 PUSH1 0x00 006F 80 DUP1 0070 FD *REVERT // Stack delta = +0 // Outputs[1] { @0070 revert(memory[0x00:0x00]); } // Block terminates label_0071: // Incoming jump from 0x006C, if !msg.value // Inputs[1] { @0079 msg.data.length } 0071 5B JUMPDEST 0072 50 POP 0073 61 PUSH2 0x005b 0076 61 PUSH2 0x0080 0079 36 CALLDATASIZE 007A 60 PUSH1 0x04 007C 61 PUSH2 0x0702 007F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0073 stack[-1] = 0x005b // @0076 stack[0] = 0x0080 // @0079 stack[1] = msg.data.length // @007A stack[2] = 0x04 // } // Block ends with call to 0x0702, returns to 0x0080 label_0080: // Incoming return from call to 0x0702 at 0x007F 0080 5B JUMPDEST 0081 61 PUSH2 0x0118 0084 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0118 label_0085: // Incoming jump from 0x0028, if 0x4f1ef286 == stack[-1] // Inputs[1] { @008C msg.data.length } 0085 5B JUMPDEST 0086 61 PUSH2 0x005b 0089 61 PUSH2 0x0093 008C 36 CALLDATASIZE 008D 60 PUSH1 0x04 008F 61 PUSH2 0x071c 0092 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0086 stack[0] = 0x005b // @0089 stack[1] = 0x0093 // @008C stack[2] = msg.data.length // @008D stack[3] = 0x04 // } // Block ends with call to 0x071c, returns to 0x0093 label_0093: // Incoming return from call to 0x071C at 0x0092 0093 5B JUMPDEST 0094 61 PUSH2 0x0164 0097 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0164 label_0098: // Incoming jump from 0x0033, if 0x5c60da1b == stack[-1] // Inputs[1] { @0099 msg.value } 0098 5B JUMPDEST 0099 34 CALLVALUE 009A 80 DUP1 009B 15 ISZERO 009C 61 PUSH2 0x00a4 009F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0099 stack[0] = msg.value } // Block ends with conditional jump to 0x00a4, if !msg.value label_00A0: // Incoming jump from 0x009F, if not !msg.value // Inputs[1] { @00A3 memory[0x00:0x00] } 00A0 60 PUSH1 0x00 00A2 80 DUP1 00A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @00A3 revert(memory[0x00:0x00]); } // Block terminates label_00A4: // Incoming jump from 0x009F, if !msg.value 00A4 5B JUMPDEST 00A5 50 POP 00A6 61 PUSH2 0x00ad 00A9 61 PUSH2 0x01da 00AC 56 *JUMP // Stack delta = +0 // Outputs[1] { @00A6 stack[-1] = 0x00ad } // Block ends with unconditional jump to 0x01da label_00AD: // Incoming return from call to 0x0241 at 0x00FD // Inputs[4] // { // @00B0 memory[0x40:0x60] // @00BA stack[-1] // @00C3 memory[0x40:0x60] // @00C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 00AD 5B JUMPDEST 00AE 60 PUSH1 0x40 00B0 51 MLOAD 00B1 60 PUSH1 0x01 00B3 60 PUSH1 0x01 00B5 60 PUSH1 0xa0 00B7 1B SHL 00B8 03 SUB 00B9 90 SWAP1 00BA 91 SWAP2 00BB 16 AND 00BC 81 DUP2 00BD 52 MSTORE 00BE 60 PUSH1 0x20 00C0 01 ADD 00C1 60 PUSH1 0x40 00C3 51 MLOAD 00C4 80 DUP1 00C5 91 SWAP2 00C6 03 SUB 00C7 90 SWAP1 00C8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @00BD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @00C8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_00C9: // Incoming jump from 0x003E, if 0x8f283970 == stack[-1] // Inputs[1] { @00CA msg.value } 00C9 5B JUMPDEST 00CA 34 CALLVALUE 00CB 80 DUP1 00CC 15 ISZERO 00CD 61 PUSH2 0x00d5 00D0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00CA stack[0] = msg.value } // Block ends with conditional jump to 0x00d5, if !msg.value label_00D1: // Incoming jump from 0x00D0, if not !msg.value // Inputs[1] { @00D4 memory[0x00:0x00] } 00D1 60 PUSH1 0x00 00D3 80 DUP1 00D4 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D4 revert(memory[0x00:0x00]); } // Block terminates label_00D5: // Incoming jump from 0x00D0, if !msg.value // Inputs[1] { @00DD msg.data.length } 00D5 5B JUMPDEST 00D6 50 POP 00D7 61 PUSH2 0x005b 00DA 61 PUSH2 0x00e4 00DD 36 CALLDATASIZE 00DE 60 PUSH1 0x04 00E0 61 PUSH2 0x0702 00E3 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @00D7 stack[-1] = 0x005b // @00DA stack[0] = 0x00e4 // @00DD stack[1] = msg.data.length // @00DE stack[2] = 0x04 // } // Block ends with call to 0x0702, returns to 0x00E4 label_00E4: // Incoming return from call to 0x0702 at 0x00E3 00E4 5B JUMPDEST 00E5 61 PUSH2 0x0217 00E8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0217 label_00E9: // Incoming jump from 0x0049, if 0xf851a440 == stack[-1] // Inputs[1] { @00EA msg.value } 00E9 5B JUMPDEST 00EA 34 CALLVALUE 00EB 80 DUP1 00EC 15 ISZERO 00ED 61 PUSH2 0x00f5 00F0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00EA stack[0] = msg.value } // Block ends with conditional jump to 0x00f5, if !msg.value label_00F1: // Incoming jump from 0x00F0, if not !msg.value // Inputs[1] { @00F4 memory[0x00:0x00] } 00F1 60 PUSH1 0x00 00F3 80 DUP1 00F4 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F4 revert(memory[0x00:0x00]); } // Block terminates label_00F5: // Incoming jump from 0x00F0, if !msg.value 00F5 5B JUMPDEST 00F6 50 POP 00F7 61 PUSH2 0x00ad 00FA 61 PUSH2 0x0241 00FD 56 *JUMP // Stack delta = +0 // Outputs[1] { @00F7 stack[-1] = 0x00ad } // Block ends with call to 0x0241, returns to 0x00AD label_00FE: // Incoming jump from 0x0064 // Incoming jump from 0x0160 // Incoming jump from 0x005A // Incoming jump from 0x01D4 // Incoming jump from 0x0213 00FE 5B JUMPDEST 00FF 61 PUSH2 0x0106 0102 61 PUSH2 0x02ab 0105 56 *JUMP // Stack delta = +1 // Outputs[1] { @00FF stack[0] = 0x0106 } // Block ends with call to 0x02ab, returns to 0x0106 label_0106: // Incoming return from call to 0x02AB at 0x0105 0106 5B JUMPDEST 0107 61 PUSH2 0x0116 010A 61 PUSH2 0x0111 010D 61 PUSH2 0x034f 0110 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0107 stack[0] = 0x0116 // @010A stack[1] = 0x0111 // } // Block ends with call to 0x034f, returns to 0x0111 label_0111: // Incoming return from call to 0x034F at 0x0110 0111 5B JUMPDEST 0112 61 PUSH2 0x035e 0115 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x035e label_0116: // Incoming jump from 0x034E // Inputs[1] { @0117 stack[-1] } 0116 5B JUMPDEST 0117 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0118: // Incoming jump from 0x0084 0118 5B JUMPDEST 0119 61 PUSH2 0x0120 011C 61 PUSH2 0x0382 011F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0119 stack[0] = 0x0120 } // Block ends with call to 0x0382, returns to 0x0120 label_0120: // Incoming return from call to 0x0382 at 0x011F // Inputs[2] // { // @0129 stack[-1] // @012A msg.sender // } 0120 5B JUMPDEST 0121 60 PUSH1 0x01 0123 60 PUSH1 0x01 0125 60 PUSH1 0xa0 0127 1B SHL 0128 03 SUB 0129 16 AND 012A 33 CALLER 012B 60 PUSH1 0x01 012D 60 PUSH1 0x01 012F 60 PUSH1 0xa0 0131 1B SHL 0132 03 SUB 0133 16 AND 0134 14 EQ 0135 15 ISZERO 0136 61 PUSH2 0x0159 0139 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0159, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) label_013A: // Incoming jump from 0x0139, if not !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @013D stack[-1] // @0140 memory[0x40:0x60] // } 013A 61 PUSH2 0x0154 013D 81 DUP2 013E 60 PUSH1 0x40 0140 51 MLOAD 0141 80 DUP1 0142 60 PUSH1 0x20 0144 01 ADD 0145 60 PUSH1 0x40 0147 52 MSTORE 0148 80 DUP1 0149 60 PUSH1 0x00 014B 81 DUP2 014C 52 MSTORE 014D 50 POP 014E 60 PUSH1 0x00 0150 61 PUSH2 0x03b5 0153 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @013A stack[0] = 0x0154 // @013D stack[1] = stack[-1] // @0140 stack[2] = memory[0x40:0x60] // @0147 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @014C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @014E stack[3] = 0x00 // } // Block ends with unconditional jump to 0x03b5 label_0154: // Incoming return from call to 0x03E0 at 0x0240 0154 5B JUMPDEST 0155 61 PUSH2 0x0161 0158 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0161 label_0159: // Incoming jump from 0x0238, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) // Incoming jump from 0x0139, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) 0159 5B JUMPDEST 015A 61 PUSH2 0x0161 015D 61 PUSH2 0x00fe 0160 56 *JUMP // Stack delta = +1 // Outputs[1] { @015A stack[0] = 0x0161 } // Block ends with unconditional jump to 0x00fe label_0161: // Incoming jump from 0x0158 // Incoming return from call to 0x0577 at 0x0433 // Inputs[1] { @0163 stack[-2] } 0161 5B JUMPDEST 0162 50 POP 0163 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0164: // Incoming jump from 0x0097 0164 5B JUMPDEST 0165 61 PUSH2 0x016c 0168 61 PUSH2 0x0382 016B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0165 stack[0] = 0x016c } // Block ends with call to 0x0382, returns to 0x016C label_016C: // Incoming return from call to 0x0382 at 0x016B // Inputs[2] // { // @0175 stack[-1] // @0176 msg.sender // } 016C 5B JUMPDEST 016D 60 PUSH1 0x01 016F 60 PUSH1 0x01 0171 60 PUSH1 0xa0 0173 1B SHL 0174 03 SUB 0175 16 AND 0176 33 CALLER 0177 60 PUSH1 0x01 0179 60 PUSH1 0x01 017B 60 PUSH1 0xa0 017D 1B SHL 017E 03 SUB 017F 16 AND 0180 14 EQ 0181 15 ISZERO 0182 61 PUSH2 0x01cd 0185 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01cd, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0186: // Incoming jump from 0x0185, if not !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[5] // { // @0189 stack[-3] // @018A stack[-2] // @018B stack[-1] // @019C memory[0x40:0x60] // @01B3 msg.data[stack[-2]:stack[-2] + stack[-1]] // } 0186 61 PUSH2 0x01c8 0189 83 DUP4 018A 83 DUP4 018B 83 DUP4 018C 80 DUP1 018D 80 DUP1 018E 60 PUSH1 0x1f 0190 01 ADD 0191 60 PUSH1 0x20 0193 80 DUP1 0194 91 SWAP2 0195 04 DIV 0196 02 MUL 0197 60 PUSH1 0x20 0199 01 ADD 019A 60 PUSH1 0x40 019C 51 MLOAD 019D 90 SWAP1 019E 81 DUP2 019F 01 ADD 01A0 60 PUSH1 0x40 01A2 52 MSTORE 01A3 80 DUP1 01A4 93 SWAP4 01A5 92 SWAP3 01A6 91 SWAP2 01A7 90 SWAP1 01A8 81 DUP2 01A9 81 DUP2 01AA 52 MSTORE 01AB 60 PUSH1 0x20 01AD 01 ADD 01AE 83 DUP4 01AF 83 DUP4 01B0 80 DUP1 01B1 82 DUP3 01B2 84 DUP5 01B3 37 CALLDATACOPY 01B4 60 PUSH1 0x00 01B6 92 SWAP3 01B7 01 ADD 01B8 91 SWAP2 01B9 90 SWAP1 01BA 91 SWAP2 01BB 52 MSTORE 01BC 50 POP 01BD 60 PUSH1 0x01 01BF 92 SWAP3 01C0 50 POP 01C1 61 PUSH2 0x03b5 01C4 91 SWAP2 01C5 50 POP 01C6 50 POP 01C7 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @0186 stack[0] = 0x01c8 // @0189 stack[1] = stack[-3] // @01A2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @01A4 stack[2] = memory[0x40:0x60] // @01AA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @01B3 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]] // @01BB memory[0x20 + memory[0x40:0x60] + stack[-1]:0x20 + memory[0x40:0x60] + stack[-1] + 0x20] = 0x00 // @01BF stack[3] = 0x01 // } // Block ends with unconditional jump to 0x03b5 01C8 5B JUMPDEST 01C9 61 PUSH2 0x01d5 01CC 56 *JUMP label_01CD: // Incoming jump from 0x0185, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) 01CD 5B JUMPDEST 01CE 61 PUSH2 0x01d5 01D1 61 PUSH2 0x00fe 01D4 56 *JUMP // Stack delta = +1 // Outputs[1] { @01CE stack[0] = 0x01d5 } // Block ends with unconditional jump to 0x00fe 01D5 5B JUMPDEST 01D6 50 POP 01D7 50 POP 01D8 50 POP 01D9 56 *JUMP label_01DA: // Incoming jump from 0x00AC 01DA 5B JUMPDEST 01DB 60 PUSH1 0x00 01DD 61 PUSH2 0x01e4 01E0 61 PUSH2 0x0382 01E3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @01DB stack[0] = 0x00 // @01DD stack[1] = 0x01e4 // } // Block ends with call to 0x0382, returns to 0x01E4 label_01E4: // Incoming return from call to 0x0382 at 0x01E3 // Inputs[2] // { // @01ED stack[-1] // @01EE msg.sender // } 01E4 5B JUMPDEST 01E5 60 PUSH1 0x01 01E7 60 PUSH1 0x01 01E9 60 PUSH1 0xa0 01EB 1B SHL 01EC 03 SUB 01ED 16 AND 01EE 33 CALLER 01EF 60 PUSH1 0x01 01F1 60 PUSH1 0x01 01F3 60 PUSH1 0xa0 01F5 1B SHL 01F6 03 SUB 01F7 16 AND 01F8 14 EQ 01F9 15 ISZERO 01FA 61 PUSH2 0x020c 01FD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x020c, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) label_01FE: // Incoming jump from 0x01FD, if not !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) 01FE 61 PUSH2 0x0205 0201 61 PUSH2 0x034f 0204 56 *JUMP // Stack delta = +1 // Outputs[1] { @01FE stack[0] = 0x0205 } // Block ends with call to 0x034f, returns to 0x0205 label_0205: // Incoming return from call to 0x034F at 0x0204 // Incoming return from call to 0x0382 at 0x026B // Inputs[2] // { // @0206 stack[-2] // @0206 stack[-1] // } 0205 5B JUMPDEST 0206 90 SWAP1 0207 50 POP 0208 61 PUSH2 0x0214 020B 56 *JUMP // Stack delta = -1 // Outputs[1] { @0206 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x0214 label_020C: // Incoming jump from 0x01FD, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) // Incoming jump from 0x0264, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) 020C 5B JUMPDEST 020D 61 PUSH2 0x0214 0210 61 PUSH2 0x00fe 0213 56 *JUMP // Stack delta = +1 // Outputs[1] { @020D stack[0] = 0x0214 } // Block ends with unconditional jump to 0x00fe label_0214: // Incoming jump from 0x020B // Inputs[2] // { // @0215 stack[-2] // @0215 stack[-1] // } 0214 5B JUMPDEST 0215 90 SWAP1 0216 56 *JUMP // Stack delta = -1 // Outputs[1] { @0215 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0217: // Incoming jump from 0x00E8 0217 5B JUMPDEST 0218 61 PUSH2 0x021f 021B 61 PUSH2 0x0382 021E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0218 stack[0] = 0x021f } // Block ends with call to 0x0382, returns to 0x021F label_021F: // Incoming return from call to 0x0382 at 0x021E // Inputs[2] // { // @0228 stack[-1] // @0229 msg.sender // } 021F 5B JUMPDEST 0220 60 PUSH1 0x01 0222 60 PUSH1 0x01 0224 60 PUSH1 0xa0 0226 1B SHL 0227 03 SUB 0228 16 AND 0229 33 CALLER 022A 60 PUSH1 0x01 022C 60 PUSH1 0x01 022E 60 PUSH1 0xa0 0230 1B SHL 0231 03 SUB 0232 16 AND 0233 14 EQ 0234 15 ISZERO 0235 61 PUSH2 0x0159 0238 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0159, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0239: // Incoming jump from 0x0238, if not !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @023C stack[-1] } 0239 61 PUSH2 0x0154 023C 81 DUP2 023D 61 PUSH2 0x03e0 0240 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0239 stack[0] = 0x0154 // @023C stack[1] = stack[-1] // } // Block ends with call to 0x03e0, returns to 0x0154 label_0241: // Incoming call from 0x00FD, returns to 0x00AD 0241 5B JUMPDEST 0242 60 PUSH1 0x00 0244 61 PUSH2 0x024b 0247 61 PUSH2 0x0382 024A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0242 stack[0] = 0x00 // @0244 stack[1] = 0x024b // } // Block ends with call to 0x0382, returns to 0x024B label_024B: // Incoming return from call to 0x0382 at 0x024A // Inputs[2] // { // @0254 stack[-1] // @0255 msg.sender // } 024B 5B JUMPDEST 024C 60 PUSH1 0x01 024E 60 PUSH1 0x01 0250 60 PUSH1 0xa0 0252 1B SHL 0253 03 SUB 0254 16 AND 0255 33 CALLER 0256 60 PUSH1 0x01 0258 60 PUSH1 0x01 025A 60 PUSH1 0xa0 025C 1B SHL 025D 03 SUB 025E 16 AND 025F 14 EQ 0260 15 ISZERO 0261 61 PUSH2 0x020c 0264 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x020c, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0265: // Incoming jump from 0x0264, if not !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) 0265 61 PUSH2 0x0205 0268 61 PUSH2 0x0382 026B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0265 stack[0] = 0x0205 } // Block ends with call to 0x0382, returns to 0x0205 026C 5B JUMPDEST 026D 60 PUSH1 0x60 026F 61 PUSH2 0x0291 0272 83 DUP4 0273 83 DUP4 0274 60 PUSH1 0x40 0276 51 MLOAD 0277 80 DUP1 0278 60 PUSH1 0x60 027A 01 ADD 027B 60 PUSH1 0x40 027D 52 MSTORE 027E 80 DUP1 027F 60 PUSH1 0x27 0281 81 DUP2 0282 52 MSTORE 0283 60 PUSH1 0x20 0285 01 ADD 0286 61 PUSH2 0x0816 0289 60 PUSH1 0x27 028B 91 SWAP2 028C 39 CODECOPY 028D 61 PUSH2 0x0434 0290 56 *JUMP label_0291: // Incoming return from call to 0x06EB at 0x071B // Inputs[3] // { // @0292 stack[-1] // @0292 stack[-5] // @0293 stack[-4] // } 0291 5B JUMPDEST 0292 93 SWAP4 0293 92 SWAP3 0294 50 POP 0295 50 POP 0296 50 POP 0297 56 *JUMP // Stack delta = -4 // Outputs[1] { @0292 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0298: // Incoming jump from 0x0661 // Inputs[2] // { // @02A1 stack[-1] // @02A3 address(stack[-1] & (0x01 << 0xa0) - 0x01).code.length // } 0298 5B JUMPDEST 0299 60 PUSH1 0x01 029B 60 PUSH1 0x01 029D 60 PUSH1 0xa0 029F 1B SHL 02A0 03 SUB 02A1 81 DUP2 02A2 16 AND 02A3 3B EXTCODESIZE 02A4 15 ISZERO 02A5 15 ISZERO // Stack delta = +1 // Outputs[1] { @02A5 stack[0] = !!address(stack[-1] & (0x01 << 0xa0) - 0x01).code.length } // Block continues label_02A6: // Incoming jump from 0x02A5 // Incoming jump from 0x06FD, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @02A7 stack[-3] // @02A7 stack[-1] // @02A8 stack[-2] // } 02A6 5B JUMPDEST 02A7 91 SWAP2 02A8 90 SWAP1 02A9 50 POP 02AA 56 *JUMP // Stack delta = -2 // Outputs[1] { @02A7 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_02AB: // Incoming call from 0x0105, returns to 0x0106 02AB 5B JUMPDEST 02AC 61 PUSH2 0x02b3 02AF 61 PUSH2 0x0382 02B2 56 *JUMP // Stack delta = +1 // Outputs[1] { @02AC stack[0] = 0x02b3 } // Block ends with call to 0x0382, returns to 0x02B3 label_02B3: // Incoming return from call to 0x0382 at 0x02B2 // Inputs[2] // { // @02BC stack[-1] // @02BD msg.sender // } 02B3 5B JUMPDEST 02B4 60 PUSH1 0x01 02B6 60 PUSH1 0x01 02B8 60 PUSH1 0xa0 02BA 1B SHL 02BB 03 SUB 02BC 16 AND 02BD 33 CALLER 02BE 60 PUSH1 0x01 02C0 60 PUSH1 0x01 02C2 60 PUSH1 0xa0 02C4 1B SHL 02C5 03 SUB 02C6 16 AND 02C7 14 EQ 02C8 15 ISZERO 02C9 61 PUSH2 0x034a 02CC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x034a, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) label_02CD: // Incoming jump from 0x02CC, if not !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @02CF memory[0x40:0x60] // @0344 memory[0x40:0x60] // @0349 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02CD 60 PUSH1 0x40 02CF 51 MLOAD 02D0 62 PUSH3 0x461bcd 02D4 60 PUSH1 0xe5 02D6 1B SHL 02D7 81 DUP2 02D8 52 MSTORE 02D9 60 PUSH1 0x20 02DB 60 PUSH1 0x04 02DD 82 DUP3 02DE 01 ADD 02DF 52 MSTORE 02E0 60 PUSH1 0x42 02E2 60 PUSH1 0x24 02E4 82 DUP3 02E5 01 ADD 02E6 52 MSTORE 02E7 7F PUSH32 0x5472616e73706172656e745570677261646561626c6550726f78793a2061646d 0308 60 PUSH1 0x44 030A 82 DUP3 030B 01 ADD 030C 52 MSTORE 030D 7F PUSH32 0x696e2063616e6e6f742066616c6c6261636b20746f2070726f78792074617267 032E 60 PUSH1 0x64 0330 82 DUP3 0331 01 ADD 0332 52 MSTORE 0333 61 PUSH2 0x195d 0336 60 PUSH1 0xf2 0338 1B SHL 0339 60 PUSH1 0x84 033B 82 DUP3 033C 01 ADD 033D 52 MSTORE 033E 60 PUSH1 0xa4 0340 01 ADD 0341 5B JUMPDEST 0342 60 PUSH1 0x40 0344 51 MLOAD 0345 80 DUP1 0346 91 SWAP2 0347 03 SUB 0348 90 SWAP1 0349 FD *REVERT // Stack delta = +0 // Outputs[7] // { // @02D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @02DF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @02E6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x42 // @030C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5472616e73706172656e745570677261646561626c6550726f78793a2061646d // @0332 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x696e2063616e6e6f742066616c6c6261636b20746f2070726f78792074617267 // @033D memory[memory[0x40:0x60] + 0x84:memory[0x40:0x60] + 0x84 + 0x20] = 0x195d << 0xf2 // @0349 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_034A: // Incoming jump from 0x02CC, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) 034A 5B JUMPDEST 034B 61 PUSH2 0x0116 034E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0116 label_034F: // Incoming call from 0x0204, returns to 0x0205 // Incoming call from 0x0110, returns to 0x0111 034F 5B JUMPDEST 0350 60 PUSH1 0x00 0352 61 PUSH2 0x0359 0355 61 PUSH2 0x050f 0358 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0350 stack[0] = 0x00 // @0352 stack[1] = 0x0359 // } // Block ends with call to 0x050f, returns to 0x0359 label_0359: // Incoming return from call to 0x050F at 0x0358 // Inputs[3] // { // @035A stack[-1] // @035A stack[-2] // @035C stack[-3] // } 0359 5B JUMPDEST 035A 90 SWAP1 035B 50 POP 035C 90 SWAP1 035D 56 *JUMP // Stack delta = -2 // Outputs[1] { @035C stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_035E: // Incoming jump from 0x0115 // Inputs[9] // { // @035F msg.data.length // @0363 msg.data[0x00:0x00 + msg.data.length] // @0367 msg.data.length // @036A stack[-1] // @036B msg.gas // @036C address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @036C memory[0x00:0x00 + msg.data.length] // @036D returndata.length // @0371 returndata[0x00:0x00 + returndata.length] // } 035E 5B JUMPDEST 035F 36 CALLDATASIZE 0360 60 PUSH1 0x00 0362 80 DUP1 0363 37 CALLDATACOPY 0364 60 PUSH1 0x00 0366 80 DUP1 0367 36 CALLDATASIZE 0368 60 PUSH1 0x00 036A 84 DUP5 036B 5A GAS 036C F4 DELEGATECALL 036D 3D RETURNDATASIZE 036E 60 PUSH1 0x00 0370 80 DUP1 0371 3E RETURNDATACOPY 0372 80 DUP1 0373 80 DUP1 0374 15 ISZERO 0375 61 PUSH2 0x037d 0378 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @0363 memory[0x00:0x00 + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @036C memory[0x00:0x00] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @036C stack[0] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @0371 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0372 stack[1] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // } // Block ends with conditional jump to 0x037d, if !address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) label_0379: // Incoming jump from 0x0378, if not !address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // Inputs[2] // { // @0379 returndata.length // @037C memory[0x00:0x00 + returndata.length] // } 0379 3D RETURNDATASIZE 037A 60 PUSH1 0x00 037C F3 *RETURN // Stack delta = +0 // Outputs[1] { @037C return memory[0x00:0x00 + returndata.length]; } // Block terminates label_037D: // Incoming jump from 0x0378, if !address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // Inputs[2] // { // @037E returndata.length // @0381 memory[0x00:0x00 + returndata.length] // } 037D 5B JUMPDEST 037E 3D RETURNDATASIZE 037F 60 PUSH1 0x00 0381 FD *REVERT // Stack delta = +0 // Outputs[1] { @0381 revert(memory[0x00:0x00 + returndata.length]); } // Block terminates label_0382: // Incoming call from 0x02B2, returns to 0x02B3 // Incoming call from 0x011F, returns to 0x0120 // Incoming call from 0x0408, returns to 0x0409 // Incoming call from 0x024A, returns to 0x024B // Incoming call from 0x026B, returns to 0x0205 // Incoming call from 0x021E, returns to 0x021F // Incoming call from 0x016B, returns to 0x016C // Incoming call from 0x01E3, returns to 0x01E4 // Inputs[2] // { // @03A7 storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] // @03B3 stack[-1] // } 0382 5B JUMPDEST 0383 60 PUSH1 0x00 0385 7F PUSH32 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103 03A6 5B JUMPDEST 03A7 54 SLOAD 03A8 60 PUSH1 0x01 03AA 60 PUSH1 0x01 03AC 60 PUSH1 0xa0 03AE 1B SHL 03AF 03 SUB 03B0 16 AND 03B1 90 SWAP1 03B2 50 POP 03B3 90 SWAP1 03B4 56 *JUMP // Stack delta = +0 // Outputs[1] { @03B3 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] } // Block ends with unconditional jump to stack[-1] label_03B5: // Incoming jump from 0x0153 // Incoming jump from 0x01C7 // Inputs[1] { @03B9 stack[-3] } 03B5 5B JUMPDEST 03B6 61 PUSH2 0x03be 03B9 83 DUP4 03BA 61 PUSH2 0x0537 03BD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @03B6 stack[0] = 0x03be // @03B9 stack[1] = stack[-3] // } // Block ends with unconditional jump to 0x0537 03BE 5B JUMPDEST 03BF 60 PUSH1 0x00 03C1 82 DUP3 03C2 51 MLOAD 03C3 11 GT 03C4 80 DUP1 03C5 61 PUSH2 0x03cb 03C8 57 *JUMPI 03C9 50 POP 03CA 80 DUP1 03CB 5B JUMPDEST 03CC 15 ISZERO 03CD 61 PUSH2 0x01d5 03D0 57 *JUMPI 03D1 61 PUSH2 0x03da 03D4 83 DUP4 03D5 83 DUP4 03D6 61 PUSH2 0x026c 03D9 56 *JUMP 03DA 5B JUMPDEST 03DB 50 POP 03DC 50 POP 03DD 50 POP 03DE 50 POP 03DF 56 *JUMP label_03E0: // Incoming call from 0x0240, returns to 0x0154 03E0 5B JUMPDEST 03E1 7F PUSH32 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f 0402 61 PUSH2 0x0409 0405 61 PUSH2 0x0382 0408 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @03E1 stack[0] = 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f // @0402 stack[1] = 0x0409 // } // Block ends with call to 0x0382, returns to 0x0409 label_0409: // Incoming return from call to 0x0382 at 0x0408 // Inputs[6] // { // @040D memory[0x40:0x60] // @0416 stack[-1] // @041C stack[-3] // @0426 memory[0x40:0x60] // @042B stack[-2] // @042B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0409 5B JUMPDEST 040A 60 PUSH1 0x40 040C 80 DUP1 040D 51 MLOAD 040E 60 PUSH1 0x01 0410 60 PUSH1 0x01 0412 60 PUSH1 0xa0 0414 1B SHL 0415 03 SUB 0416 92 SWAP3 0417 83 DUP4 0418 16 AND 0419 81 DUP2 041A 52 MSTORE 041B 91 SWAP2 041C 84 DUP5 041D 16 AND 041E 60 PUSH1 0x20 0420 83 DUP4 0421 01 ADD 0422 52 MSTORE 0423 01 ADD 0424 60 PUSH1 0x40 0426 51 MLOAD 0427 80 DUP1 0428 91 SWAP2 0429 03 SUB 042A 90 SWAP1 042B A1 LOG1 042C 61 PUSH2 0x0161 042F 81 DUP2 0430 61 PUSH2 0x0577 0433 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @041A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0422 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @042B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]], [stack[-2]]); // @042C stack[-2] = 0x0161 // @042F stack[-1] = stack[-3] // } // Block ends with call to 0x0577, returns to 0x0161 0434 5B JUMPDEST 0435 60 PUSH1 0x60 0437 61 PUSH2 0x043f 043A 84 DUP5 043B 61 PUSH2 0x0298 043E 56 *JUMP 043F 5B JUMPDEST 0440 61 PUSH2 0x049a 0443 57 *JUMPI 0444 60 PUSH1 0x40 0446 51 MLOAD 0447 62 PUSH3 0x461bcd 044B 60 PUSH1 0xe5 044D 1B SHL 044E 81 DUP2 044F 52 MSTORE 0450 60 PUSH1 0x20 0452 60 PUSH1 0x04 0454 82 DUP3 0455 01 ADD 0456 52 MSTORE 0457 60 PUSH1 0x26 0459 60 PUSH1 0x24 045B 82 DUP3 045C 01 ADD 045D 52 MSTORE 045E 7F PUSH32 0x416464726573733a2064656c65676174652063616c6c20746f206e6f6e2d636f 047F 60 PUSH1 0x44 0481 82 DUP3 0482 01 ADD 0483 52 MSTORE 0484 65 PUSH6 0x1b9d1c9858dd 048B 60 PUSH1 0xd2 048D 1B SHL 048E 60 PUSH1 0x64 0490 82 DUP3 0491 01 ADD 0492 52 MSTORE 0493 60 PUSH1 0x84 0495 01 ADD 0496 61 PUSH2 0x0341 0499 56 *JUMP 049A 5B JUMPDEST 049B 60 PUSH1 0x00 049D 80 DUP1 049E 85 DUP6 049F 60 PUSH1 0x01 04A1 60 PUSH1 0x01 04A3 60 PUSH1 0xa0 04A5 1B SHL 04A6 03 SUB 04A7 16 AND 04A8 85 DUP6 04A9 60 PUSH1 0x40 04AB 51 MLOAD 04AC 61 PUSH2 0x04b5 04AF 91 SWAP2 04B0 90 SWAP1 04B1 61 PUSH2 0x079a 04B4 56 *JUMP 04B5 5B JUMPDEST 04B6 60 PUSH1 0x00 04B8 60 PUSH1 0x40 04BA 51 MLOAD 04BB 80 DUP1 04BC 83 DUP4 04BD 03 SUB 04BE 81 DUP2 04BF 85 DUP6 04C0 5A GAS 04C1 F4 DELEGATECALL 04C2 91 SWAP2 04C3 50 POP 04C4 50 POP 04C5 3D RETURNDATASIZE 04C6 80 DUP1 04C7 60 PUSH1 0x00 04C9 81 DUP2 04CA 14 EQ 04CB 61 PUSH2 0x04f0 04CE 57 *JUMPI 04CF 60 PUSH1 0x40 04D1 51 MLOAD 04D2 91 SWAP2 04D3 50 POP 04D4 60 PUSH1 0x1f 04D6 19 NOT 04D7 60 PUSH1 0x3f 04D9 3D RETURNDATASIZE 04DA 01 ADD 04DB 16 AND 04DC 82 DUP3 04DD 01 ADD 04DE 60 PUSH1 0x40 04E0 52 MSTORE 04E1 3D RETURNDATASIZE 04E2 82 DUP3 04E3 52 MSTORE 04E4 3D RETURNDATASIZE 04E5 60 PUSH1 0x00 04E7 60 PUSH1 0x20 04E9 84 DUP5 04EA 01 ADD 04EB 3E RETURNDATACOPY 04EC 61 PUSH2 0x04f5 04EF 56 *JUMP 04F0 5B JUMPDEST 04F1 60 PUSH1 0x60 04F3 91 SWAP2 04F4 50 POP 04F5 5B JUMPDEST 04F6 50 POP 04F7 91 SWAP2 04F8 50 POP 04F9 91 SWAP2 04FA 50 POP 04FB 61 PUSH2 0x0505 04FE 82 DUP3 04FF 82 DUP3 0500 86 DUP7 0501 61 PUSH2 0x0620 0504 56 *JUMP 0505 5B JUMPDEST 0506 96 SWAP7 0507 95 SWAP6 0508 50 POP 0509 50 POP 050A 50 POP 050B 50 POP 050C 50 POP 050D 50 POP 050E 56 *JUMP label_050F: // Incoming call from 0x0358, returns to 0x0359 050F 5B JUMPDEST 0510 60 PUSH1 0x00 0512 7F PUSH32 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc 0533 61 PUSH2 0x03a6 0536 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0510 stack[0] = 0x00 // @0512 stack[1] = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc // } // Block ends with unconditional jump to 0x03a6 label_0537: // Incoming jump from 0x03BD // Inputs[1] { @053B stack[-1] } 0537 5B JUMPDEST 0538 61 PUSH2 0x0540 053B 81 DUP2 053C 61 PUSH2 0x0659 053F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0538 stack[0] = 0x0540 // @053B stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x0659 0540 5B JUMPDEST 0541 60 PUSH1 0x40 0543 51 MLOAD 0544 60 PUSH1 0x01 0546 60 PUSH1 0x01 0548 60 PUSH1 0xa0 054A 1B SHL 054B 03 SUB 054C 82 DUP3 054D 16 AND 054E 90 SWAP1 054F 7F PUSH32 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b 0570 90 SWAP1 0571 60 PUSH1 0x00 0573 90 SWAP1 0574 A2 LOG2 0575 50 POP 0576 56 *JUMP label_0577: // Incoming call from 0x0433, returns to 0x0161 // Inputs[1] { @0580 stack[-1] } 0577 5B JUMPDEST 0578 60 PUSH1 0x01 057A 60 PUSH1 0x01 057C 60 PUSH1 0xa0 057E 1B SHL 057F 03 SUB 0580 81 DUP2 0581 16 AND 0582 61 PUSH2 0x05dc 0585 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05dc, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0586: // Incoming jump from 0x0585, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0588 memory[0x40:0x60] } 0586 60 PUSH1 0x40 0588 51 MLOAD 0589 62 PUSH3 0x461bcd 058D 60 PUSH1 0xe5 058F 1B SHL 0590 81 DUP2 0591 52 MSTORE 0592 60 PUSH1 0x20 0594 60 PUSH1 0x04 0596 82 DUP3 0597 01 ADD 0598 52 MSTORE 0599 60 PUSH1 0x26 059B 60 PUSH1 0x24 059D 82 DUP3 059E 01 ADD 059F 52 MSTORE 05A0 7F PUSH32 0x455243313936373a206e65772061646d696e20697320746865207a65726f2061 05C1 60 PUSH1 0x44 05C3 82 DUP3 05C4 01 ADD 05C5 52 MSTORE 05C6 65 PUSH6 0x646472657373 05CD 60 PUSH1 0xd0 05CF 1B SHL 05D0 60 PUSH1 0x64 05D2 82 DUP3 05D3 01 ADD 05D4 52 MSTORE 05D5 60 PUSH1 0x84 05D7 01 ADD 05D8 61 PUSH2 0x0341 05DB 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0591 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0598 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @059F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @05C5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313936373a206e65772061646d696e20697320746865207a65726f2061 // @05D4 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @05D7 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0341 label_05DC: // Incoming jump from 0x0585, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @05DD stack[-1] // @0601 storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] // @061F stack[-2] // } 05DC 5B JUMPDEST 05DD 80 DUP1 05DE 7F PUSH32 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103 05FF 5B JUMPDEST 0600 80 DUP1 0601 54 SLOAD 0602 60 PUSH1 0x01 0604 60 PUSH1 0x01 0606 60 PUSH1 0xa0 0608 1B SHL 0609 03 SUB 060A 19 NOT 060B 16 AND 060C 60 PUSH1 0x01 060E 60 PUSH1 0x01 0610 60 PUSH1 0xa0 0612 1B SHL 0613 03 SUB 0614 92 SWAP3 0615 90 SWAP1 0616 92 SWAP3 0617 16 AND 0618 91 SWAP2 0619 90 SWAP1 061A 91 SWAP2 061B 17 OR 061C 90 SWAP1 061D 55 SSTORE 061E 50 POP 061F 56 *JUMP // Stack delta = -2 // Outputs[1] { @061D storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103]) } // Block ends with unconditional jump to stack[-2] 0620 5B JUMPDEST 0621 60 PUSH1 0x60 0623 83 DUP4 0624 15 ISZERO 0625 61 PUSH2 0x062f 0628 57 *JUMPI 0629 50 POP 062A 81 DUP2 062B 61 PUSH2 0x0291 062E 56 *JUMP 062F 5B JUMPDEST 0630 82 DUP3 0631 51 MLOAD 0632 15 ISZERO 0633 61 PUSH2 0x063f 0636 57 *JUMPI 0637 82 DUP3 0638 51 MLOAD 0639 80 DUP1 063A 84 DUP5 063B 60 PUSH1 0x20 063D 01 ADD 063E FD *REVERT 063F 5B JUMPDEST 0640 81 DUP2 0641 60 PUSH1 0x40 0643 51 MLOAD 0644 62 PUSH3 0x461bcd 0648 60 PUSH1 0xe5 064A 1B SHL 064B 81 DUP2 064C 52 MSTORE 064D 60 PUSH1 0x04 064F 01 ADD 0650 61 PUSH2 0x0341 0653 91 SWAP2 0654 90 SWAP1 0655 61 PUSH2 0x07b6 0658 56 *JUMP label_0659: // Incoming jump from 0x053F // Inputs[1] { @065D stack[-1] } 0659 5B JUMPDEST 065A 61 PUSH2 0x0662 065D 81 DUP2 065E 61 PUSH2 0x0298 0661 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @065A stack[0] = 0x0662 // @065D stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x0298 0662 5B JUMPDEST 0663 61 PUSH2 0x06c4 0666 57 *JUMPI 0667 60 PUSH1 0x40 0669 51 MLOAD 066A 62 PUSH3 0x461bcd 066E 60 PUSH1 0xe5 0670 1B SHL 0671 81 DUP2 0672 52 MSTORE 0673 60 PUSH1 0x20 0675 60 PUSH1 0x04 0677 82 DUP3 0678 01 ADD 0679 52 MSTORE 067A 60 PUSH1 0x2d 067C 60 PUSH1 0x24 067E 82 DUP3 067F 01 ADD 0680 52 MSTORE 0681 7F PUSH32 0x455243313936373a206e657720696d706c656d656e746174696f6e206973206e 06A2 60 PUSH1 0x44 06A4 82 DUP3 06A5 01 ADD 06A6 52 MSTORE 06A7 6C PUSH13 0x1bdd08184818dbdb9d1c9858dd 06B5 60 PUSH1 0x9a 06B7 1B SHL 06B8 60 PUSH1 0x64 06BA 82 DUP3 06BB 01 ADD 06BC 52 MSTORE 06BD 60 PUSH1 0x84 06BF 01 ADD 06C0 61 PUSH2 0x0341 06C3 56 *JUMP 06C4 5B JUMPDEST 06C5 80 DUP1 06C6 7F PUSH32 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc 06E7 61 PUSH2 0x05ff 06EA 56 *JUMP label_06EB: // Incoming call from 0x071B, returns to 0x0291 // Incoming call from 0x0738, returns to 0x0739 // Inputs[2] // { // @06EC stack[-1] // @06ED msg.data[stack[-1]:stack[-1] + 0x20] // } 06EB 5B JUMPDEST 06EC 80 DUP1 06ED 35 CALLDATALOAD 06EE 60 PUSH1 0x01 06F0 60 PUSH1 0x01 06F2 60 PUSH1 0xa0 06F4 1B SHL 06F5 03 SUB 06F6 81 DUP2 06F7 16 AND 06F8 81 DUP2 06F9 14 EQ 06FA 61 PUSH2 0x02a6 06FD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06ED stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x02a6, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_06FE: // Incoming jump from 0x06FD, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0701 memory[0x00:0x00] } 06FE 60 PUSH1 0x00 0700 80 DUP1 0701 FD *REVERT // Stack delta = +0 // Outputs[1] { @0701 revert(memory[0x00:0x00]); } // Block terminates label_0702: // Incoming call from 0x007F, returns to 0x0080 // Incoming call from 0x00E3, returns to 0x00E4 // Inputs[2] // { // @0707 stack[-1] // @0708 stack[-2] // } 0702 5B JUMPDEST 0703 60 PUSH1 0x00 0705 60 PUSH1 0x20 0707 82 DUP3 0708 84 DUP5 0709 03 SUB 070A 12 SLT 070B 15 ISZERO 070C 61 PUSH2 0x0713 070F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0703 stack[0] = 0x00 } // Block ends with conditional jump to 0x0713, if !(stack[-2] - stack[-1] i< 0x20) label_0710: // Incoming jump from 0x070F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @0710 stack[-1] // @0712 memory[stack[-1]:stack[-1] + stack[-1]] // } 0710 80 DUP1 0711 81 DUP2 0712 FD *REVERT // Stack delta = +0 // Outputs[1] { @0712 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_0713: // Incoming jump from 0x070F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @0717 stack[-2] } 0713 5B JUMPDEST 0714 61 PUSH2 0x0291 0717 82 DUP3 0718 61 PUSH2 0x06eb 071B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0714 stack[0] = 0x0291 // @0717 stack[1] = stack[-2] // } // Block ends with call to 0x06eb, returns to 0x0291 label_071C: // Incoming call from 0x0092, returns to 0x0093 // Inputs[2] // { // @0724 stack[-1] // @0725 stack[-2] // } 071C 5B JUMPDEST 071D 60 PUSH1 0x00 071F 80 DUP1 0720 60 PUSH1 0x00 0722 60 PUSH1 0x40 0724 84 DUP5 0725 86 DUP7 0726 03 SUB 0727 12 SLT 0728 15 ISZERO 0729 61 PUSH2 0x0730 072C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @071D stack[0] = 0x00 // @071F stack[1] = 0x00 // @0720 stack[2] = 0x00 // } // Block ends with conditional jump to 0x0730, if !(stack[-2] - stack[-1] i< 0x40) label_072D: // Incoming jump from 0x072C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @072D stack[-2] // @072F memory[stack[-2]:stack[-2] + stack[-2]] // } 072D 81 DUP2 072E 82 DUP3 072F FD *REVERT // Stack delta = +0 // Outputs[1] { @072F revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_0730: // Incoming jump from 0x072C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @0734 stack[-4] } 0730 5B JUMPDEST 0731 61 PUSH2 0x0739 0734 84 DUP5 0735 61 PUSH2 0x06eb 0738 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0731 stack[0] = 0x0739 // @0734 stack[1] = stack[-4] // } // Block ends with call to 0x06eb, returns to 0x0739 label_0739: // Incoming return from call to 0x06EB at 0x0738 // Inputs[4] // { // @073A stack[-1] // @073A stack[-4] // @073E stack[-5] // @0740 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 0739 5B JUMPDEST 073A 92 SWAP3 073B 50 POP 073C 60 PUSH1 0x20 073E 84 DUP5 073F 01 ADD 0740 35 CALLDATALOAD 0741 67 PUSH8 0xffffffffffffffff 074A 80 DUP1 074B 82 DUP3 074C 11 GT 074D 15 ISZERO 074E 61 PUSH2 0x0755 0751 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @073A stack[-4] = stack[-1] // @0740 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @0741 stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x0755, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) label_0752: // Incoming jump from 0x0751, if not !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @0752 stack[-4] // @0754 memory[stack[-4]:stack[-4] + stack[-4]] // } 0752 83 DUP4 0753 84 DUP5 0754 FD *REVERT // Stack delta = +0 // Outputs[1] { @0754 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_0755: // Incoming jump from 0x0751, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @0756 stack[-2] // @0757 stack[-6] // @075B stack[-7] // } 0755 5B JUMPDEST 0756 81 DUP2 0757 86 DUP7 0758 01 ADD 0759 91 SWAP2 075A 50 POP 075B 86 DUP7 075C 60 PUSH1 0x1f 075E 83 DUP4 075F 01 ADD 0760 12 SLT 0761 61 PUSH2 0x0768 0764 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0759 stack[-2] = stack[-6] + stack[-2] } // Block ends with conditional jump to 0x0768, if stack[-6] + stack[-2] + 0x1f i< stack[-7] label_0765: // Incoming jump from 0x0764, if not stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[2] // { // @0765 stack[-4] // @0767 memory[stack[-4]:stack[-4] + stack[-4]] // } 0765 83 DUP4 0766 84 DUP5 0767 FD *REVERT // Stack delta = +0 // Outputs[1] { @0767 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_0768: // Incoming jump from 0x0764, if stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[3] // { // @0769 stack[-2] // @076A msg.data[stack[-2]:stack[-2] + 0x20] // @076B stack[-1] // } 0768 5B JUMPDEST 0769 81 DUP2 076A 35 CALLDATALOAD 076B 81 DUP2 076C 81 DUP2 076D 11 GT 076E 15 ISZERO 076F 61 PUSH2 0x0776 0772 57 *JUMPI // Stack delta = +1 // Outputs[1] { @076A stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0776, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_0773: // Incoming jump from 0x0772, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[2] // { // @0773 stack[-5] // @0775 memory[stack[-5]:stack[-5] + stack[-5]] // } 0773 84 DUP5 0774 85 DUP6 0775 FD *REVERT // Stack delta = +0 // Outputs[1] { @0775 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_0776: // Incoming jump from 0x0772, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @0777 stack[-8] // @077A stack[-1] // @077B stack[-3] // } 0776 5B JUMPDEST 0777 87 DUP8 0778 60 PUSH1 0x20 077A 82 DUP3 077B 85 DUP6 077C 01 ADD 077D 01 ADD 077E 11 GT 077F 15 ISZERO 0780 61 PUSH2 0x0787 0783 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0787, if !(stack[-3] + stack[-1] + 0x20 > stack[-8]) label_0784: // Incoming jump from 0x0783, if not !(stack[-3] + stack[-1] + 0x20 > stack[-8]) // Inputs[2] // { // @0784 stack[-5] // @0786 memory[stack[-5]:stack[-5] + stack[-5]] // } 0784 84 DUP5 0785 85 DUP6 0786 FD *REVERT // Stack delta = +0 // Outputs[1] { @0786 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_0787: // Incoming jump from 0x0783, if !(stack[-3] + stack[-1] + 0x20 > stack[-8]) // Inputs[8] // { // @078A stack[-3] // @078C stack[-5] // @078E stack[-1] // @078F stack[-4] // @0794 stack[-7] // @0796 stack[-8] // @0798 stack[-6] // @0798 stack[-9] // } 0787 5B JUMPDEST 0788 60 PUSH1 0x20 078A 83 DUP4 078B 01 ADD 078C 94 SWAP5 078D 50 POP 078E 80 DUP1 078F 93 SWAP4 0790 50 POP 0791 50 POP 0792 50 POP 0793 50 POP 0794 92 SWAP3 0795 50 POP 0796 92 SWAP3 0797 50 POP 0798 92 SWAP3 0799 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @0794 stack[-7] = stack[-1] // @0796 stack[-8] = stack[-3] + 0x20 // @0798 stack[-9] = stack[-6] // } // Block ends with unconditional jump to stack[-9] 079A 5B JUMPDEST 079B 60 PUSH1 0x00 079D 82 DUP3 079E 51 MLOAD 079F 61 PUSH2 0x07ac 07A2 81 DUP2 07A3 84 DUP5 07A4 60 PUSH1 0x20 07A6 87 DUP8 07A7 01 ADD 07A8 61 PUSH2 0x07e9 07AB 56 *JUMP 07AC 5B JUMPDEST 07AD 91 SWAP2 07AE 90 SWAP1 07AF 91 SWAP2 07B0 01 ADD 07B1 92 SWAP3 07B2 91 SWAP2 07B3 50 POP 07B4 50 POP 07B5 56 *JUMP 07B6 5B JUMPDEST 07B7 60 PUSH1 0x00 07B9 60 PUSH1 0x20 07BB 82 DUP3 07BC 52 MSTORE 07BD 82 DUP3 07BE 51 MLOAD 07BF 80 DUP1 07C0 60 PUSH1 0x20 07C2 84 DUP5 07C3 01 ADD 07C4 52 MSTORE 07C5 61 PUSH2 0x07d5 07C8 81 DUP2 07C9 60 PUSH1 0x40 07CB 85 DUP6 07CC 01 ADD 07CD 60 PUSH1 0x20 07CF 87 DUP8 07D0 01 ADD 07D1 61 PUSH2 0x07e9 07D4 56 *JUMP 07D5 5B JUMPDEST 07D6 60 PUSH1 0x1f 07D8 01 ADD 07D9 60 PUSH1 0x1f 07DB 19 NOT 07DC 16 AND 07DD 91 SWAP2 07DE 90 SWAP1 07DF 91 SWAP2 07E0 01 ADD 07E1 60 PUSH1 0x40 07E3 01 ADD 07E4 92 SWAP3 07E5 91 SWAP2 07E6 50 POP 07E7 50 POP 07E8 56 *JUMP 07E9 5B JUMPDEST 07EA 60 PUSH1 0x00 07EC 5B JUMPDEST 07ED 83 DUP4 07EE 81 DUP2 07EF 10 LT 07F0 15 ISZERO 07F1 61 PUSH2 0x0804 07F4 57 *JUMPI 07F5 81 DUP2 07F6 81 DUP2 07F7 01 ADD 07F8 51 MLOAD 07F9 83 DUP4 07FA 82 DUP3 07FB 01 ADD 07FC 52 MSTORE 07FD 60 PUSH1 0x20 07FF 01 ADD 0800 61 PUSH2 0x07ec 0803 56 *JUMP 0804 5B JUMPDEST 0805 83 DUP4 0806 81 DUP2 0807 11 GT 0808 15 ISZERO 0809 61 PUSH2 0x03da 080C 57 *JUMPI 080D 50 POP 080E 50 POP 080F 60 PUSH1 0x00 0811 91 SWAP2 0812 01 ADD 0813 52 MSTORE 0814 56 *JUMP 0815 FE *ASSERT 0816 41 COINBASE 0817 64 PUSH5 0x6472657373 081D 3A GASPRICE 081E 20 SHA3 081F 6C PUSH13 0x6f772d6c6576656c2064656c65 082D 67 PUSH8 0x6174652063616c6c 0836 20 SHA3 0837 66 PUSH7 0x61696c6564a264 083F 69 PUSH10 0x706673582212201559a9 084A CE CE 084B CC CC 084C 07 SMOD 084D 47 SELFBALANCE 084E 31 BALANCE 084F 41 COINBASE 0850 6A PUSH11 0xb18b8af6d70a4ade0d4c27 085C D3 D3 085D 60 PUSH1 0x67 085F A9 A9 0860 DD DD 0861 60 PUSH1 0x5c 0863 EA EA 0864 C4 C4 0865 94 SWAP5 0866 0B SIGNEXTEND 0867 64 PUSH5 0x736f6c6343 086D 00 *STOP 086E 08 ADDMOD 086F 02 MUL 0870 00 *STOP 0871 33 CALLER