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 0x0053, if msg.data.length // Incoming jump from 0x004D 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 0x06ed 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 0x06ed, returns to 0x0080 label_0080: // Incoming return from call to 0x06ED 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 0x0707 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 0x0707, returns to 0x0093 label_0093: // Incoming return from call to 0x0707 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 0x06ed 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 0x06ed, returns to 0x00E4 label_00E4: // Incoming return from call to 0x06ED 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 0x005A // Incoming jump from 0x0213 // Incoming jump from 0x01D4 // Incoming jump from 0x0160 // Incoming jump from 0x0064 00FE 5B JUMPDEST 00FF 61 PUSH2 0x0106 0102 61 PUSH2 0x02a2 0105 56 *JUMP // Stack delta = +1 // Outputs[1] { @00FF stack[0] = 0x0106 } // Block ends with call to 0x02a2, returns to 0x0106 label_0106: // Incoming return from call to 0x02A2 at 0x0105 0106 5B JUMPDEST 0107 61 PUSH2 0x0116 010A 61 PUSH2 0x0111 010D 61 PUSH2 0x0346 0110 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0107 stack[0] = 0x0116 // @010A stack[1] = 0x0111 // } // Block ends with call to 0x0346, returns to 0x0111 label_0111: // Incoming return from call to 0x0346 at 0x0110 0111 5B JUMPDEST 0112 61 PUSH2 0x0355 0115 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0355 label_0116: // Incoming jump from 0x0345 // 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 0x0379 011F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0119 stack[0] = 0x0120 } // Block ends with call to 0x0379, returns to 0x0120 label_0120: // Incoming return from call to 0x0379 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 0x03ac 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 0x03ac label_0154: // Incoming return from call to 0x040B 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 0x0611 at 0x045E // 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 0x0379 016B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0165 stack[0] = 0x016c } // Block ends with call to 0x0379, returns to 0x016C label_016C: // Incoming return from call to 0x0379 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 0x03ac 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 0x03ac 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 0x0379 01E3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @01DB stack[0] = 0x00 // @01DD stack[1] = 0x01e4 // } // Block ends with call to 0x0379, returns to 0x01E4 label_01E4: // Incoming return from call to 0x0379 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 0x0346 0204 56 *JUMP // Stack delta = +1 // Outputs[1] { @01FE stack[0] = 0x0205 } // Block ends with call to 0x0346, returns to 0x0205 label_0205: // Incoming return from call to 0x0379 at 0x026B // Incoming return from call to 0x0346 at 0x0204 // Inputs[2] // { // @0206 stack[-1] // @0206 stack[-2] // } 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 0x0264, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) // Incoming jump from 0x01FD, 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 0x0379 021E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0218 stack[0] = 0x021f } // Block ends with call to 0x0379, returns to 0x021F label_021F: // Incoming return from call to 0x0379 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 0x040b 0240 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0239 stack[0] = 0x0154 // @023C stack[1] = stack[-1] // } // Block ends with call to 0x040b, 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 0x0379 024A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0242 stack[0] = 0x00 // @0244 stack[1] = 0x024b // } // Block ends with call to 0x0379, returns to 0x024B label_024B: // Incoming return from call to 0x0379 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 0x0379 026B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0265 stack[0] = 0x0205 } // Block ends with call to 0x0379, 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 0x0801 0289 60 PUSH1 0x27 028B 91 SWAP2 028C 39 CODECOPY 028D 61 PUSH2 0x045f 0290 56 *JUMP label_0291: // Incoming return from call to 0x06D6 at 0x0706 // 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 0x056A // Inputs[2] // { // @0299 stack[-1] // @029A address(stack[-1]).code.length // } 0298 5B JUMPDEST 0299 80 DUP1 029A 3B EXTCODESIZE 029B 15 ISZERO 029C 15 ISZERO // Stack delta = +1 // Outputs[1] { @029C stack[0] = !!address(stack[-1]).code.length } // Block continues label_029D: // Incoming jump from 0x06E8, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x029C // Inputs[3] // { // @029E stack[-1] // @029E stack[-3] // @029F stack[-2] // } 029D 5B JUMPDEST 029E 91 SWAP2 029F 90 SWAP1 02A0 50 POP 02A1 56 *JUMP // Stack delta = -2 // Outputs[1] { @029E stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_02A2: // Incoming call from 0x0105, returns to 0x0106 02A2 5B JUMPDEST 02A3 61 PUSH2 0x02aa 02A6 61 PUSH2 0x0379 02A9 56 *JUMP // Stack delta = +1 // Outputs[1] { @02A3 stack[0] = 0x02aa } // Block ends with call to 0x0379, returns to 0x02AA label_02AA: // Incoming return from call to 0x0379 at 0x02A9 // Inputs[2] // { // @02B3 stack[-1] // @02B4 msg.sender // } 02AA 5B JUMPDEST 02AB 60 PUSH1 0x01 02AD 60 PUSH1 0x01 02AF 60 PUSH1 0xa0 02B1 1B SHL 02B2 03 SUB 02B3 16 AND 02B4 33 CALLER 02B5 60 PUSH1 0x01 02B7 60 PUSH1 0x01 02B9 60 PUSH1 0xa0 02BB 1B SHL 02BC 03 SUB 02BD 16 AND 02BE 14 EQ 02BF 15 ISZERO 02C0 61 PUSH2 0x0341 02C3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0341, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) label_02C4: // Incoming jump from 0x02C3, if not !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @02C6 memory[0x40:0x60] // @033B memory[0x40:0x60] // @0340 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02C4 60 PUSH1 0x40 02C6 51 MLOAD 02C7 62 PUSH3 0x461bcd 02CB 60 PUSH1 0xe5 02CD 1B SHL 02CE 81 DUP2 02CF 52 MSTORE 02D0 60 PUSH1 0x20 02D2 60 PUSH1 0x04 02D4 82 DUP3 02D5 01 ADD 02D6 52 MSTORE 02D7 60 PUSH1 0x42 02D9 60 PUSH1 0x24 02DB 82 DUP3 02DC 01 ADD 02DD 52 MSTORE 02DE 7F PUSH32 0x5472616e73706172656e745570677261646561626c6550726f78793a2061646d 02FF 60 PUSH1 0x44 0301 82 DUP3 0302 01 ADD 0303 52 MSTORE 0304 7F PUSH32 0x696e2063616e6e6f742066616c6c6261636b20746f2070726f78792074617267 0325 60 PUSH1 0x64 0327 82 DUP3 0328 01 ADD 0329 52 MSTORE 032A 61 PUSH2 0x195d 032D 60 PUSH1 0xf2 032F 1B SHL 0330 60 PUSH1 0x84 0332 82 DUP3 0333 01 ADD 0334 52 MSTORE 0335 60 PUSH1 0xa4 0337 01 ADD 0338 5B JUMPDEST 0339 60 PUSH1 0x40 033B 51 MLOAD 033C 80 DUP1 033D 91 SWAP2 033E 03 SUB 033F 90 SWAP1 0340 FD *REVERT // Stack delta = +0 // Outputs[7] // { // @02CF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @02D6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @02DD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x42 // @0303 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5472616e73706172656e745570677261646561626c6550726f78793a2061646d // @0329 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x696e2063616e6e6f742066616c6c6261636b20746f2070726f78792074617267 // @0334 memory[memory[0x40:0x60] + 0x84:memory[0x40:0x60] + 0x84 + 0x20] = 0x195d << 0xf2 // @0340 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0341: // Incoming jump from 0x02C3, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) 0341 5B JUMPDEST 0342 61 PUSH2 0x0116 0345 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0116 label_0346: // Incoming call from 0x0110, returns to 0x0111 // Incoming call from 0x0204, returns to 0x0205 0346 5B JUMPDEST 0347 60 PUSH1 0x00 0349 61 PUSH2 0x0350 034C 61 PUSH2 0x053a 034F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0347 stack[0] = 0x00 // @0349 stack[1] = 0x0350 // } // Block ends with call to 0x053a, returns to 0x0350 label_0350: // Incoming return from call to 0x053A at 0x034F // Inputs[3] // { // @0351 stack[-1] // @0351 stack[-2] // @0353 stack[-3] // } 0350 5B JUMPDEST 0351 90 SWAP1 0352 50 POP 0353 90 SWAP1 0354 56 *JUMP // Stack delta = -2 // Outputs[1] { @0353 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_0355: // Incoming jump from 0x0115 // Inputs[9] // { // @0356 msg.data.length // @035A msg.data[0x00:0x00 + msg.data.length] // @035E msg.data.length // @0361 stack[-1] // @0362 msg.gas // @0363 memory[0x00:0x00 + msg.data.length] // @0363 address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @0364 returndata.length // @0368 returndata[0x00:0x00 + returndata.length] // } 0355 5B JUMPDEST 0356 36 CALLDATASIZE 0357 60 PUSH1 0x00 0359 80 DUP1 035A 37 CALLDATACOPY 035B 60 PUSH1 0x00 035D 80 DUP1 035E 36 CALLDATASIZE 035F 60 PUSH1 0x00 0361 84 DUP5 0362 5A GAS 0363 F4 DELEGATECALL 0364 3D RETURNDATASIZE 0365 60 PUSH1 0x00 0367 80 DUP1 0368 3E RETURNDATACOPY 0369 80 DUP1 036A 80 DUP1 036B 15 ISZERO 036C 61 PUSH2 0x0374 036F 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @035A memory[0x00:0x00 + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @0363 memory[0x00:0x00] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @0363 stack[0] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @0368 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0369 stack[1] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // } // Block ends with conditional jump to 0x0374, if !address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) label_0370: // Incoming jump from 0x036F, if not !address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // Inputs[2] // { // @0370 returndata.length // @0373 memory[0x00:0x00 + returndata.length] // } 0370 3D RETURNDATASIZE 0371 60 PUSH1 0x00 0373 F3 *RETURN // Stack delta = +0 // Outputs[1] { @0373 return memory[0x00:0x00 + returndata.length]; } // Block terminates label_0374: // Incoming jump from 0x036F, if !address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // Inputs[2] // { // @0375 returndata.length // @0378 memory[0x00:0x00 + returndata.length] // } 0374 5B JUMPDEST 0375 3D RETURNDATASIZE 0376 60 PUSH1 0x00 0378 FD *REVERT // Stack delta = +0 // Outputs[1] { @0378 revert(memory[0x00:0x00 + returndata.length]); } // Block terminates label_0379: // Incoming call from 0x016B, returns to 0x016C // Incoming call from 0x011F, returns to 0x0120 // Incoming call from 0x01E3, returns to 0x01E4 // Incoming call from 0x024A, returns to 0x024B // Incoming call from 0x0433, returns to 0x0434 // Incoming call from 0x021E, returns to 0x021F // Incoming call from 0x026B, returns to 0x0205 // Incoming call from 0x02A9, returns to 0x02AA // Inputs[2] // { // @039E storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] // @03AA stack[-1] // } 0379 5B JUMPDEST 037A 60 PUSH1 0x00 037C 7F PUSH32 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103 039D 5B JUMPDEST 039E 54 SLOAD 039F 60 PUSH1 0x01 03A1 60 PUSH1 0x01 03A3 60 PUSH1 0xa0 03A5 1B SHL 03A6 03 SUB 03A7 16 AND 03A8 90 SWAP1 03A9 50 POP 03AA 90 SWAP1 03AB 56 *JUMP // Stack delta = +0 // Outputs[1] { @03AA stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] } // Block ends with unconditional jump to stack[-1] label_03AC: // Incoming jump from 0x0153 // Incoming jump from 0x01C7 // Inputs[1] { @03B0 stack[-3] } 03AC 5B JUMPDEST 03AD 61 PUSH2 0x03b5 03B0 83 DUP4 03B1 61 PUSH2 0x0562 03B4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @03AD stack[0] = 0x03b5 // @03B0 stack[1] = stack[-3] // } // Block ends with unconditional jump to 0x0562 03B5 5B JUMPDEST 03B6 60 PUSH1 0x40 03B8 51 MLOAD 03B9 60 PUSH1 0x01 03BB 60 PUSH1 0x01 03BD 60 PUSH1 0xa0 03BF 1B SHL 03C0 03 SUB 03C1 84 DUP5 03C2 16 AND 03C3 90 SWAP1 03C4 7F PUSH32 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b 03E5 90 SWAP1 03E6 60 PUSH1 0x00 03E8 90 SWAP1 03E9 A2 LOG2 03EA 60 PUSH1 0x00 03EC 82 DUP3 03ED 51 MLOAD 03EE 11 GT 03EF 80 DUP1 03F0 61 PUSH2 0x03f6 03F3 57 *JUMPI 03F4 50 POP 03F5 80 DUP1 03F6 5B JUMPDEST 03F7 15 ISZERO 03F8 61 PUSH2 0x01d5 03FB 57 *JUMPI 03FC 61 PUSH2 0x0405 03FF 83 DUP4 0400 83 DUP4 0401 61 PUSH2 0x026c 0404 56 *JUMP 0405 5B JUMPDEST 0406 50 POP 0407 50 POP 0408 50 POP 0409 50 POP 040A 56 *JUMP label_040B: // Incoming call from 0x0240, returns to 0x0154 040B 5B JUMPDEST 040C 7F PUSH32 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f 042D 61 PUSH2 0x0434 0430 61 PUSH2 0x0379 0433 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @040C stack[0] = 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f // @042D stack[1] = 0x0434 // } // Block ends with call to 0x0379, returns to 0x0434 label_0434: // Incoming return from call to 0x0379 at 0x0433 // Inputs[6] // { // @0438 memory[0x40:0x60] // @0441 stack[-1] // @0447 stack[-3] // @0451 memory[0x40:0x60] // @0456 stack[-2] // @0456 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0434 5B JUMPDEST 0435 60 PUSH1 0x40 0437 80 DUP1 0438 51 MLOAD 0439 60 PUSH1 0x01 043B 60 PUSH1 0x01 043D 60 PUSH1 0xa0 043F 1B SHL 0440 03 SUB 0441 92 SWAP3 0442 83 DUP4 0443 16 AND 0444 81 DUP2 0445 52 MSTORE 0446 91 SWAP2 0447 84 DUP5 0448 16 AND 0449 60 PUSH1 0x20 044B 83 DUP4 044C 01 ADD 044D 52 MSTORE 044E 01 ADD 044F 60 PUSH1 0x40 0451 51 MLOAD 0452 80 DUP1 0453 91 SWAP2 0454 03 SUB 0455 90 SWAP1 0456 A1 LOG1 0457 61 PUSH2 0x0161 045A 81 DUP2 045B 61 PUSH2 0x0611 045E 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @0445 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @044D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0456 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]], [stack[-2]]); // @0457 stack[-2] = 0x0161 // @045A stack[-1] = stack[-3] // } // Block ends with call to 0x0611, returns to 0x0161 045F 5B JUMPDEST 0460 60 PUSH1 0x60 0462 61 PUSH2 0x046a 0465 84 DUP5 0466 61 PUSH2 0x0298 0469 56 *JUMP 046A 5B JUMPDEST 046B 61 PUSH2 0x04c5 046E 57 *JUMPI 046F 60 PUSH1 0x40 0471 51 MLOAD 0472 62 PUSH3 0x461bcd 0476 60 PUSH1 0xe5 0478 1B SHL 0479 81 DUP2 047A 52 MSTORE 047B 60 PUSH1 0x20 047D 60 PUSH1 0x04 047F 82 DUP3 0480 01 ADD 0481 52 MSTORE 0482 60 PUSH1 0x26 0484 60 PUSH1 0x24 0486 82 DUP3 0487 01 ADD 0488 52 MSTORE 0489 7F PUSH32 0x416464726573733a2064656c65676174652063616c6c20746f206e6f6e2d636f 04AA 60 PUSH1 0x44 04AC 82 DUP3 04AD 01 ADD 04AE 52 MSTORE 04AF 65 PUSH6 0x1b9d1c9858dd 04B6 60 PUSH1 0xd2 04B8 1B SHL 04B9 60 PUSH1 0x64 04BB 82 DUP3 04BC 01 ADD 04BD 52 MSTORE 04BE 60 PUSH1 0x84 04C0 01 ADD 04C1 61 PUSH2 0x0338 04C4 56 *JUMP 04C5 5B JUMPDEST 04C6 60 PUSH1 0x00 04C8 80 DUP1 04C9 85 DUP6 04CA 60 PUSH1 0x01 04CC 60 PUSH1 0x01 04CE 60 PUSH1 0xa0 04D0 1B SHL 04D1 03 SUB 04D2 16 AND 04D3 85 DUP6 04D4 60 PUSH1 0x40 04D6 51 MLOAD 04D7 61 PUSH2 0x04e0 04DA 91 SWAP2 04DB 90 SWAP1 04DC 61 PUSH2 0x0785 04DF 56 *JUMP 04E0 5B JUMPDEST 04E1 60 PUSH1 0x00 04E3 60 PUSH1 0x40 04E5 51 MLOAD 04E6 80 DUP1 04E7 83 DUP4 04E8 03 SUB 04E9 81 DUP2 04EA 85 DUP6 04EB 5A GAS 04EC F4 DELEGATECALL 04ED 91 SWAP2 04EE 50 POP 04EF 50 POP 04F0 3D RETURNDATASIZE 04F1 80 DUP1 04F2 60 PUSH1 0x00 04F4 81 DUP2 04F5 14 EQ 04F6 61 PUSH2 0x051b 04F9 57 *JUMPI 04FA 60 PUSH1 0x40 04FC 51 MLOAD 04FD 91 SWAP2 04FE 50 POP 04FF 60 PUSH1 0x1f 0501 19 NOT 0502 60 PUSH1 0x3f 0504 3D RETURNDATASIZE 0505 01 ADD 0506 16 AND 0507 82 DUP3 0508 01 ADD 0509 60 PUSH1 0x40 050B 52 MSTORE 050C 3D RETURNDATASIZE 050D 82 DUP3 050E 52 MSTORE 050F 3D RETURNDATASIZE 0510 60 PUSH1 0x00 0512 60 PUSH1 0x20 0514 84 DUP5 0515 01 ADD 0516 3E RETURNDATACOPY 0517 61 PUSH2 0x0520 051A 56 *JUMP 051B 5B JUMPDEST 051C 60 PUSH1 0x60 051E 91 SWAP2 051F 50 POP 0520 5B JUMPDEST 0521 50 POP 0522 91 SWAP2 0523 50 POP 0524 91 SWAP2 0525 50 POP 0526 61 PUSH2 0x0530 0529 82 DUP3 052A 82 DUP3 052B 86 DUP7 052C 61 PUSH2 0x069d 052F 56 *JUMP 0530 5B JUMPDEST 0531 96 SWAP7 0532 95 SWAP6 0533 50 POP 0534 50 POP 0535 50 POP 0536 50 POP 0537 50 POP 0538 50 POP 0539 56 *JUMP label_053A: // Incoming call from 0x034F, returns to 0x0350 053A 5B JUMPDEST 053B 60 PUSH1 0x00 053D 7F PUSH32 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc 055E 61 PUSH2 0x039d 0561 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @053B stack[0] = 0x00 // @053D stack[1] = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc // } // Block ends with unconditional jump to 0x039d label_0562: // Incoming jump from 0x03B4 // Inputs[1] { @0566 stack[-1] } 0562 5B JUMPDEST 0563 61 PUSH2 0x056b 0566 81 DUP2 0567 61 PUSH2 0x0298 056A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0563 stack[0] = 0x056b // @0566 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x0298 056B 5B JUMPDEST 056C 61 PUSH2 0x05cd 056F 57 *JUMPI 0570 60 PUSH1 0x40 0572 51 MLOAD 0573 62 PUSH3 0x461bcd 0577 60 PUSH1 0xe5 0579 1B SHL 057A 81 DUP2 057B 52 MSTORE 057C 60 PUSH1 0x20 057E 60 PUSH1 0x04 0580 82 DUP3 0581 01 ADD 0582 52 MSTORE 0583 60 PUSH1 0x2d 0585 60 PUSH1 0x24 0587 82 DUP3 0588 01 ADD 0589 52 MSTORE 058A 7F PUSH32 0x455243313936373a206e657720696d706c656d656e746174696f6e206973206e 05AB 60 PUSH1 0x44 05AD 82 DUP3 05AE 01 ADD 05AF 52 MSTORE 05B0 6C PUSH13 0x1bdd08184818dbdb9d1c9858dd 05BE 60 PUSH1 0x9a 05C0 1B SHL 05C1 60 PUSH1 0x64 05C3 82 DUP3 05C4 01 ADD 05C5 52 MSTORE 05C6 60 PUSH1 0x84 05C8 01 ADD 05C9 61 PUSH2 0x0338 05CC 56 *JUMP 05CD 5B JUMPDEST 05CE 80 DUP1 05CF 7F PUSH32 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc label_05F0: // Incoming jump from 0x069C // Inputs[4] // { // @05F1 stack[-1] // @05F2 storage[stack[-1]] // @0605 stack[-2] // @0610 stack[-4] // } 05F0 5B JUMPDEST 05F1 80 DUP1 05F2 54 SLOAD 05F3 60 PUSH1 0x01 05F5 60 PUSH1 0x01 05F7 60 PUSH1 0xa0 05F9 1B SHL 05FA 03 SUB 05FB 19 NOT 05FC 16 AND 05FD 60 PUSH1 0x01 05FF 60 PUSH1 0x01 0601 60 PUSH1 0xa0 0603 1B SHL 0604 03 SUB 0605 92 SWAP3 0606 90 SWAP1 0607 92 SWAP3 0608 16 AND 0609 91 SWAP2 060A 90 SWAP1 060B 91 SWAP2 060C 17 OR 060D 90 SWAP1 060E 55 SSTORE 060F 50 POP 0610 56 *JUMP // Stack delta = -4 // Outputs[1] { @060E storage[stack[-1]] = ((0x01 << 0xa0) - 0x01 & stack[-2]) | (~((0x01 << 0xa0) - 0x01) & storage[stack[-1]]) } // Block ends with unconditional jump to stack[-4] label_0611: // Incoming call from 0x045E, returns to 0x0161 // Inputs[1] { @061A stack[-1] } 0611 5B JUMPDEST 0612 60 PUSH1 0x01 0614 60 PUSH1 0x01 0616 60 PUSH1 0xa0 0618 1B SHL 0619 03 SUB 061A 81 DUP2 061B 16 AND 061C 61 PUSH2 0x0676 061F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0676, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0620: // Incoming jump from 0x061F, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0622 memory[0x40:0x60] } 0620 60 PUSH1 0x40 0622 51 MLOAD 0623 62 PUSH3 0x461bcd 0627 60 PUSH1 0xe5 0629 1B SHL 062A 81 DUP2 062B 52 MSTORE 062C 60 PUSH1 0x20 062E 60 PUSH1 0x04 0630 82 DUP3 0631 01 ADD 0632 52 MSTORE 0633 60 PUSH1 0x26 0635 60 PUSH1 0x24 0637 82 DUP3 0638 01 ADD 0639 52 MSTORE 063A 7F PUSH32 0x455243313936373a206e65772061646d696e20697320746865207a65726f2061 065B 60 PUSH1 0x44 065D 82 DUP3 065E 01 ADD 065F 52 MSTORE 0660 65 PUSH6 0x646472657373 0667 60 PUSH1 0xd0 0669 1B SHL 066A 60 PUSH1 0x64 066C 82 DUP3 066D 01 ADD 066E 52 MSTORE 066F 60 PUSH1 0x84 0671 01 ADD 0672 61 PUSH2 0x0338 0675 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @062B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0632 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0639 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @065F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313936373a206e65772061646d696e20697320746865207a65726f2061 // @066E memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @0671 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0338 label_0676: // Incoming jump from 0x061F, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0677 stack[-1] } 0676 5B JUMPDEST 0677 80 DUP1 0678 7F PUSH32 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103 0699 61 PUSH2 0x05f0 069C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0677 stack[0] = stack[-1] // @0678 stack[1] = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103 // } // Block ends with unconditional jump to 0x05f0 069D 5B JUMPDEST 069E 60 PUSH1 0x60 06A0 83 DUP4 06A1 15 ISZERO 06A2 61 PUSH2 0x06ac 06A5 57 *JUMPI 06A6 50 POP 06A7 81 DUP2 06A8 61 PUSH2 0x0291 06AB 56 *JUMP 06AC 5B JUMPDEST 06AD 82 DUP3 06AE 51 MLOAD 06AF 15 ISZERO 06B0 61 PUSH2 0x06bc 06B3 57 *JUMPI 06B4 82 DUP3 06B5 51 MLOAD 06B6 80 DUP1 06B7 84 DUP5 06B8 60 PUSH1 0x20 06BA 01 ADD 06BB FD *REVERT 06BC 5B JUMPDEST 06BD 81 DUP2 06BE 60 PUSH1 0x40 06C0 51 MLOAD 06C1 62 PUSH3 0x461bcd 06C5 60 PUSH1 0xe5 06C7 1B SHL 06C8 81 DUP2 06C9 52 MSTORE 06CA 60 PUSH1 0x04 06CC 01 ADD 06CD 61 PUSH2 0x0338 06D0 91 SWAP2 06D1 90 SWAP1 06D2 61 PUSH2 0x07a1 06D5 56 *JUMP label_06D6: // Incoming call from 0x0706, returns to 0x0291 // Incoming call from 0x0723, returns to 0x0724 // Inputs[2] // { // @06D7 stack[-1] // @06D8 msg.data[stack[-1]:stack[-1] + 0x20] // } 06D6 5B JUMPDEST 06D7 80 DUP1 06D8 35 CALLDATALOAD 06D9 60 PUSH1 0x01 06DB 60 PUSH1 0x01 06DD 60 PUSH1 0xa0 06DF 1B SHL 06E0 03 SUB 06E1 81 DUP2 06E2 16 AND 06E3 81 DUP2 06E4 14 EQ 06E5 61 PUSH2 0x029d 06E8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06D8 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x029d, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_06E9: // Incoming jump from 0x06E8, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @06EC memory[0x00:0x00] } 06E9 60 PUSH1 0x00 06EB 80 DUP1 06EC FD *REVERT // Stack delta = +0 // Outputs[1] { @06EC revert(memory[0x00:0x00]); } // Block terminates label_06ED: // Incoming call from 0x00E3, returns to 0x00E4 // Incoming call from 0x007F, returns to 0x0080 // Inputs[2] // { // @06F2 stack[-1] // @06F3 stack[-2] // } 06ED 5B JUMPDEST 06EE 60 PUSH1 0x00 06F0 60 PUSH1 0x20 06F2 82 DUP3 06F3 84 DUP5 06F4 03 SUB 06F5 12 SLT 06F6 15 ISZERO 06F7 61 PUSH2 0x06fe 06FA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06EE stack[0] = 0x00 } // Block ends with conditional jump to 0x06fe, if !(stack[-2] - stack[-1] i< 0x20) label_06FB: // Incoming jump from 0x06FA, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @06FB stack[-1] // @06FD memory[stack[-1]:stack[-1] + stack[-1]] // } 06FB 80 DUP1 06FC 81 DUP2 06FD FD *REVERT // Stack delta = +0 // Outputs[1] { @06FD revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_06FE: // Incoming jump from 0x06FA, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @0702 stack[-2] } 06FE 5B JUMPDEST 06FF 61 PUSH2 0x0291 0702 82 DUP3 0703 61 PUSH2 0x06d6 0706 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06FF stack[0] = 0x0291 // @0702 stack[1] = stack[-2] // } // Block ends with call to 0x06d6, returns to 0x0291 label_0707: // Incoming call from 0x0092, returns to 0x0093 // Inputs[2] // { // @070F stack[-1] // @0710 stack[-2] // } 0707 5B JUMPDEST 0708 60 PUSH1 0x00 070A 80 DUP1 070B 60 PUSH1 0x00 070D 60 PUSH1 0x40 070F 84 DUP5 0710 86 DUP7 0711 03 SUB 0712 12 SLT 0713 15 ISZERO 0714 61 PUSH2 0x071b 0717 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0708 stack[0] = 0x00 // @070A stack[1] = 0x00 // @070B stack[2] = 0x00 // } // Block ends with conditional jump to 0x071b, if !(stack[-2] - stack[-1] i< 0x40) label_0718: // Incoming jump from 0x0717, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @0718 stack[-2] // @071A memory[stack[-2]:stack[-2] + stack[-2]] // } 0718 81 DUP2 0719 82 DUP3 071A FD *REVERT // Stack delta = +0 // Outputs[1] { @071A revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_071B: // Incoming jump from 0x0717, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @071F stack[-4] } 071B 5B JUMPDEST 071C 61 PUSH2 0x0724 071F 84 DUP5 0720 61 PUSH2 0x06d6 0723 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @071C stack[0] = 0x0724 // @071F stack[1] = stack[-4] // } // Block ends with call to 0x06d6, returns to 0x0724 label_0724: // Incoming return from call to 0x06D6 at 0x0723 // Inputs[4] // { // @0725 stack[-4] // @0725 stack[-1] // @0729 stack[-5] // @072B msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 0724 5B JUMPDEST 0725 92 SWAP3 0726 50 POP 0727 60 PUSH1 0x20 0729 84 DUP5 072A 01 ADD 072B 35 CALLDATALOAD 072C 67 PUSH8 0xffffffffffffffff 0735 80 DUP1 0736 82 DUP3 0737 11 GT 0738 15 ISZERO 0739 61 PUSH2 0x0740 073C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0725 stack[-4] = stack[-1] // @072B stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @072C stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x0740, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) label_073D: // Incoming jump from 0x073C, if not !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @073D stack[-4] // @073F memory[stack[-4]:stack[-4] + stack[-4]] // } 073D 83 DUP4 073E 84 DUP5 073F FD *REVERT // Stack delta = +0 // Outputs[1] { @073F revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_0740: // Incoming jump from 0x073C, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @0741 stack[-2] // @0742 stack[-6] // @0746 stack[-7] // } 0740 5B JUMPDEST 0741 81 DUP2 0742 86 DUP7 0743 01 ADD 0744 91 SWAP2 0745 50 POP 0746 86 DUP7 0747 60 PUSH1 0x1f 0749 83 DUP4 074A 01 ADD 074B 12 SLT 074C 61 PUSH2 0x0753 074F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0744 stack[-2] = stack[-6] + stack[-2] } // Block ends with conditional jump to 0x0753, if stack[-6] + stack[-2] + 0x1f i< stack[-7] label_0750: // Incoming jump from 0x074F, if not stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[2] // { // @0750 stack[-4] // @0752 memory[stack[-4]:stack[-4] + stack[-4]] // } 0750 83 DUP4 0751 84 DUP5 0752 FD *REVERT // Stack delta = +0 // Outputs[1] { @0752 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_0753: // Incoming jump from 0x074F, if stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[3] // { // @0754 stack[-2] // @0755 msg.data[stack[-2]:stack[-2] + 0x20] // @0756 stack[-1] // } 0753 5B JUMPDEST 0754 81 DUP2 0755 35 CALLDATALOAD 0756 81 DUP2 0757 81 DUP2 0758 11 GT 0759 15 ISZERO 075A 61 PUSH2 0x0761 075D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0755 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0761, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_075E: // Incoming jump from 0x075D, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[2] // { // @075E stack[-5] // @0760 memory[stack[-5]:stack[-5] + stack[-5]] // } 075E 84 DUP5 075F 85 DUP6 0760 FD *REVERT // Stack delta = +0 // Outputs[1] { @0760 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_0761: // Incoming jump from 0x075D, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @0762 stack[-8] // @0765 stack[-1] // @0766 stack[-3] // } 0761 5B JUMPDEST 0762 87 DUP8 0763 60 PUSH1 0x20 0765 82 DUP3 0766 85 DUP6 0767 01 ADD 0768 01 ADD 0769 11 GT 076A 15 ISZERO 076B 61 PUSH2 0x0772 076E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0772, if !(stack[-3] + stack[-1] + 0x20 > stack[-8]) label_076F: // Incoming jump from 0x076E, if not !(stack[-3] + stack[-1] + 0x20 > stack[-8]) // Inputs[2] // { // @076F stack[-5] // @0771 memory[stack[-5]:stack[-5] + stack[-5]] // } 076F 84 DUP5 0770 85 DUP6 0771 FD *REVERT // Stack delta = +0 // Outputs[1] { @0771 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_0772: // Incoming jump from 0x076E, if !(stack[-3] + stack[-1] + 0x20 > stack[-8]) // Inputs[8] // { // @0775 stack[-3] // @0777 stack[-5] // @0779 stack[-1] // @077A stack[-4] // @077F stack[-7] // @0781 stack[-8] // @0783 stack[-9] // @0783 stack[-6] // } 0772 5B JUMPDEST 0773 60 PUSH1 0x20 0775 83 DUP4 0776 01 ADD 0777 94 SWAP5 0778 50 POP 0779 80 DUP1 077A 93 SWAP4 077B 50 POP 077C 50 POP 077D 50 POP 077E 50 POP 077F 92 SWAP3 0780 50 POP 0781 92 SWAP3 0782 50 POP 0783 92 SWAP3 0784 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @077F stack[-7] = stack[-1] // @0781 stack[-8] = stack[-3] + 0x20 // @0783 stack[-9] = stack[-6] // } // Block ends with unconditional jump to stack[-9] 0785 5B JUMPDEST 0786 60 PUSH1 0x00 0788 82 DUP3 0789 51 MLOAD 078A 61 PUSH2 0x0797 078D 81 DUP2 078E 84 DUP5 078F 60 PUSH1 0x20 0791 87 DUP8 0792 01 ADD 0793 61 PUSH2 0x07d4 0796 56 *JUMP 0797 5B JUMPDEST 0798 91 SWAP2 0799 90 SWAP1 079A 91 SWAP2 079B 01 ADD 079C 92 SWAP3 079D 91 SWAP2 079E 50 POP 079F 50 POP 07A0 56 *JUMP 07A1 5B JUMPDEST 07A2 60 PUSH1 0x00 07A4 60 PUSH1 0x20 07A6 82 DUP3 07A7 52 MSTORE 07A8 82 DUP3 07A9 51 MLOAD 07AA 80 DUP1 07AB 60 PUSH1 0x20 07AD 84 DUP5 07AE 01 ADD 07AF 52 MSTORE 07B0 61 PUSH2 0x07c0 07B3 81 DUP2 07B4 60 PUSH1 0x40 07B6 85 DUP6 07B7 01 ADD 07B8 60 PUSH1 0x20 07BA 87 DUP8 07BB 01 ADD 07BC 61 PUSH2 0x07d4 07BF 56 *JUMP 07C0 5B JUMPDEST 07C1 60 PUSH1 0x1f 07C3 01 ADD 07C4 60 PUSH1 0x1f 07C6 19 NOT 07C7 16 AND 07C8 91 SWAP2 07C9 90 SWAP1 07CA 91 SWAP2 07CB 01 ADD 07CC 60 PUSH1 0x40 07CE 01 ADD 07CF 92 SWAP3 07D0 91 SWAP2 07D1 50 POP 07D2 50 POP 07D3 56 *JUMP 07D4 5B JUMPDEST 07D5 60 PUSH1 0x00 07D7 5B JUMPDEST 07D8 83 DUP4 07D9 81 DUP2 07DA 10 LT 07DB 15 ISZERO 07DC 61 PUSH2 0x07ef 07DF 57 *JUMPI 07E0 81 DUP2 07E1 81 DUP2 07E2 01 ADD 07E3 51 MLOAD 07E4 83 DUP4 07E5 82 DUP3 07E6 01 ADD 07E7 52 MSTORE 07E8 60 PUSH1 0x20 07EA 01 ADD 07EB 61 PUSH2 0x07d7 07EE 56 *JUMP 07EF 5B JUMPDEST 07F0 83 DUP4 07F1 81 DUP2 07F2 11 GT 07F3 15 ISZERO 07F4 61 PUSH2 0x0405 07F7 57 *JUMPI 07F8 50 POP 07F9 50 POP 07FA 60 PUSH1 0x00 07FC 91 SWAP2 07FD 01 ADD 07FE 52 MSTORE 07FF 56 *JUMP 0800 FE *ASSERT 0801 41 COINBASE 0802 64 PUSH5 0x6472657373 0808 3A GASPRICE 0809 20 SHA3 080A 6C PUSH13 0x6f772d6c6576656c2064656c65 0818 67 PUSH8 0x6174652063616c6c 0821 20 SHA3 0822 66 PUSH7 0x61696c6564a264 082A 69 PUSH10 0x7066735822122093f028 0835 25 25 0836 50 POP 0837 35 CALLDATALOAD 0838 B6 B6 0839 1D SAR 083A F4 DELEGATECALL 083B 76 PUSH23 0xb13b9dba3c4f06f60e51b9b4caee31680b389aef327f64 0853 73 PUSH20 0x6f6c63430008020033