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 0x0080 at 0x007F 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 0x06ca 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 0x06ca, returns to 0x0080 label_0080: // Incoming return from call to 0x06CA 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 0x06e5 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 0x06e5, returns to 0x0093 label_0093: // Incoming return from call to 0x06E5 at 0x0092 0093 5B JUMPDEST 0094 61 PUSH2 0x015f 0097 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x015f 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 0x01d0 00AC 56 *JUMP // Stack delta = +0 // Outputs[1] { @00A6 stack[-1] = 0x00ad } // Block ends with unconditional jump to 0x01d0 label_00AD: // Incoming return from call to 0x0235 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 0x06ca 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 0x06ca, returns to 0x00E4 label_00E4: // Incoming return from call to 0x06CA at 0x00E3 00E4 5B JUMPDEST 00E5 61 PUSH2 0x020b 00E8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x020b 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 0x0235 00FD 56 *JUMP // Stack delta = +0 // Outputs[1] { @00F7 stack[-1] = 0x00ad } // Block ends with call to 0x0235, returns to 0x00AD label_00FE: // Incoming jump from 0x015E // Incoming jump from 0x005A // Incoming jump from 0x0064 // Incoming jump from 0x01CF // Incoming jump from 0x0207 00FE 5B JUMPDEST 00FF 61 PUSH2 0x0106 0102 61 PUSH2 0x0292 0105 56 *JUMP // Stack delta = +1 // Outputs[1] { @00FF stack[0] = 0x0106 } // Block ends with call to 0x0292, returns to 0x0106 label_0106: // Incoming return from call to 0x0292 at 0x0105 0106 5B JUMPDEST 0107 61 PUSH2 0x0116 010A 61 PUSH2 0x0111 010D 61 PUSH2 0x0331 0110 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0107 stack[0] = 0x0116 // @010A stack[1] = 0x0111 // } // Block ends with call to 0x0331, returns to 0x0111 label_0111: // Incoming return from call to 0x0331 at 0x0110 0111 5B JUMPDEST 0112 61 PUSH2 0x033b 0115 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x033b label_0116: // Incoming jump from 0x02B3, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) // 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 0x035f 011F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0119 stack[0] = 0x0120 } // Block ends with call to 0x035f, returns to 0x0120 label_0120: // Incoming return from call to 0x035F 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 0x0157 0139 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0157, 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 0x0392 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 call to 0x0392, returns to 0x0154 label_0154: // Incoming return from call to 0x03F1 at 0x0234 // Incoming return from call to 0x0392 at 0x0153 // Incoming return from call to 0x05E9 at 0x0444 // Inputs[1] { @0156 stack[-2] } 0154 5B JUMPDEST 0155 50 POP 0156 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0157: // Incoming jump from 0x0139, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) // Incoming jump from 0x022C, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) 0157 5B JUMPDEST 0158 61 PUSH2 0x0154 015B 61 PUSH2 0x00fe 015E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0158 stack[0] = 0x0154 } // Block ends with unconditional jump to 0x00fe label_015F: // Incoming jump from 0x0097 015F 5B JUMPDEST 0160 61 PUSH2 0x0167 0163 61 PUSH2 0x035f 0166 56 *JUMP // Stack delta = +1 // Outputs[1] { @0160 stack[0] = 0x0167 } // Block ends with call to 0x035f, returns to 0x0167 label_0167: // Incoming return from call to 0x035F at 0x0166 // Inputs[2] // { // @0170 stack[-1] // @0171 msg.sender // } 0167 5B JUMPDEST 0168 60 PUSH1 0x01 016A 60 PUSH1 0x01 016C 60 PUSH1 0xa0 016E 1B SHL 016F 03 SUB 0170 16 AND 0171 33 CALLER 0172 60 PUSH1 0x01 0174 60 PUSH1 0x01 0176 60 PUSH1 0xa0 0178 1B SHL 0179 03 SUB 017A 16 AND 017B 14 EQ 017C 15 ISZERO 017D 61 PUSH2 0x01c8 0180 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01c8, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0181: // Incoming jump from 0x0180, if not !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[5] // { // @0184 stack[-3] // @0185 stack[-2] // @0186 stack[-1] // @0197 memory[0x40:0x60] // @01AE msg.data[stack[-2]:stack[-2] + stack[-1]] // } 0181 61 PUSH2 0x01c3 0184 83 DUP4 0185 83 DUP4 0186 83 DUP4 0187 80 DUP1 0188 80 DUP1 0189 60 PUSH1 0x1f 018B 01 ADD 018C 60 PUSH1 0x20 018E 80 DUP1 018F 91 SWAP2 0190 04 DIV 0191 02 MUL 0192 60 PUSH1 0x20 0194 01 ADD 0195 60 PUSH1 0x40 0197 51 MLOAD 0198 90 SWAP1 0199 81 DUP2 019A 01 ADD 019B 60 PUSH1 0x40 019D 52 MSTORE 019E 80 DUP1 019F 93 SWAP4 01A0 92 SWAP3 01A1 91 SWAP2 01A2 90 SWAP1 01A3 81 DUP2 01A4 81 DUP2 01A5 52 MSTORE 01A6 60 PUSH1 0x20 01A8 01 ADD 01A9 83 DUP4 01AA 83 DUP4 01AB 80 DUP1 01AC 82 DUP3 01AD 84 DUP5 01AE 37 CALLDATACOPY 01AF 60 PUSH1 0x00 01B1 92 SWAP3 01B2 01 ADD 01B3 91 SWAP2 01B4 90 SWAP1 01B5 91 SWAP2 01B6 52 MSTORE 01B7 50 POP 01B8 60 PUSH1 0x01 01BA 92 SWAP3 01BB 50 POP 01BC 61 PUSH2 0x0392 01BF 91 SWAP2 01C0 50 POP 01C1 50 POP 01C2 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @0181 stack[0] = 0x01c3 // @0184 stack[1] = stack[-3] // @019D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @019F stack[2] = memory[0x40:0x60] // @01A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @01AE memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]] // @01B6 memory[0x20 + memory[0x40:0x60] + stack[-1]:0x20 + memory[0x40:0x60] + stack[-1] + 0x20] = 0x00 // @01BA stack[3] = 0x01 // } // Block ends with call to 0x0392, returns to 0x01C3 label_01C3: // Incoming jump from 0x03E1, if !stack[-2] // Incoming return from call to 0x0392 at 0x01C2 // Incoming jump from 0x03E1, if !stack[-1] // Inputs[1] { @01C7 stack[-4] } 01C3 5B JUMPDEST 01C4 50 POP 01C5 50 POP 01C6 50 POP 01C7 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_01C8: // Incoming jump from 0x0180, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) 01C8 5B JUMPDEST 01C9 61 PUSH2 0x01c3 01CC 61 PUSH2 0x00fe 01CF 56 *JUMP // Stack delta = +1 // Outputs[1] { @01C9 stack[0] = 0x01c3 } // Block ends with unconditional jump to 0x00fe label_01D0: // Incoming jump from 0x00AC 01D0 5B JUMPDEST 01D1 60 PUSH1 0x00 01D3 61 PUSH2 0x01da 01D6 61 PUSH2 0x035f 01D9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @01D1 stack[0] = 0x00 // @01D3 stack[1] = 0x01da // } // Block ends with call to 0x035f, returns to 0x01DA label_01DA: // Incoming return from call to 0x035F at 0x01D9 // Inputs[2] // { // @01E3 stack[-1] // @01E4 msg.sender // } 01DA 5B JUMPDEST 01DB 60 PUSH1 0x01 01DD 60 PUSH1 0x01 01DF 60 PUSH1 0xa0 01E1 1B SHL 01E2 03 SUB 01E3 16 AND 01E4 33 CALLER 01E5 60 PUSH1 0x01 01E7 60 PUSH1 0x01 01E9 60 PUSH1 0xa0 01EB 1B SHL 01EC 03 SUB 01ED 16 AND 01EE 14 EQ 01EF 15 ISZERO 01F0 61 PUSH2 0x0200 01F3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0200, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) label_01F4: // Incoming jump from 0x01F3, if not !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) 01F4 61 PUSH2 0x01fb 01F7 61 PUSH2 0x0331 01FA 56 *JUMP // Stack delta = +1 // Outputs[1] { @01F4 stack[0] = 0x01fb } // Block ends with call to 0x0331, returns to 0x01FB label_01FB: // Incoming return from call to 0x0331 at 0x01FA // Incoming return from call to 0x035F at 0x025F // Incoming return from call to 0x0519 at 0x033A // Inputs[3] // { // @01FC stack[-1] // @01FC stack[-2] // @01FE stack[-3] // } 01FB 5B JUMPDEST 01FC 90 SWAP1 01FD 50 POP 01FE 90 SWAP1 01FF 56 *JUMP // Stack delta = -2 // Outputs[1] { @01FE stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_0200: // Incoming jump from 0x0258, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) // Incoming jump from 0x01F3, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) 0200 5B JUMPDEST 0201 61 PUSH2 0x0208 0204 61 PUSH2 0x00fe 0207 56 *JUMP // Stack delta = +1 // Outputs[1] { @0201 stack[0] = 0x0208 } // Block ends with unconditional jump to 0x00fe 0208 5B JUMPDEST 0209 90 SWAP1 020A 56 *JUMP label_020B: // Incoming jump from 0x00E8 020B 5B JUMPDEST 020C 61 PUSH2 0x0213 020F 61 PUSH2 0x035f 0212 56 *JUMP // Stack delta = +1 // Outputs[1] { @020C stack[0] = 0x0213 } // Block ends with call to 0x035f, returns to 0x0213 label_0213: // Incoming return from call to 0x035F at 0x0212 // Inputs[2] // { // @021C stack[-1] // @021D msg.sender // } 0213 5B JUMPDEST 0214 60 PUSH1 0x01 0216 60 PUSH1 0x01 0218 60 PUSH1 0xa0 021A 1B SHL 021B 03 SUB 021C 16 AND 021D 33 CALLER 021E 60 PUSH1 0x01 0220 60 PUSH1 0x01 0222 60 PUSH1 0xa0 0224 1B SHL 0225 03 SUB 0226 16 AND 0227 14 EQ 0228 15 ISZERO 0229 61 PUSH2 0x0157 022C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0157, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) label_022D: // Incoming jump from 0x022C, if not !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @0230 stack[-1] } 022D 61 PUSH2 0x0154 0230 81 DUP2 0231 61 PUSH2 0x03f1 0234 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @022D stack[0] = 0x0154 // @0230 stack[1] = stack[-1] // } // Block ends with call to 0x03f1, returns to 0x0154 label_0235: // Incoming call from 0x00FD, returns to 0x00AD 0235 5B JUMPDEST 0236 60 PUSH1 0x00 0238 61 PUSH2 0x023f 023B 61 PUSH2 0x035f 023E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0236 stack[0] = 0x00 // @0238 stack[1] = 0x023f // } // Block ends with call to 0x035f, returns to 0x023F label_023F: // Incoming return from call to 0x035F at 0x023E // Inputs[2] // { // @0248 stack[-1] // @0249 msg.sender // } 023F 5B JUMPDEST 0240 60 PUSH1 0x01 0242 60 PUSH1 0x01 0244 60 PUSH1 0xa0 0246 1B SHL 0247 03 SUB 0248 16 AND 0249 33 CALLER 024A 60 PUSH1 0x01 024C 60 PUSH1 0x01 024E 60 PUSH1 0xa0 0250 1B SHL 0251 03 SUB 0252 16 AND 0253 14 EQ 0254 15 ISZERO 0255 61 PUSH2 0x0200 0258 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0200, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0259: // Incoming jump from 0x0258, if not !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) 0259 61 PUSH2 0x01fb 025C 61 PUSH2 0x035f 025F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0259 stack[0] = 0x01fb } // Block ends with call to 0x035f, returns to 0x01FB label_0260: // Incoming jump from 0x03EA // Inputs[3] // { // @0266 stack[-2] // @0267 stack[-1] // @026A memory[0x40:0x60] // } 0260 5B JUMPDEST 0261 60 PUSH1 0x60 0263 61 PUSH2 0x0285 0266 83 DUP4 0267 83 DUP4 0268 60 PUSH1 0x40 026A 51 MLOAD 026B 80 DUP1 026C 60 PUSH1 0x60 026E 01 ADD 026F 60 PUSH1 0x40 0271 52 MSTORE 0272 80 DUP1 0273 60 PUSH1 0x27 0275 81 DUP2 0276 52 MSTORE 0277 60 PUSH1 0x20 0279 01 ADD 027A 61 PUSH2 0x07e4 027D 60 PUSH1 0x27 027F 91 SWAP2 0280 39 CODECOPY 0281 61 PUSH2 0x0445 0284 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @0261 stack[0] = 0x60 // @0263 stack[1] = 0x0285 // @0266 stack[2] = stack[-2] // @0267 stack[3] = stack[-1] // @026A stack[4] = memory[0x40:0x60] // @0271 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @0276 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x27 // @0280 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x27] = code[0x07e4:0x080b] // } // Block ends with call to 0x0445, returns to 0x0285 label_0285: // Incoming jump from 0x0683 // Incoming return from call to 0x0445 at 0x0284 // Incoming return from call to 0x06AE at 0x06E4 // Inputs[3] // { // @0286 stack[-5] // @0286 stack[-1] // @0287 stack[-4] // } 0285 5B JUMPDEST 0286 93 SWAP4 0287 92 SWAP3 0288 50 POP 0289 50 POP 028A 50 POP 028B 56 *JUMP // Stack delta = -4 // Outputs[1] { @0286 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] 028C 5B JUMPDEST 028D 3B EXTCODESIZE 028E 15 ISZERO 028F 15 ISZERO 0290 90 SWAP1 0291 56 *JUMP label_0292: // Incoming call from 0x0105, returns to 0x0106 0292 5B JUMPDEST 0293 61 PUSH2 0x029a 0296 61 PUSH2 0x035f 0299 56 *JUMP // Stack delta = +1 // Outputs[1] { @0293 stack[0] = 0x029a } // Block ends with call to 0x035f, returns to 0x029A label_029A: // Incoming return from call to 0x035F at 0x0299 // Inputs[2] // { // @02A3 stack[-1] // @02A4 msg.sender // } 029A 5B JUMPDEST 029B 60 PUSH1 0x01 029D 60 PUSH1 0x01 029F 60 PUSH1 0xa0 02A1 1B SHL 02A2 03 SUB 02A3 16 AND 02A4 33 CALLER 02A5 60 PUSH1 0x01 02A7 60 PUSH1 0x01 02A9 60 PUSH1 0xa0 02AB 1B SHL 02AC 03 SUB 02AD 16 AND 02AE 14 EQ 02AF 15 ISZERO 02B0 61 PUSH2 0x0116 02B3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0116, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) label_02B4: // Incoming jump from 0x02B3, if not !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @02B6 memory[0x40:0x60] // @032B memory[0x40:0x60] // @0330 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02B4 60 PUSH1 0x40 02B6 51 MLOAD 02B7 62 PUSH3 0x461bcd 02BB 60 PUSH1 0xe5 02BD 1B SHL 02BE 81 DUP2 02BF 52 MSTORE 02C0 60 PUSH1 0x20 02C2 60 PUSH1 0x04 02C4 82 DUP3 02C5 01 ADD 02C6 52 MSTORE 02C7 60 PUSH1 0x42 02C9 60 PUSH1 0x24 02CB 82 DUP3 02CC 01 ADD 02CD 52 MSTORE 02CE 7F PUSH32 0x5472616e73706172656e745570677261646561626c6550726f78793a2061646d 02EF 60 PUSH1 0x44 02F1 82 DUP3 02F2 01 ADD 02F3 52 MSTORE 02F4 7F PUSH32 0x696e2063616e6e6f742066616c6c6261636b20746f2070726f78792074617267 0315 60 PUSH1 0x64 0317 82 DUP3 0318 01 ADD 0319 52 MSTORE 031A 61 PUSH2 0x195d 031D 60 PUSH1 0xf2 031F 1B SHL 0320 60 PUSH1 0x84 0322 82 DUP3 0323 01 ADD 0324 52 MSTORE 0325 60 PUSH1 0xa4 0327 01 ADD 0328 5B JUMPDEST 0329 60 PUSH1 0x40 032B 51 MLOAD 032C 80 DUP1 032D 91 SWAP2 032E 03 SUB 032F 90 SWAP1 0330 FD *REVERT // Stack delta = +0 // Outputs[7] // { // @02BF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @02C6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @02CD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x42 // @02F3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5472616e73706172656e745570677261646561626c6550726f78793a2061646d // @0319 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x696e2063616e6e6f742066616c6c6261636b20746f2070726f78792074617267 // @0324 memory[memory[0x40:0x60] + 0x84:memory[0x40:0x60] + 0x84 + 0x20] = 0x195d << 0xf2 // @0330 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0331: // Incoming call from 0x0110, returns to 0x0111 // Incoming call from 0x01FA, returns to 0x01FB 0331 5B JUMPDEST 0332 60 PUSH1 0x00 0334 61 PUSH2 0x01fb 0337 61 PUSH2 0x0519 033A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0332 stack[0] = 0x00 // @0334 stack[1] = 0x01fb // } // Block ends with call to 0x0519, returns to 0x01FB label_033B: // Incoming jump from 0x0115 // Inputs[9] // { // @033C msg.data.length // @0340 msg.data[0x00:0x00 + msg.data.length] // @0344 msg.data.length // @0347 stack[-1] // @0348 msg.gas // @0349 memory[0x00:0x00 + msg.data.length] // @0349 address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @034A returndata.length // @034E returndata[0x00:0x00 + returndata.length] // } 033B 5B JUMPDEST 033C 36 CALLDATASIZE 033D 60 PUSH1 0x00 033F 80 DUP1 0340 37 CALLDATACOPY 0341 60 PUSH1 0x00 0343 80 DUP1 0344 36 CALLDATASIZE 0345 60 PUSH1 0x00 0347 84 DUP5 0348 5A GAS 0349 F4 DELEGATECALL 034A 3D RETURNDATASIZE 034B 60 PUSH1 0x00 034D 80 DUP1 034E 3E RETURNDATACOPY 034F 80 DUP1 0350 80 DUP1 0351 15 ISZERO 0352 61 PUSH2 0x035a 0355 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @0340 memory[0x00:0x00 + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @0349 memory[0x00:0x00] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @0349 stack[0] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @034E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @034F stack[1] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // } // Block ends with conditional jump to 0x035a, if !address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) label_0356: // Incoming jump from 0x0355, if not !address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // Inputs[2] // { // @0356 returndata.length // @0359 memory[0x00:0x00 + returndata.length] // } 0356 3D RETURNDATASIZE 0357 60 PUSH1 0x00 0359 F3 *RETURN // Stack delta = +0 // Outputs[1] { @0359 return memory[0x00:0x00 + returndata.length]; } // Block terminates label_035A: // Incoming jump from 0x0355, if !address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // Inputs[2] // { // @035B returndata.length // @035E memory[0x00:0x00 + returndata.length] // } 035A 5B JUMPDEST 035B 3D RETURNDATASIZE 035C 60 PUSH1 0x00 035E FD *REVERT // Stack delta = +0 // Outputs[1] { @035E revert(memory[0x00:0x00 + returndata.length]); } // Block terminates label_035F: // Incoming call from 0x0419, returns to 0x041A // Incoming call from 0x0212, returns to 0x0213 // Incoming call from 0x01D9, returns to 0x01DA // Incoming call from 0x011F, returns to 0x0120 // Incoming call from 0x0299, returns to 0x029A // Incoming call from 0x0166, returns to 0x0167 // Incoming call from 0x025F, returns to 0x01FB // Incoming call from 0x023E, returns to 0x023F // Inputs[2] // { // @0384 storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] // @038E stack[-1] // } 035F 5B JUMPDEST 0360 60 PUSH1 0x00 0362 7F PUSH32 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103 0383 5B JUMPDEST 0384 54 SLOAD 0385 60 PUSH1 0x01 0387 60 PUSH1 0x01 0389 60 PUSH1 0xa0 038B 1B SHL 038C 03 SUB 038D 16 AND 038E 91 SWAP2 038F 90 SWAP1 0390 50 POP 0391 56 *JUMP // Stack delta = +0 // Outputs[1] { @038E stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] } // Block ends with unconditional jump to stack[-1] label_0392: // Incoming call from 0x0153, returns to 0x0154 // Incoming call from 0x01C2, returns to 0x01C3 // Inputs[1] { @0396 stack[-3] } 0392 5B JUMPDEST 0393 61 PUSH2 0x039b 0396 83 DUP4 0397 61 PUSH2 0x0541 039A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0393 stack[0] = 0x039b // @0396 stack[1] = stack[-3] // } // Block ends with call to 0x0541, returns to 0x039B label_039B: // Incoming return from call to 0x0541 at 0x039A // Inputs[5] // { // @039E memory[0x40:0x60] // @03A7 stack[-3] // @03CF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @03D2 stack[-2] // @03D3 memory[stack[-2]:stack[-2] + 0x20] // } 039B 5B JUMPDEST 039C 60 PUSH1 0x40 039E 51 MLOAD 039F 60 PUSH1 0x01 03A1 60 PUSH1 0x01 03A3 60 PUSH1 0xa0 03A5 1B SHL 03A6 03 SUB 03A7 84 DUP5 03A8 16 AND 03A9 90 SWAP1 03AA 7F PUSH32 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b 03CB 90 SWAP1 03CC 60 PUSH1 0x00 03CE 90 SWAP1 03CF A2 LOG2 03D0 60 PUSH1 0x00 03D2 82 DUP3 03D3 51 MLOAD 03D4 11 GT 03D5 80 DUP1 03D6 61 PUSH2 0x03dc 03D9 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @03CF log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b, stack[-3] & (0x01 << 0xa0) - 0x01]); // @03D4 stack[0] = memory[stack[-2]:stack[-2] + 0x20] > 0x00 // } // Block ends with conditional jump to 0x03dc, if memory[stack[-2]:stack[-2] + 0x20] > 0x00 label_03DA: // Incoming jump from 0x03D9, if not memory[stack[-2]:stack[-2] + 0x20] > 0x00 // Inputs[1] { @03DB stack[-2] } 03DA 50 POP 03DB 80 DUP1 03DC 5B JUMPDEST 03DD 15 ISZERO 03DE 61 PUSH2 0x01c3 03E1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01c3, if !stack[-2] label_03E2: // Incoming jump from 0x03E1, if not !stack[-1] // Incoming jump from 0x03E1, if not !stack[-2] // Inputs[2] // { // @03E5 stack[-3] // @03E6 stack[-2] // } 03E2 61 PUSH2 0x03eb 03E5 83 DUP4 03E6 83 DUP4 03E7 61 PUSH2 0x0260 03EA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @03E2 stack[0] = 0x03eb // @03E5 stack[1] = stack[-3] // @03E6 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x0260 label_03EB: // Incoming jump from 0x078B, if !(stack[-1] > stack[-4]) // Inputs[1] { @03F0 stack[-5] } 03EB 5B JUMPDEST 03EC 50 POP 03ED 50 POP 03EE 50 POP 03EF 50 POP 03F0 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_03F1: // Incoming call from 0x0234, returns to 0x0154 03F1 5B JUMPDEST 03F2 7F PUSH32 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f 0413 61 PUSH2 0x041a 0416 61 PUSH2 0x035f 0419 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @03F2 stack[0] = 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f // @0413 stack[1] = 0x041a // } // Block ends with call to 0x035f, returns to 0x041A label_041A: // Incoming return from call to 0x035F at 0x0419 // Inputs[6] // { // @041E memory[0x40:0x60] // @0427 stack[-1] // @042D stack[-3] // @0437 memory[0x40:0x60] // @043C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]] // @043C stack[-2] // } 041A 5B JUMPDEST 041B 60 PUSH1 0x40 041D 80 DUP1 041E 51 MLOAD 041F 60 PUSH1 0x01 0421 60 PUSH1 0x01 0423 60 PUSH1 0xa0 0425 1B SHL 0426 03 SUB 0427 92 SWAP3 0428 83 DUP4 0429 16 AND 042A 81 DUP2 042B 52 MSTORE 042C 91 SWAP2 042D 84 DUP5 042E 16 AND 042F 60 PUSH1 0x20 0431 83 DUP4 0432 01 ADD 0433 52 MSTORE 0434 01 ADD 0435 60 PUSH1 0x40 0437 51 MLOAD 0438 80 DUP1 0439 91 SWAP2 043A 03 SUB 043B 90 SWAP1 043C A1 LOG1 043D 61 PUSH2 0x0154 0440 81 DUP2 0441 61 PUSH2 0x05e9 0444 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @042B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0433 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @043C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]], [stack[-2]]); // @043D stack[-2] = 0x0154 // @0440 stack[-1] = stack[-3] // } // Block ends with call to 0x05e9, returns to 0x0154 label_0445: // Incoming call from 0x0284, returns to 0x0285 // Inputs[2] // { // @0448 stack[-3] // @0449 address(stack[-3]).code.length // } 0445 5B JUMPDEST 0446 60 PUSH1 0x60 0448 83 DUP4 0449 3B EXTCODESIZE 044A 61 PUSH2 0x04a4 044D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0446 stack[0] = 0x60 } // Block ends with conditional jump to 0x04a4, if address(stack[-3]).code.length label_044E: // Incoming jump from 0x044D, if not address(stack[-3]).code.length // Inputs[1] { @0450 memory[0x40:0x60] } 044E 60 PUSH1 0x40 0450 51 MLOAD 0451 62 PUSH3 0x461bcd 0455 60 PUSH1 0xe5 0457 1B SHL 0458 81 DUP2 0459 52 MSTORE 045A 60 PUSH1 0x20 045C 60 PUSH1 0x04 045E 82 DUP3 045F 01 ADD 0460 52 MSTORE 0461 60 PUSH1 0x26 0463 60 PUSH1 0x24 0465 82 DUP3 0466 01 ADD 0467 52 MSTORE 0468 7F PUSH32 0x416464726573733a2064656c65676174652063616c6c20746f206e6f6e2d636f 0489 60 PUSH1 0x44 048B 82 DUP3 048C 01 ADD 048D 52 MSTORE 048E 65 PUSH6 0x1b9d1c9858dd 0495 60 PUSH1 0xd2 0497 1B SHL 0498 60 PUSH1 0x64 049A 82 DUP3 049B 01 ADD 049C 52 MSTORE 049D 60 PUSH1 0x84 049F 01 ADD 04A0 61 PUSH2 0x0328 04A3 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0459 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0460 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0467 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @048D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416464726573733a2064656c65676174652063616c6c20746f206e6f6e2d636f // @049C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x1b9d1c9858dd << 0xd2 // @049F stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0328 label_04A4: // Incoming jump from 0x044D, if address(stack[-3]).code.length // Inputs[3] // { // @04A8 stack[-4] // @04B2 stack[-3] // @04B5 memory[0x40:0x60] // } 04A4 5B JUMPDEST 04A5 60 PUSH1 0x00 04A7 80 DUP1 04A8 85 DUP6 04A9 60 PUSH1 0x01 04AB 60 PUSH1 0x01 04AD 60 PUSH1 0xa0 04AF 1B SHL 04B0 03 SUB 04B1 16 AND 04B2 85 DUP6 04B3 60 PUSH1 0x40 04B5 51 MLOAD 04B6 61 PUSH2 0x04bf 04B9 91 SWAP2 04BA 90 SWAP1 04BB 61 PUSH2 0x0794 04BE 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @04A5 stack[0] = 0x00 // @04A7 stack[1] = 0x00 // @04B1 stack[2] = (0x01 << 0xa0) - 0x01 & stack[-4] // @04B9 stack[3] = 0x04bf // @04BA stack[4] = stack[-3] // @04BA stack[5] = memory[0x40:0x60] // } // Block ends with call to 0x0794, returns to 0x04BF label_04BF: // Incoming return from call to 0x0794 at 0x04BE // Inputs[7] // { // @04C4 memory[0x40:0x60] // @04C6 stack[-1] // @04C9 stack[-2] // @04CA msg.gas // @04CB memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @04CB address(stack[-2]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @04CF returndata.length // } 04BF 5B JUMPDEST 04C0 60 PUSH1 0x00 04C2 60 PUSH1 0x40 04C4 51 MLOAD 04C5 80 DUP1 04C6 83 DUP4 04C7 03 SUB 04C8 81 DUP2 04C9 85 DUP6 04CA 5A GAS 04CB F4 DELEGATECALL 04CC 91 SWAP2 04CD 50 POP 04CE 50 POP 04CF 3D RETURNDATASIZE 04D0 80 DUP1 04D1 60 PUSH1 0x00 04D3 81 DUP2 04D4 14 EQ 04D5 61 PUSH2 0x04fa 04D8 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @04CB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @04CC stack[-2] = address(stack[-2]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @04CF stack[-1] = returndata.length // @04D0 stack[0] = returndata.length // } // Block ends with conditional jump to 0x04fa, if returndata.length == 0x00 label_04D9: // Incoming jump from 0x04D8, if not returndata.length == 0x00 // Inputs[6] // { // @04DB memory[0x40:0x60] // @04DC stack[-2] // @04E3 returndata.length // @04EB returndata.length // @04EE returndata.length // @04F5 returndata[0x00:0x00 + returndata.length] // } 04D9 60 PUSH1 0x40 04DB 51 MLOAD 04DC 91 SWAP2 04DD 50 POP 04DE 60 PUSH1 0x1f 04E0 19 NOT 04E1 60 PUSH1 0x3f 04E3 3D RETURNDATASIZE 04E4 01 ADD 04E5 16 AND 04E6 82 DUP3 04E7 01 ADD 04E8 60 PUSH1 0x40 04EA 52 MSTORE 04EB 3D RETURNDATASIZE 04EC 82 DUP3 04ED 52 MSTORE 04EE 3D RETURNDATASIZE 04EF 60 PUSH1 0x00 04F1 60 PUSH1 0x20 04F3 84 DUP5 04F4 01 ADD 04F5 3E RETURNDATACOPY 04F6 61 PUSH2 0x04ff 04F9 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @04DC stack[-2] = memory[0x40:0x60] // @04EA memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @04ED memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @04F5 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x04ff label_04FA: // Incoming jump from 0x04D8, if returndata.length == 0x00 // Inputs[5] // { // @04FD stack[-2] // @0501 stack[-4] // @0503 stack[-3] // @0503 stack[-5] // @050A stack[-7] // } 04FA 5B JUMPDEST 04FB 60 PUSH1 0x60 04FD 91 SWAP2 04FE 50 POP 04FF 5B JUMPDEST 0500 50 POP 0501 91 SWAP2 0502 50 POP 0503 91 SWAP2 0504 50 POP 0505 61 PUSH2 0x050f 0508 82 DUP3 0509 82 DUP3 050A 86 DUP7 050B 61 PUSH2 0x0675 050E 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0501 stack[-4] = 0x60 // @0503 stack[-5] = stack[-3] // @0505 stack[-3] = 0x050f // @0508 stack[-2] = stack[-3] // @0509 stack[-1] = 0x60 // @050A stack[0] = stack[-7] // } // Block ends with call to 0x0675, returns to 0x050F label_050F: // Incoming return from call to 0x0675 at 0x050E // Incoming return from call to 0x0675 at 0x050E // Inputs[3] // { // @0510 stack[-1] // @0510 stack[-8] // @0511 stack[-7] // } 050F 5B JUMPDEST 0510 96 SWAP7 0511 95 SWAP6 0512 50 POP 0513 50 POP 0514 50 POP 0515 50 POP 0516 50 POP 0517 50 POP 0518 56 *JUMP // Stack delta = -7 // Outputs[1] { @0510 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_0519: // Incoming call from 0x033A, returns to 0x01FB 0519 5B JUMPDEST 051A 60 PUSH1 0x00 051C 7F PUSH32 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc 053D 61 PUSH2 0x0383 0540 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @051A stack[0] = 0x00 // @051C stack[1] = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc // } // Block ends with unconditional jump to 0x0383 label_0541: // Incoming call from 0x039A, returns to 0x039B // Inputs[2] // { // @0542 stack[-1] // @0543 address(stack[-1]).code.length // } 0541 5B JUMPDEST 0542 80 DUP1 0543 3B EXTCODESIZE 0544 61 PUSH2 0x05a5 0547 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a5, if address(stack[-1]).code.length label_0548: // Incoming jump from 0x0547, if not address(stack[-1]).code.length // Inputs[1] { @054A memory[0x40:0x60] } 0548 60 PUSH1 0x40 054A 51 MLOAD 054B 62 PUSH3 0x461bcd 054F 60 PUSH1 0xe5 0551 1B SHL 0552 81 DUP2 0553 52 MSTORE 0554 60 PUSH1 0x20 0556 60 PUSH1 0x04 0558 82 DUP3 0559 01 ADD 055A 52 MSTORE 055B 60 PUSH1 0x2d 055D 60 PUSH1 0x24 055F 82 DUP3 0560 01 ADD 0561 52 MSTORE 0562 7F PUSH32 0x455243313936373a206e657720696d706c656d656e746174696f6e206973206e 0583 60 PUSH1 0x44 0585 82 DUP3 0586 01 ADD 0587 52 MSTORE 0588 6C PUSH13 0x1bdd08184818dbdb9d1c9858dd 0596 60 PUSH1 0x9a 0598 1B SHL 0599 60 PUSH1 0x64 059B 82 DUP3 059C 01 ADD 059D 52 MSTORE 059E 60 PUSH1 0x84 05A0 01 ADD 05A1 61 PUSH2 0x0328 05A4 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0553 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @055A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0561 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2d // @0587 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313936373a206e657720696d706c656d656e746174696f6e206973206e // @059D memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x1bdd08184818dbdb9d1c9858dd << 0x9a // @05A0 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0328 label_05A5: // Incoming jump from 0x0547, if address(stack[-1]).code.length // Inputs[3] // { // @05A6 stack[-1] // @05CA storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] // @05E8 stack[-2] // } 05A5 5B JUMPDEST 05A6 80 DUP1 05A7 7F PUSH32 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc 05C8 5B JUMPDEST 05C9 80 DUP1 05CA 54 SLOAD 05CB 60 PUSH1 0x01 05CD 60 PUSH1 0x01 05CF 60 PUSH1 0xa0 05D1 1B SHL 05D2 03 SUB 05D3 19 NOT 05D4 16 AND 05D5 60 PUSH1 0x01 05D7 60 PUSH1 0x01 05D9 60 PUSH1 0xa0 05DB 1B SHL 05DC 03 SUB 05DD 92 SWAP3 05DE 90 SWAP1 05DF 92 SWAP3 05E0 16 AND 05E1 91 SWAP2 05E2 90 SWAP1 05E3 91 SWAP2 05E4 17 OR 05E5 90 SWAP1 05E6 55 SSTORE 05E7 50 POP 05E8 56 *JUMP // Stack delta = -2 // Outputs[1] { @05E6 storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc]) } // Block ends with unconditional jump to stack[-2] label_05E9: // Incoming call from 0x0444, returns to 0x0154 // Inputs[1] { @05F2 stack[-1] } 05E9 5B JUMPDEST 05EA 60 PUSH1 0x01 05EC 60 PUSH1 0x01 05EE 60 PUSH1 0xa0 05F0 1B SHL 05F1 03 SUB 05F2 81 DUP2 05F3 16 AND 05F4 61 PUSH2 0x064e 05F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x064e, if stack[-1] & (0x01 << 0xa0) - 0x01 label_05F8: // Incoming jump from 0x05F7, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @05FA memory[0x40:0x60] } 05F8 60 PUSH1 0x40 05FA 51 MLOAD 05FB 62 PUSH3 0x461bcd 05FF 60 PUSH1 0xe5 0601 1B SHL 0602 81 DUP2 0603 52 MSTORE 0604 60 PUSH1 0x20 0606 60 PUSH1 0x04 0608 82 DUP3 0609 01 ADD 060A 52 MSTORE 060B 60 PUSH1 0x26 060D 60 PUSH1 0x24 060F 82 DUP3 0610 01 ADD 0611 52 MSTORE 0612 7F PUSH32 0x455243313936373a206e65772061646d696e20697320746865207a65726f2061 0633 60 PUSH1 0x44 0635 82 DUP3 0636 01 ADD 0637 52 MSTORE 0638 65 PUSH6 0x646472657373 063F 60 PUSH1 0xd0 0641 1B SHL 0642 60 PUSH1 0x64 0644 82 DUP3 0645 01 ADD 0646 52 MSTORE 0647 60 PUSH1 0x84 0649 01 ADD 064A 61 PUSH2 0x0328 064D 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0603 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @060A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0611 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0637 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313936373a206e65772061646d696e20697320746865207a65726f2061 // @0646 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @0649 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0328 label_064E: // Incoming jump from 0x05F7, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @064F stack[-1] } 064E 5B JUMPDEST 064F 80 DUP1 0650 7F PUSH32 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103 0671 61 PUSH2 0x05c8 0674 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @064F stack[0] = stack[-1] // @0650 stack[1] = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103 // } // Block ends with unconditional jump to 0x05c8 label_0675: // Incoming call from 0x050E, returns to 0x050F // Incoming call from 0x050E, returns to 0x050F // Inputs[1] { @0678 stack[-3] } 0675 5B JUMPDEST 0676 60 PUSH1 0x60 0678 83 DUP4 0679 15 ISZERO 067A 61 PUSH2 0x0684 067D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0676 stack[0] = 0x60 } // Block ends with conditional jump to 0x0684, if !stack[-3] label_067E: // Incoming jump from 0x067D, if not !stack[-3] // Inputs[1] { @067F stack[-3] } 067E 50 POP 067F 81 DUP2 0680 61 PUSH2 0x0285 0683 56 *JUMP // Stack delta = +0 // Outputs[1] { @067F stack[-1] = stack[-3] } // Block ends with unconditional jump to 0x0285 label_0684: // Incoming jump from 0x067D, if !stack[-3] // Inputs[2] // { // @0685 stack[-3] // @0686 memory[stack[-3]:stack[-3] + 0x20] // } 0684 5B JUMPDEST 0685 82 DUP3 0686 51 MLOAD 0687 15 ISZERO 0688 61 PUSH2 0x0694 068B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0694, if !memory[stack[-3]:stack[-3] + 0x20] label_068C: // Incoming jump from 0x068B, if not !memory[stack[-3]:stack[-3] + 0x20] // Inputs[3] // { // @068C stack[-3] // @068D memory[stack[-3]:stack[-3] + 0x20] // @0693 memory[0x20 + stack[-3]:0x20 + stack[-3] + memory[stack[-3]:stack[-3] + 0x20]] // } 068C 82 DUP3 068D 51 MLOAD 068E 80 DUP1 068F 84 DUP5 0690 60 PUSH1 0x20 0692 01 ADD 0693 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @068D stack[0] = memory[stack[-3]:stack[-3] + 0x20] // @0693 revert(memory[0x20 + stack[-3]:0x20 + stack[-3] + memory[stack[-3]:stack[-3] + 0x20]]); // } // Block terminates label_0694: // Incoming jump from 0x068B, if !memory[stack[-3]:stack[-3] + 0x20] // Inputs[2] // { // @0695 stack[-2] // @0698 memory[0x40:0x60] // } 0694 5B JUMPDEST 0695 81 DUP2 0696 60 PUSH1 0x40 0698 51 MLOAD 0699 62 PUSH3 0x461bcd 069D 60 PUSH1 0xe5 069F 1B SHL 06A0 81 DUP2 06A1 52 MSTORE 06A2 60 PUSH1 0x04 06A4 01 ADD 06A5 61 PUSH2 0x0328 06A8 91 SWAP2 06A9 90 SWAP1 06AA 61 PUSH2 0x07b0 06AD 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @06A8 stack[0] = 0x0328 // @06A9 stack[1] = stack[-2] // @06A9 stack[2] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x07b0, returns to 0x0328 label_06AE: // Incoming call from 0x0702, returns to 0x0703 // Incoming call from 0x06E4, returns to 0x0285 // Inputs[2] // { // @06AF stack[-1] // @06B0 msg.data[stack[-1]:stack[-1] + 0x20] // } 06AE 5B JUMPDEST 06AF 80 DUP1 06B0 35 CALLDATALOAD 06B1 60 PUSH1 0x01 06B3 60 PUSH1 0x01 06B5 60 PUSH1 0xa0 06B7 1B SHL 06B8 03 SUB 06B9 81 DUP2 06BA 16 AND 06BB 81 DUP2 06BC 14 EQ 06BD 61 PUSH2 0x06c5 06C0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06B0 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x06c5, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_06C1: // Incoming jump from 0x06C0, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @06C4 memory[0x00:0x00] } 06C1 60 PUSH1 0x00 06C3 80 DUP1 06C4 FD *REVERT // Stack delta = +0 // Outputs[1] { @06C4 revert(memory[0x00:0x00]); } // Block terminates label_06C5: // Incoming jump from 0x06C0, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @06C6 stack[-3] // @06C6 stack[-1] // @06C7 stack[-2] // } 06C5 5B JUMPDEST 06C6 91 SWAP2 06C7 90 SWAP1 06C8 50 POP 06C9 56 *JUMP // Stack delta = -2 // Outputs[1] { @06C6 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_06CA: // Incoming call from 0x007F, returns to 0x0080 // Incoming call from 0x00E3, returns to 0x00E4 // Inputs[2] // { // @06CF stack[-1] // @06D0 stack[-2] // } 06CA 5B JUMPDEST 06CB 60 PUSH1 0x00 06CD 60 PUSH1 0x20 06CF 82 DUP3 06D0 84 DUP5 06D1 03 SUB 06D2 12 SLT 06D3 15 ISZERO 06D4 61 PUSH2 0x06dc 06D7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06CB stack[0] = 0x00 } // Block ends with conditional jump to 0x06dc, if !(stack[-2] - stack[-1] i< 0x20) label_06D8: // Incoming jump from 0x06D7, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @06DB memory[0x00:0x00] } 06D8 60 PUSH1 0x00 06DA 80 DUP1 06DB FD *REVERT // Stack delta = +0 // Outputs[1] { @06DB revert(memory[0x00:0x00]); } // Block terminates label_06DC: // Incoming jump from 0x06D7, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @06E0 stack[-2] } 06DC 5B JUMPDEST 06DD 61 PUSH2 0x0285 06E0 82 DUP3 06E1 61 PUSH2 0x06ae 06E4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06DD stack[0] = 0x0285 // @06E0 stack[1] = stack[-2] // } // Block ends with call to 0x06ae, returns to 0x0285 label_06E5: // Incoming call from 0x0092, returns to 0x0093 // Inputs[2] // { // @06ED stack[-1] // @06EE stack[-2] // } 06E5 5B JUMPDEST 06E6 60 PUSH1 0x00 06E8 80 DUP1 06E9 60 PUSH1 0x00 06EB 60 PUSH1 0x40 06ED 84 DUP5 06EE 86 DUP7 06EF 03 SUB 06F0 12 SLT 06F1 15 ISZERO 06F2 61 PUSH2 0x06fa 06F5 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @06E6 stack[0] = 0x00 // @06E8 stack[1] = 0x00 // @06E9 stack[2] = 0x00 // } // Block ends with conditional jump to 0x06fa, if !(stack[-2] - stack[-1] i< 0x40) label_06F6: // Incoming jump from 0x06F5, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @06F9 memory[0x00:0x00] } 06F6 60 PUSH1 0x00 06F8 80 DUP1 06F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @06F9 revert(memory[0x00:0x00]); } // Block terminates label_06FA: // Incoming jump from 0x06F5, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @06FE stack[-4] } 06FA 5B JUMPDEST 06FB 61 PUSH2 0x0703 06FE 84 DUP5 06FF 61 PUSH2 0x06ae 0702 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06FB stack[0] = 0x0703 // @06FE stack[1] = stack[-4] // } // Block ends with call to 0x06ae, returns to 0x0703 label_0703: // Incoming return from call to 0x06AE at 0x0702 // Inputs[4] // { // @0704 stack[-1] // @0704 stack[-4] // @0708 stack[-5] // @070A msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 0703 5B JUMPDEST 0704 92 SWAP3 0705 50 POP 0706 60 PUSH1 0x20 0708 84 DUP5 0709 01 ADD 070A 35 CALLDATALOAD 070B 67 PUSH8 0xffffffffffffffff 0714 80 DUP1 0715 82 DUP3 0716 11 GT 0717 15 ISZERO 0718 61 PUSH2 0x0720 071B 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0704 stack[-4] = stack[-1] // @070A stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @070B stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x0720, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) label_071C: // Incoming jump from 0x071B, if not !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @071F memory[0x00:0x00] } 071C 60 PUSH1 0x00 071E 80 DUP1 071F FD *REVERT // Stack delta = +0 // Outputs[1] { @071F revert(memory[0x00:0x00]); } // Block terminates label_0720: // Incoming jump from 0x071B, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @0721 stack[-2] // @0722 stack[-6] // @0726 stack[-7] // } 0720 5B JUMPDEST 0721 81 DUP2 0722 86 DUP7 0723 01 ADD 0724 91 SWAP2 0725 50 POP 0726 86 DUP7 0727 60 PUSH1 0x1f 0729 83 DUP4 072A 01 ADD 072B 12 SLT 072C 61 PUSH2 0x0734 072F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0724 stack[-2] = stack[-6] + stack[-2] } // Block ends with conditional jump to 0x0734, if stack[-6] + stack[-2] + 0x1f i< stack[-7] label_0730: // Incoming jump from 0x072F, if not stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[1] { @0733 memory[0x00:0x00] } 0730 60 PUSH1 0x00 0732 80 DUP1 0733 FD *REVERT // Stack delta = +0 // Outputs[1] { @0733 revert(memory[0x00:0x00]); } // Block terminates label_0734: // Incoming jump from 0x072F, if stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[3] // { // @0735 stack[-2] // @0736 msg.data[stack[-2]:stack[-2] + 0x20] // @0737 stack[-1] // } 0734 5B JUMPDEST 0735 81 DUP2 0736 35 CALLDATALOAD 0737 81 DUP2 0738 81 DUP2 0739 11 GT 073A 15 ISZERO 073B 61 PUSH2 0x0743 073E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0736 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0743, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_073F: // Incoming jump from 0x073E, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @0742 memory[0x00:0x00] } 073F 60 PUSH1 0x00 0741 80 DUP1 0742 FD *REVERT // Stack delta = +0 // Outputs[1] { @0742 revert(memory[0x00:0x00]); } // Block terminates label_0743: // Incoming jump from 0x073E, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @0744 stack[-8] // @0747 stack[-1] // @0748 stack[-3] // } 0743 5B JUMPDEST 0744 87 DUP8 0745 60 PUSH1 0x20 0747 82 DUP3 0748 85 DUP6 0749 01 ADD 074A 01 ADD 074B 11 GT 074C 15 ISZERO 074D 61 PUSH2 0x0755 0750 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0755, if !(stack[-3] + stack[-1] + 0x20 > stack[-8]) label_0751: // Incoming jump from 0x0750, if not !(stack[-3] + stack[-1] + 0x20 > stack[-8]) // Inputs[1] { @0754 memory[0x00:0x00] } 0751 60 PUSH1 0x00 0753 80 DUP1 0754 FD *REVERT // Stack delta = +0 // Outputs[1] { @0754 revert(memory[0x00:0x00]); } // Block terminates label_0755: // Incoming jump from 0x0750, if !(stack[-3] + stack[-1] + 0x20 > stack[-8]) // Inputs[8] // { // @0758 stack[-3] // @075A stack[-5] // @075C stack[-1] // @075D stack[-4] // @0762 stack[-7] // @0764 stack[-8] // @0766 stack[-9] // @0766 stack[-6] // } 0755 5B JUMPDEST 0756 60 PUSH1 0x20 0758 83 DUP4 0759 01 ADD 075A 94 SWAP5 075B 50 POP 075C 80 DUP1 075D 93 SWAP4 075E 50 POP 075F 50 POP 0760 50 POP 0761 50 POP 0762 92 SWAP3 0763 50 POP 0764 92 SWAP3 0765 50 POP 0766 92 SWAP3 0767 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @0762 stack[-7] = stack[-1] // @0764 stack[-8] = stack[-3] + 0x20 // @0766 stack[-9] = stack[-6] // } // Block ends with unconditional jump to stack[-9] label_0768: // Incoming call from 0x07A5, returns to 0x07A6 // Incoming call from 0x07CE, returns to 0x07CF // Inputs[1] { @076C stack[-3] } 0768 5B JUMPDEST 0769 60 PUSH1 0x00 076B 5B JUMPDEST 076C 83 DUP4 076D 81 DUP2 076E 10 LT 076F 15 ISZERO 0770 61 PUSH2 0x0783 0773 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0769 stack[0] = 0x00 } // Block ends with conditional jump to 0x0783, if !(0x00 < stack[-3]) label_0774: // Incoming jump from 0x0773, if not !(0x00 < stack[-3]) // Incoming jump from 0x0773, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0774 stack[-2] // @0775 stack[-1] // @0777 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0778 stack[-3] // } 0774 81 DUP2 0775 81 DUP2 0776 01 ADD 0777 51 MLOAD 0778 83 DUP4 0779 82 DUP3 077A 01 ADD 077B 52 MSTORE 077C 60 PUSH1 0x20 077E 01 ADD 077F 61 PUSH2 0x076b 0782 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @077B memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @077E stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x076b label_0783: // Incoming jump from 0x0773, if !(0x00 < stack[-3]) // Incoming jump from 0x0773, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @0784 stack[-4] // @0785 stack[-1] // } 0783 5B JUMPDEST 0784 83 DUP4 0785 81 DUP2 0786 11 GT 0787 15 ISZERO 0788 61 PUSH2 0x03eb 078B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03eb, if !(stack[-1] > stack[-4]) label_078C: // Incoming jump from 0x078B, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @0790 stack[-4] // @0791 stack[-3] // @0793 stack[-5] // } 078C 50 POP 078D 50 POP 078E 60 PUSH1 0x00 0790 91 SWAP2 0791 01 ADD 0792 52 MSTORE 0793 56 *JUMP // Stack delta = -5 // Outputs[1] { @0792 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_0794: // Incoming call from 0x04BE, returns to 0x04BF // Inputs[3] // { // @0797 stack[-2] // @0798 memory[stack[-2]:stack[-2] + 0x20] // @079D stack[-1] // } 0794 5B JUMPDEST 0795 60 PUSH1 0x00 0797 82 DUP3 0798 51 MLOAD 0799 61 PUSH2 0x07a6 079C 81 DUP2 079D 84 DUP5 079E 60 PUSH1 0x20 07A0 87 DUP8 07A1 01 ADD 07A2 61 PUSH2 0x0768 07A5 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0795 stack[0] = 0x00 // @0798 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @0799 stack[2] = 0x07a6 // @079C stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @079D stack[4] = stack[-1] // @07A1 stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x0768, returns to 0x07A6 label_07A6: // Incoming return from call to 0x0768 at 0x07A5 // Inputs[5] // { // @07A7 stack[-3] // @07A7 stack[-1] // @07A8 stack[-2] // @07AB stack[-5] // @07AC stack[-4] // } 07A6 5B JUMPDEST 07A7 91 SWAP2 07A8 90 SWAP1 07A9 91 SWAP2 07AA 01 ADD 07AB 92 SWAP3 07AC 91 SWAP2 07AD 50 POP 07AE 50 POP 07AF 56 *JUMP // Stack delta = -4 // Outputs[1] { @07AB stack[-5] = stack[-1] + stack[-3] } // Block ends with unconditional jump to stack[-5] label_07B0: // Incoming call from 0x06AD, returns to 0x0328 // Inputs[3] // { // @07B3 stack[-1] // @07B7 stack[-2] // @07B8 memory[stack[-2]:stack[-2] + 0x20] // } 07B0 5B JUMPDEST 07B1 60 PUSH1 0x20 07B3 81 DUP2 07B4 52 MSTORE 07B5 60 PUSH1 0x00 07B7 82 DUP3 07B8 51 MLOAD 07B9 80 DUP1 07BA 60 PUSH1 0x20 07BC 84 DUP5 07BD 01 ADD 07BE 52 MSTORE 07BF 61 PUSH2 0x07cf 07C2 81 DUP2 07C3 60 PUSH1 0x40 07C5 85 DUP6 07C6 01 ADD 07C7 60 PUSH1 0x20 07C9 87 DUP8 07CA 01 ADD 07CB 61 PUSH2 0x0768 07CE 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @07B4 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @07B5 stack[0] = 0x00 // @07B8 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @07BE memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @07BF stack[2] = 0x07cf // @07C2 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @07C6 stack[4] = stack[-1] + 0x40 // @07CA stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x0768, returns to 0x07CF label_07CF: // Incoming return from call to 0x0768 at 0x07CE // Inputs[5] // { // @07D2 stack[-1] // @07D7 stack[-3] // @07D8 stack[-2] // @07DE stack[-5] // @07DF stack[-4] // } 07CF 5B JUMPDEST 07D0 60 PUSH1 0x1f 07D2 01 ADD 07D3 60 PUSH1 0x1f 07D5 19 NOT 07D6 16 AND 07D7 91 SWAP2 07D8 90 SWAP1 07D9 91 SWAP2 07DA 01 ADD 07DB 60 PUSH1 0x40 07DD 01 ADD 07DE 92 SWAP3 07DF 91 SWAP2 07E0 50 POP 07E1 50 POP 07E2 56 *JUMP // Stack delta = -4 // Outputs[1] { @07DE stack[-5] = 0x40 + (~0x1f & 0x1f + stack[-1]) + stack[-3] } // Block ends with unconditional jump to stack[-5] 07E3 FE *ASSERT 07E4 41 COINBASE 07E5 64 PUSH5 0x6472657373 07EB 3A GASPRICE 07EC 20 SHA3 07ED 6C PUSH13 0x6f772d6c6576656c2064656c65 07FB 67 PUSH8 0x6174652063616c6c 0804 20 SHA3 0805 66 PUSH7 0x61696c6564a264 080D 69 PUSH10 0x70667358221220467518 0818 7C PUSH29 0xaf3a43285d9a2c1844a981e977bd52a85ff073e7fc649f73847d70a464 0836 73 PUSH20 0x6f6c63430008090033