Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 36 CALLDATASIZE 0006 61 PUSH2 0x0013 0009 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0013, if msg.data.length label_000A: // Incoming jump from 0x0009, if not msg.data.length 000A 61 PUSH2 0x0011 000D 61 PUSH2 0x0017 0010 56 *JUMP // Stack delta = +1 // Outputs[1] { @000A stack[0] = 0x0011 } // Block ends with unconditional jump to 0x0017 0011 5B JUMPDEST 0012 00 *STOP label_0013: // Incoming jump from 0x0009, if msg.data.length 0013 5B JUMPDEST 0014 61 PUSH2 0x0011 0017 5B JUMPDEST 0018 61 PUSH2 0x001f 001B 61 PUSH2 0x01b7 001E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0014 stack[0] = 0x0011 // @0018 stack[1] = 0x001f // } // Block ends with call to 0x01b7, returns to 0x001F label_001F: // Incoming return from call to 0x01B7 at 0x001E // Incoming return from call to 0x01B7 at 0x001E // Inputs[2] // { // @0028 stack[-1] // @0029 msg.sender // } 001F 5B JUMPDEST 0020 60 PUSH1 0x01 0022 60 PUSH1 0x01 0024 60 PUSH1 0xa0 0026 1B SHL 0027 03 SUB 0028 16 AND 0029 33 CALLER 002A 60 PUSH1 0x01 002C 60 PUSH1 0x01 002E 60 PUSH1 0xa0 0030 1B SHL 0031 03 SUB 0032 16 AND 0033 14 EQ 0034 15 ISZERO 0035 61 PUSH2 0x016f 0038 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x016f, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0039: // Incoming jump from 0x0038, if not !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @0046 msg.data[0x00:0x20] } 0039 60 PUSH1 0x60 003B 60 PUSH1 0x01 003D 60 PUSH1 0x01 003F 60 PUSH1 0xe0 0041 1B SHL 0042 03 SUB 0043 19 NOT 0044 60 PUSH1 0x00 0046 35 CALLDATALOAD 0047 16 AND 0048 63 PUSH4 0x1b2ce7f3 004D 60 PUSH1 0xe1 004F 1B SHL 0050 81 DUP2 0051 14 EQ 0052 15 ISZERO 0053 61 PUSH2 0x0065 0056 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0039 stack[0] = 0x60 // @0047 stack[1] = msg.data[0x00:0x20] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0065, if !(msg.data[0x00:0x20] & ~((0x01 << 0xe0) - 0x01) == 0x1b2ce7f3 << 0xe1) label_0057: // Incoming jump from 0x0056, if not !(msg.data[0x00:0x20] & ~((0x01 << 0xe0) - 0x01) == 0x1b2ce7f3 << 0xe1) 0057 61 PUSH2 0x005e 005A 61 PUSH2 0x01ea 005D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0057 stack[0] = 0x005e } // Block ends with call to 0x01ea, returns to 0x005E label_005E: // Incoming return from call to 0x0241 at 0x0085 // Incoming return from call to 0x01EA at 0x005D // Incoming return from call to 0x02B8 at 0x00C7 // Incoming return from call to 0x02F8 at 0x00E8 // Inputs[2] // { // @005F stack[-3] // @005F stack[-1] // } 005E 5B JUMPDEST 005F 91 SWAP2 0060 50 POP 0061 61 PUSH2 0x0167 0064 56 *JUMP // Stack delta = -1 // Outputs[1] { @005F stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0167 label_0065: // Incoming jump from 0x0056, if !(msg.data[0x00:0x20] & ~((0x01 << 0xe0) - 0x01) == 0x1b2ce7f3 << 0xe1) // Inputs[1] { @006F stack[-1] } 0065 5B JUMPDEST 0066 60 PUSH1 0x01 0068 60 PUSH1 0x01 006A 60 PUSH1 0xe0 006C 1B SHL 006D 03 SUB 006E 19 NOT 006F 81 DUP2 0070 16 AND 0071 63 PUSH4 0x278f7943 0076 60 PUSH1 0xe1 0078 1B SHL 0079 14 EQ 007A 15 ISZERO 007B 61 PUSH2 0x0086 007E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0086, if !(0x278f7943 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01)) label_007F: // Incoming jump from 0x007E, if not !(0x278f7943 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01)) 007F 61 PUSH2 0x005e 0082 61 PUSH2 0x0241 0085 56 *JUMP // Stack delta = +1 // Outputs[1] { @007F stack[0] = 0x005e } // Block ends with call to 0x0241, returns to 0x005E label_0086: // Incoming jump from 0x007E, if !(0x278f7943 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01)) // Inputs[1] { @0090 stack[-1] } 0086 5B JUMPDEST 0087 60 PUSH1 0x01 0089 60 PUSH1 0x01 008B 60 PUSH1 0xe0 008D 1B SHL 008E 03 SUB 008F 19 NOT 0090 81 DUP2 0091 16 AND 0092 63 PUSH4 0x08f28397 0097 60 PUSH1 0xe4 0099 1B SHL 009A 14 EQ 009B 15 ISZERO 009C 61 PUSH2 0x00a7 009F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a7, if !(0x08f28397 << 0xe4 == stack[-1] & ~((0x01 << 0xe0) - 0x01)) label_00A0: // Incoming jump from 0x009F, if not !(0x08f28397 << 0xe4 == stack[-1] & ~((0x01 << 0xe0) - 0x01)) 00A0 61 PUSH2 0x005e 00A3 61 PUSH2 0x0287 00A6 56 *JUMP // Stack delta = +1 // Outputs[1] { @00A0 stack[0] = 0x005e } // Block ends with unconditional jump to 0x0287 label_00A7: // Incoming jump from 0x009F, if !(0x08f28397 << 0xe4 == stack[-1] & ~((0x01 << 0xe0) - 0x01)) // Inputs[1] { @00B1 stack[-1] } 00A7 5B JUMPDEST 00A8 60 PUSH1 0x01 00AA 60 PUSH1 0x01 00AC 60 PUSH1 0xe0 00AE 1B SHL 00AF 03 SUB 00B0 19 NOT 00B1 81 DUP2 00B2 16 AND 00B3 63 PUSH4 0x03e14691 00B8 60 PUSH1 0xe6 00BA 1B SHL 00BB 14 EQ 00BC 15 ISZERO 00BD 61 PUSH2 0x00c8 00C0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c8, if !(0x03e14691 << 0xe6 == stack[-1] & ~((0x01 << 0xe0) - 0x01)) label_00C1: // Incoming jump from 0x00C0, if not !(0x03e14691 << 0xe6 == stack[-1] & ~((0x01 << 0xe0) - 0x01)) 00C1 61 PUSH2 0x005e 00C4 61 PUSH2 0x02b8 00C7 56 *JUMP // Stack delta = +1 // Outputs[1] { @00C1 stack[0] = 0x005e } // Block ends with call to 0x02b8, returns to 0x005E label_00C8: // Incoming jump from 0x00C0, if !(0x03e14691 << 0xe6 == stack[-1] & ~((0x01 << 0xe0) - 0x01)) // Inputs[1] { @00D2 stack[-1] } 00C8 5B JUMPDEST 00C9 60 PUSH1 0x01 00CB 60 PUSH1 0x01 00CD 60 PUSH1 0xe0 00CF 1B SHL 00D0 03 SUB 00D1 19 NOT 00D2 81 DUP2 00D3 16 AND 00D4 63 PUSH4 0x5c60da1b 00D9 60 PUSH1 0xe0 00DB 1B SHL 00DC 14 EQ 00DD 15 ISZERO 00DE 61 PUSH2 0x00e9 00E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00e9, if !(0x5c60da1b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01)) label_00E2: // Incoming jump from 0x00E1, if not !(0x5c60da1b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01)) 00E2 61 PUSH2 0x005e 00E5 61 PUSH2 0x02f8 00E8 56 *JUMP // Stack delta = +1 // Outputs[1] { @00E2 stack[0] = 0x005e } // Block ends with call to 0x02f8, returns to 0x005E label_00E9: // Incoming jump from 0x00E1, if !(0x5c60da1b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01)) // Inputs[3] // { // @00EC memory[0x40:0x60] // @0161 memory[0x40:0x60] // @0166 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 00E9 5B JUMPDEST 00EA 60 PUSH1 0x40 00EC 51 MLOAD 00ED 62 PUSH3 0x461bcd 00F1 60 PUSH1 0xe5 00F3 1B SHL 00F4 81 DUP2 00F5 52 MSTORE 00F6 60 PUSH1 0x20 00F8 60 PUSH1 0x04 00FA 82 DUP3 00FB 01 ADD 00FC 52 MSTORE 00FD 60 PUSH1 0x42 00FF 60 PUSH1 0x24 0101 82 DUP3 0102 01 ADD 0103 52 MSTORE 0104 7F PUSH32 0x5472616e73706172656e745570677261646561626c6550726f78793a2061646d 0125 60 PUSH1 0x44 0127 82 DUP3 0128 01 ADD 0129 52 MSTORE 012A 7F PUSH32 0x696e2063616e6e6f742066616c6c6261636b20746f2070726f78792074617267 014B 60 PUSH1 0x64 014D 82 DUP3 014E 01 ADD 014F 52 MSTORE 0150 61 PUSH2 0x195d 0153 60 PUSH1 0xf2 0155 1B SHL 0156 60 PUSH1 0x84 0158 82 DUP3 0159 01 ADD 015A 52 MSTORE 015B 60 PUSH1 0xa4 015D 01 ADD 015E 5B JUMPDEST 015F 60 PUSH1 0x40 0161 51 MLOAD 0162 80 DUP1 0163 91 SWAP2 0164 03 SUB 0165 90 SWAP1 0166 FD *REVERT // Stack delta = +0 // Outputs[7] // { // @00F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @00FC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0103 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x42 // @0129 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5472616e73706172656e745570677261646561626c6550726f78793a2061646d // @014F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x696e2063616e6e6f742066616c6c6261636b20746f2070726f78792074617267 // @015A memory[memory[0x40:0x60] + 0x84:memory[0x40:0x60] + 0x84 + 0x20] = 0x195d << 0xf2 // @0166 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0167: // Incoming jump from 0x0064 // Inputs[3] // { // @0168 stack[-2] // @0169 memory[stack[-2]:stack[-2] + 0x20] // @016E memory[stack[-2] + 0x20:stack[-2] + 0x20 + memory[stack[-2]:stack[-2] + 0x20]] // } 0167 5B JUMPDEST 0168 81 DUP2 0169 51 MLOAD 016A 60 PUSH1 0x20 016C 83 DUP4 016D 01 ADD 016E F3 *RETURN // Stack delta = +0 // Outputs[1] { @016E return memory[stack[-2] + 0x20:stack[-2] + 0x20 + memory[stack[-2]:stack[-2] + 0x20]]; } // Block terminates label_016F: // Incoming jump from 0x0038, if !((0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1]) 016F 5B JUMPDEST 0170 61 PUSH2 0x0177 0173 61 PUSH2 0x030c 0176 56 *JUMP // Stack delta = +1 // Outputs[1] { @0170 stack[0] = 0x0177 } // Block ends with unconditional jump to 0x030c label_0177: // Incoming jump from 0x039A, if !msg.value // Inputs[1] { @0178 stack[-1] } 0177 5B JUMPDEST 0178 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0179: // Incoming jump from 0x03C3 // Inputs[3] // { // @017F stack[-2] // @0180 stack[-1] // @0183 memory[0x40:0x60] // } 0179 5B JUMPDEST 017A 60 PUSH1 0x60 017C 61 PUSH2 0x019e 017F 83 DUP4 0180 83 DUP4 0181 60 PUSH1 0x40 0183 51 MLOAD 0184 80 DUP1 0185 60 PUSH1 0x60 0187 01 ADD 0188 60 PUSH1 0x40 018A 52 MSTORE 018B 80 DUP1 018C 60 PUSH1 0x27 018E 81 DUP2 018F 52 MSTORE 0190 60 PUSH1 0x20 0192 01 ADD 0193 61 PUSH2 0x0857 0196 60 PUSH1 0x27 0198 91 SWAP2 0199 39 CODECOPY 019A 61 PUSH2 0x031c 019D 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @017A stack[0] = 0x60 // @017C stack[1] = 0x019e // @017F stack[2] = stack[-2] // @0180 stack[3] = stack[-1] // @0183 stack[4] = memory[0x40:0x60] // @018A memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @018F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x27 // @0199 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x27] = code[0x0857:0x087e] // } // Block ends with call to 0x031c, returns to 0x019E label_019E: // Incoming return from call to 0x06CC at 0x0702 // Incoming return from call to 0x031C at 0x019D // Inputs[3] // { // @019F stack[-1] // @019F stack[-5] // @01A0 stack[-4] // } 019E 5B JUMPDEST 019F 93 SWAP4 01A0 92 SWAP3 01A1 50 POP 01A2 50 POP 01A3 50 POP 01A4 56 *JUMP // Stack delta = -4 // Outputs[1] { @019F stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] 01A5 5B JUMPDEST 01A6 90 SWAP1 01A7 56 *JUMP 01A8 5B JUMPDEST 01A9 60 PUSH1 0x01 01AB 60 PUSH1 0x01 01AD 60 PUSH1 0xa0 01AF 1B SHL 01B0 03 SUB 01B1 16 AND 01B2 3B EXTCODESIZE 01B3 15 ISZERO 01B4 15 ISZERO 01B5 90 SWAP1 01B6 56 *JUMP label_01B7: // Incoming call from 0x02CB, returns to 0x02CC // Incoming call from 0x001E, returns to 0x001F // Incoming call from 0x03F3, returns to 0x03F4 // Incoming call from 0x001E, returns to 0x001F // Inputs[2] // { // @01DC storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] // @01E6 stack[-1] // } 01B7 5B JUMPDEST 01B8 60 PUSH1 0x00 01BA 7F PUSH32 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103 01DB 5B JUMPDEST 01DC 54 SLOAD 01DD 60 PUSH1 0x01 01DF 60 PUSH1 0x01 01E1 60 PUSH1 0xa0 01E3 1B SHL 01E4 03 SUB 01E5 16 AND 01E6 91 SWAP2 01E7 90 SWAP1 01E8 50 POP 01E9 56 *JUMP // Stack delta = +0 // Outputs[1] { @01E6 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] } // Block ends with unconditional jump to stack[-1] label_01EA: // Incoming call from 0x005D, returns to 0x005E 01EA 5B JUMPDEST 01EB 60 PUSH1 0x60 01ED 61 PUSH2 0x01f4 01F0 61 PUSH2 0x0394 01F3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @01EB stack[0] = 0x60 // @01ED stack[1] = 0x01f4 // } // Block ends with call to 0x0394, returns to 0x01F4 label_01F4: // Incoming return from call to 0x0394 at 0x01F3 // Inputs[1] { @01FA msg.data.length } 01F4 5B JUMPDEST 01F5 60 PUSH1 0x00 01F7 61 PUSH2 0x0203 01FA 36 CALLDATASIZE 01FB 60 PUSH1 0x04 01FD 81 DUP2 01FE 84 DUP5 01FF 61 PUSH2 0x06a2 0202 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @01F5 stack[0] = 0x00 // @01F7 stack[1] = 0x0203 // @01FA stack[2] = msg.data.length // @01FB stack[3] = 0x04 // @01FD stack[4] = msg.data.length // @01FE stack[5] = 0x00 // } // Block ends with call to 0x06a2, returns to 0x0203 label_0203: // Incoming return from call to 0x06A2 at 0x0202 // Inputs[2] // { // @0204 stack[-2] // @0205 stack[-1] // } 0203 5B JUMPDEST 0204 81 DUP2 0205 01 ADD 0206 90 SWAP1 0207 61 PUSH2 0x0210 020A 91 SWAP2 020B 90 SWAP1 020C 61 PUSH2 0x06e8 020F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @020A stack[-2] = 0x0210 // @020B stack[-1] = stack[-2] + stack[-1] // @020B stack[0] = stack[-2] // } // Block ends with call to 0x06e8, returns to 0x0210 label_0210: // Incoming return from call to 0x06E8 at 0x020F // Inputs[3] // { // @0211 stack[-2] // @0211 stack[-1] // @0219 memory[0x40:0x60] // } 0210 5B JUMPDEST 0211 90 SWAP1 0212 50 POP 0213 61 PUSH2 0x022d 0216 81 DUP2 0217 60 PUSH1 0x40 0219 51 MLOAD 021A 80 DUP1 021B 60 PUSH1 0x20 021D 01 ADD 021E 60 PUSH1 0x40 0220 52 MSTORE 0221 80 DUP1 0222 60 PUSH1 0x00 0224 81 DUP2 0225 52 MSTORE 0226 50 POP 0227 60 PUSH1 0x00 0229 61 PUSH2 0x039f 022C 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @0211 stack[-2] = stack[-1] // @0213 stack[-1] = 0x022d // @0216 stack[0] = stack[-1] // @0219 stack[1] = memory[0x40:0x60] // @0220 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0225 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0227 stack[2] = 0x00 // } // Block ends with call to 0x039f, returns to 0x022D label_022D: // Incoming return from call to 0x039F at 0x022C // Inputs[2] // { // @0233 memory[0x40:0x60] // @023F stack[-3] // } 022D 5B JUMPDEST 022E 50 POP 022F 50 POP 0230 60 PUSH1 0x40 0232 80 DUP1 0233 51 MLOAD 0234 60 PUSH1 0x20 0236 81 DUP2 0237 01 ADD 0238 90 SWAP1 0239 91 SWAP2 023A 52 MSTORE 023B 60 PUSH1 0x00 023D 81 DUP2 023E 52 MSTORE 023F 90 SWAP1 0240 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @023A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @023E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @023F stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_0241: // Incoming call from 0x0085, returns to 0x005E // Inputs[1] { @024A msg.data.length } 0241 5B JUMPDEST 0242 60 PUSH1 0x60 0244 60 PUSH1 0x00 0246 80 DUP1 0247 61 PUSH2 0x0253 024A 36 CALLDATASIZE 024B 60 PUSH1 0x04 024D 81 DUP2 024E 84 DUP5 024F 61 PUSH2 0x06a2 0252 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @0242 stack[0] = 0x60 // @0244 stack[1] = 0x00 // @0246 stack[2] = 0x00 // @0247 stack[3] = 0x0253 // @024A stack[4] = msg.data.length // @024B stack[5] = 0x04 // @024D stack[6] = msg.data.length // @024E stack[7] = 0x00 // } // Block ends with call to 0x06a2, returns to 0x0253 label_0253: // Incoming return from call to 0x06A2 at 0x0252 // Inputs[2] // { // @0254 stack[-2] // @0255 stack[-1] // } 0253 5B JUMPDEST 0254 81 DUP2 0255 01 ADD 0256 90 SWAP1 0257 61 PUSH2 0x0260 025A 91 SWAP2 025B 90 SWAP1 025C 61 PUSH2 0x0719 025F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @025A stack[-2] = 0x0260 // @025B stack[-1] = stack[-2] + stack[-1] // @025B stack[0] = stack[-2] // } // Block ends with call to 0x0719, returns to 0x0260 label_0260: // Incoming return from call to 0x0719 at 0x025F // Inputs[4] // { // @0261 stack[-1] // @0261 stack[-3] // @0263 stack[-4] // @0263 stack[-2] // } 0260 5B JUMPDEST 0261 91 SWAP2 0262 50 POP 0263 91 SWAP2 0264 50 POP 0265 61 PUSH2 0x0270 0268 82 DUP3 0269 82 DUP3 026A 60 PUSH1 0x01 026C 61 PUSH2 0x039f 026F 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @0261 stack[-3] = stack[-1] // @0263 stack[-4] = stack[-2] // @0265 stack[-2] = 0x0270 // @0268 stack[-1] = stack[-2] // @0269 stack[0] = stack[-1] // @026A stack[1] = 0x01 // } // Block ends with call to 0x039f, returns to 0x0270 label_0270: // Incoming return from call to 0x039F at 0x026F // Inputs[3] // { // @0273 memory[0x40:0x60] // @0281 stack[-3] // @0285 stack[-4] // } 0270 5B JUMPDEST 0271 60 PUSH1 0x40 0273 51 MLOAD 0274 80 DUP1 0275 60 PUSH1 0x20 0277 01 ADD 0278 60 PUSH1 0x40 027A 52 MSTORE 027B 80 DUP1 027C 60 PUSH1 0x00 027E 81 DUP2 027F 52 MSTORE 0280 50 POP 0281 92 SWAP3 0282 50 POP 0283 50 POP 0284 50 POP 0285 90 SWAP1 0286 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @027A memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @027F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0285 stack[-4] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-4] label_0287: // Incoming jump from 0x00A6 0287 5B JUMPDEST 0288 60 PUSH1 0x60 028A 61 PUSH2 0x0291 028D 61 PUSH2 0x0394 0290 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0288 stack[0] = 0x60 // @028A stack[1] = 0x0291 // } // Block ends with call to 0x0394, returns to 0x0291 label_0291: // Incoming return from call to 0x0394 at 0x0290 // Inputs[1] { @0297 msg.data.length } 0291 5B JUMPDEST 0292 60 PUSH1 0x00 0294 61 PUSH2 0x02a0 0297 36 CALLDATASIZE 0298 60 PUSH1 0x04 029A 81 DUP2 029B 84 DUP5 029C 61 PUSH2 0x06a2 029F 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0292 stack[0] = 0x00 // @0294 stack[1] = 0x02a0 // @0297 stack[2] = msg.data.length // @0298 stack[3] = 0x04 // @029A stack[4] = msg.data.length // @029B stack[5] = 0x00 // } // Block ends with call to 0x06a2, returns to 0x02A0 label_02A0: // Incoming return from call to 0x06A2 at 0x029F // Inputs[2] // { // @02A1 stack[-2] // @02A2 stack[-1] // } 02A0 5B JUMPDEST 02A1 81 DUP2 02A2 01 ADD 02A3 90 SWAP1 02A4 61 PUSH2 0x02ad 02A7 91 SWAP2 02A8 90 SWAP1 02A9 61 PUSH2 0x06e8 02AC 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @02A7 stack[-2] = 0x02ad // @02A8 stack[-1] = stack[-2] + stack[-1] // @02A8 stack[0] = stack[-2] // } // Block ends with call to 0x06e8, returns to 0x02AD label_02AD: // Incoming return from call to 0x06E8 at 0x02AC // Inputs[2] // { // @02AE stack[-1] // @02AE stack[-2] // } 02AD 5B JUMPDEST 02AE 90 SWAP1 02AF 50 POP 02B0 61 PUSH2 0x022d 02B3 81 DUP2 02B4 61 PUSH2 0x03cb 02B7 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @02AE stack[-2] = stack[-1] // @02B0 stack[-1] = 0x022d // @02B3 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x03cb label_02B8: // Incoming call from 0x00C7, returns to 0x005E 02B8 5B JUMPDEST 02B9 60 PUSH1 0x60 02BB 61 PUSH2 0x02c2 02BE 61 PUSH2 0x0394 02C1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02B9 stack[0] = 0x60 // @02BB stack[1] = 0x02c2 // } // Block ends with call to 0x0394, returns to 0x02C2 label_02C2: // Incoming return from call to 0x0394 at 0x02C1 02C2 5B JUMPDEST 02C3 60 PUSH1 0x00 02C5 61 PUSH2 0x02cc 02C8 61 PUSH2 0x01b7 02CB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02C3 stack[0] = 0x00 // @02C5 stack[1] = 0x02cc // } // Block ends with call to 0x01b7, returns to 0x02CC label_02CC: // Incoming return from call to 0x01B7 at 0x02CB // Incoming return from call to 0x0422 at 0x030B // Inputs[6] // { // @02D0 memory[0x40:0x60] // @02D9 stack[-1] // @02E1 stack[-2] // @02E6 memory[0x40:0x60] // @02F3 stack[-3] // @02F6 stack[-4] // } 02CC 5B JUMPDEST 02CD 60 PUSH1 0x40 02CF 80 DUP1 02D0 51 MLOAD 02D1 60 PUSH1 0x01 02D3 60 PUSH1 0x01 02D5 60 PUSH1 0xa0 02D7 1B SHL 02D8 03 SUB 02D9 83 DUP4 02DA 16 AND 02DB 60 PUSH1 0x20 02DD 82 DUP3 02DE 01 ADD 02DF 52 MSTORE 02E0 91 SWAP2 02E1 92 SWAP3 02E2 50 POP 02E3 01 ADD 02E4 60 PUSH1 0x40 02E6 51 MLOAD 02E7 60 PUSH1 0x20 02E9 81 DUP2 02EA 83 DUP4 02EB 03 SUB 02EC 03 SUB 02ED 81 DUP2 02EE 52 MSTORE 02EF 90 SWAP1 02F0 60 PUSH1 0x40 02F2 52 MSTORE 02F3 91 SWAP2 02F4 50 POP 02F5 50 POP 02F6 90 SWAP1 02F7 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @02DF memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @02EE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x40 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @02F2 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @02F6 stack[-4] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-4] label_02F8: // Incoming call from 0x00E8, returns to 0x005E 02F8 5B JUMPDEST 02F9 60 PUSH1 0x60 02FB 61 PUSH2 0x0302 02FE 61 PUSH2 0x0394 0301 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02F9 stack[0] = 0x60 // @02FB stack[1] = 0x0302 // } // Block ends with call to 0x0394, returns to 0x0302 label_0302: // Incoming return from call to 0x0394 at 0x0301 0302 5B JUMPDEST 0303 60 PUSH1 0x00 0305 61 PUSH2 0x02cc 0308 61 PUSH2 0x0422 030B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0303 stack[0] = 0x00 // @0305 stack[1] = 0x02cc // } // Block ends with call to 0x0422, returns to 0x02CC label_030C: // Incoming jump from 0x0176 030C 5B JUMPDEST 030D 61 PUSH2 0x0177 0310 61 PUSH2 0x0317 0313 61 PUSH2 0x0422 0316 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @030D stack[0] = 0x0177 // @0310 stack[1] = 0x0317 // } // Block ends with call to 0x0422, returns to 0x0317 label_0317: // Incoming return from call to 0x0422 at 0x0316 0317 5B JUMPDEST 0318 61 PUSH2 0x0431 031B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0431 label_031C: // Incoming call from 0x019D, returns to 0x019E // Inputs[3] // { // @0322 stack[-3] // @032C stack[-2] // @032F memory[0x40:0x60] // } 031C 5B JUMPDEST 031D 60 PUSH1 0x60 031F 60 PUSH1 0x00 0321 80 DUP1 0322 85 DUP6 0323 60 PUSH1 0x01 0325 60 PUSH1 0x01 0327 60 PUSH1 0xa0 0329 1B SHL 032A 03 SUB 032B 16 AND 032C 85 DUP6 032D 60 PUSH1 0x40 032F 51 MLOAD 0330 61 PUSH2 0x0339 0333 91 SWAP2 0334 90 SWAP1 0335 61 PUSH2 0x0807 0338 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @031D stack[0] = 0x60 // @031F stack[1] = 0x00 // @0321 stack[2] = 0x00 // @032B stack[3] = (0x01 << 0xa0) - 0x01 & stack[-3] // @0333 stack[4] = 0x0339 // @0334 stack[5] = stack[-2] // @0334 stack[6] = memory[0x40:0x60] // } // Block ends with call to 0x0807, returns to 0x0339 label_0339: // Incoming return from call to 0x0807 at 0x0338 // Inputs[7] // { // @033E memory[0x40:0x60] // @0340 stack[-1] // @0343 stack[-2] // @0344 msg.gas // @0345 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0345 address(stack[-2]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0349 returndata.length // } 0339 5B JUMPDEST 033A 60 PUSH1 0x00 033C 60 PUSH1 0x40 033E 51 MLOAD 033F 80 DUP1 0340 83 DUP4 0341 03 SUB 0342 81 DUP2 0343 85 DUP6 0344 5A GAS 0345 F4 DELEGATECALL 0346 91 SWAP2 0347 50 POP 0348 50 POP 0349 3D RETURNDATASIZE 034A 80 DUP1 034B 60 PUSH1 0x00 034D 81 DUP2 034E 14 EQ 034F 61 PUSH2 0x0374 0352 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0345 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]]) // @0346 stack[-2] = address(stack[-2]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0349 stack[-1] = returndata.length // @034A stack[0] = returndata.length // } // Block ends with conditional jump to 0x0374, if returndata.length == 0x00 label_0353: // Incoming jump from 0x0352, if not returndata.length == 0x00 // Inputs[6] // { // @0355 memory[0x40:0x60] // @0356 stack[-2] // @035D returndata.length // @0365 returndata.length // @0368 returndata.length // @036F returndata[0x00:0x00 + returndata.length] // } 0353 60 PUSH1 0x40 0355 51 MLOAD 0356 91 SWAP2 0357 50 POP 0358 60 PUSH1 0x1f 035A 19 NOT 035B 60 PUSH1 0x3f 035D 3D RETURNDATASIZE 035E 01 ADD 035F 16 AND 0360 82 DUP3 0361 01 ADD 0362 60 PUSH1 0x40 0364 52 MSTORE 0365 3D RETURNDATASIZE 0366 82 DUP3 0367 52 MSTORE 0368 3D RETURNDATASIZE 0369 60 PUSH1 0x00 036B 60 PUSH1 0x20 036D 84 DUP5 036E 01 ADD 036F 3E RETURNDATACOPY 0370 61 PUSH2 0x0379 0373 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0356 stack[-2] = memory[0x40:0x60] // @0364 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0367 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @036F memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0379 label_0374: // Incoming jump from 0x0352, if returndata.length == 0x00 // Inputs[6] // { // @0377 stack[-2] // @037B stack[-4] // @037D stack[-5] // @037D stack[-3] // @0382 stack[-9] // @0385 stack[-7] // } 0374 5B JUMPDEST 0375 60 PUSH1 0x60 0377 91 SWAP2 0378 50 POP 0379 5B JUMPDEST 037A 50 POP 037B 91 SWAP2 037C 50 POP 037D 91 SWAP2 037E 50 POP 037F 61 PUSH2 0x038a 0382 86 DUP7 0383 83 DUP4 0384 83 DUP4 0385 87 DUP8 0386 61 PUSH2 0x0455 0389 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @037B stack[-4] = 0x60 // @037D stack[-5] = stack[-3] // @037F stack[-3] = 0x038a // @0382 stack[-2] = stack[-9] // @0383 stack[-1] = stack[-3] // @0384 stack[0] = 0x60 // @0385 stack[1] = stack[-7] // } // Block ends with call to 0x0455, returns to 0x038A label_038A: // Incoming return from call to 0x0455 at 0x0389 // Incoming return from call to 0x0455 at 0x0389 // Inputs[3] // { // @038B stack[-8] // @038B stack[-1] // @038C stack[-7] // } 038A 5B JUMPDEST 038B 96 SWAP7 038C 95 SWAP6 038D 50 POP 038E 50 POP 038F 50 POP 0390 50 POP 0391 50 POP 0392 50 POP 0393 56 *JUMP // Stack delta = -7 // Outputs[1] { @038B stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_0394: // Incoming call from 0x0301, returns to 0x0302 // Incoming call from 0x0290, returns to 0x0291 // Incoming call from 0x02C1, returns to 0x02C2 // Incoming call from 0x01F3, returns to 0x01F4 // Inputs[1] { @0395 msg.value } 0394 5B JUMPDEST 0395 34 CALLVALUE 0396 15 ISZERO 0397 61 PUSH2 0x0177 039A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0177, if !msg.value label_039B: // Incoming jump from 0x039A, if not !msg.value // Inputs[1] { @039E memory[0x00:0x00] } 039B 60 PUSH1 0x00 039D 80 DUP1 039E FD *REVERT // Stack delta = +0 // Outputs[1] { @039E revert(memory[0x00:0x00]); } // Block terminates label_039F: // Incoming call from 0x026F, returns to 0x0270 // Incoming call from 0x022C, returns to 0x022D // Inputs[1] { @03A3 stack[-3] } 039F 5B JUMPDEST 03A0 61 PUSH2 0x03a8 03A3 83 DUP4 03A4 61 PUSH2 0x04d3 03A7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @03A0 stack[0] = 0x03a8 // @03A3 stack[1] = stack[-3] // } // Block ends with call to 0x04d3, returns to 0x03A8 label_03A8: // Incoming return from call to 0x04D3 at 0x03A7 // Inputs[2] // { // @03AB stack[-2] // @03AC memory[stack[-2]:stack[-2] + 0x20] // } 03A8 5B JUMPDEST 03A9 60 PUSH1 0x00 03AB 82 DUP3 03AC 51 MLOAD 03AD 11 GT 03AE 80 DUP1 03AF 61 PUSH2 0x03b5 03B2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03AD stack[0] = memory[stack[-2]:stack[-2] + 0x20] > 0x00 } // Block ends with conditional jump to 0x03b5, if memory[stack[-2]:stack[-2] + 0x20] > 0x00 label_03B3: // Incoming jump from 0x03B2, if not memory[stack[-2]:stack[-2] + 0x20] > 0x00 // Inputs[1] { @03B4 stack[-2] } 03B3 50 POP 03B4 80 DUP1 03B5 5B JUMPDEST 03B6 15 ISZERO 03B7 61 PUSH2 0x03c6 03BA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x03c6, if !stack[-2] label_03BB: // Incoming jump from 0x03BA, if not !stack[-1] // Incoming jump from 0x03BA, if not !stack[-2] // Inputs[2] // { // @03BE stack[-3] // @03BF stack[-2] // } 03BB 61 PUSH2 0x03c4 03BE 83 DUP4 03BF 83 DUP4 03C0 61 PUSH2 0x0179 03C3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @03BB stack[0] = 0x03c4 // @03BE stack[1] = stack[-3] // @03BF stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x0179 label_03C4: // Incoming jump from 0x07FE, if !(stack[-1] > stack[-4]) 03C4 5B JUMPDEST 03C5 50 POP // Stack delta = -1 // Block continues label_03C6: // Incoming jump from 0x03BA, if !stack[-2] // Incoming jump from 0x03BA, if !stack[-1] // Incoming jump from 0x03C5 // Inputs[1] { @03CA stack[-4] } 03C6 5B JUMPDEST 03C7 50 POP 03C8 50 POP 03C9 50 POP 03CA 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_03CB: // Incoming jump from 0x02B7 03CB 5B JUMPDEST 03CC 7F PUSH32 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f 03ED 61 PUSH2 0x03f4 03F0 61 PUSH2 0x01b7 03F3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @03CC stack[0] = 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f // @03ED stack[1] = 0x03f4 // } // Block ends with call to 0x01b7, returns to 0x03F4 label_03F4: // Incoming return from call to 0x01B7 at 0x03F3 // Inputs[6] // { // @03F8 memory[0x40:0x60] // @0401 stack[-1] // @0407 stack[-3] // @0411 memory[0x40:0x60] // @0416 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0416 stack[-2] // } 03F4 5B JUMPDEST 03F5 60 PUSH1 0x40 03F7 80 DUP1 03F8 51 MLOAD 03F9 60 PUSH1 0x01 03FB 60 PUSH1 0x01 03FD 60 PUSH1 0xa0 03FF 1B SHL 0400 03 SUB 0401 92 SWAP3 0402 83 DUP4 0403 16 AND 0404 81 DUP2 0405 52 MSTORE 0406 91 SWAP2 0407 84 DUP5 0408 16 AND 0409 60 PUSH1 0x20 040B 83 DUP4 040C 01 ADD 040D 52 MSTORE 040E 01 ADD 040F 60 PUSH1 0x40 0411 51 MLOAD 0412 80 DUP1 0413 91 SWAP2 0414 03 SUB 0415 90 SWAP1 0416 A1 LOG1 0417 61 PUSH2 0x041f 041A 81 DUP2 041B 61 PUSH2 0x0513 041E 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @0405 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @040D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0416 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]], [stack[-2]]); // @0417 stack[-2] = 0x041f // @041A stack[-1] = stack[-3] // } // Block ends with unconditional jump to 0x0513 041F 5B JUMPDEST 0420 50 POP 0421 56 *JUMP label_0422: // Incoming call from 0x0316, returns to 0x0317 // Incoming call from 0x030B, returns to 0x02CC 0422 5B JUMPDEST 0423 60 PUSH1 0x00 0425 61 PUSH2 0x042c 0428 61 PUSH2 0x05bc 042B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0423 stack[0] = 0x00 // @0425 stack[1] = 0x042c // } // Block ends with call to 0x05bc, returns to 0x042C label_042C: // Incoming return from call to 0x05BC at 0x042B // Inputs[3] // { // @042D stack[-2] // @042D stack[-1] // @042F stack[-3] // } 042C 5B JUMPDEST 042D 90 SWAP1 042E 50 POP 042F 90 SWAP1 0430 56 *JUMP // Stack delta = -2 // Outputs[1] { @042F stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_0431: // Incoming jump from 0x031B // Inputs[9] // { // @0432 msg.data.length // @0436 msg.data[0x00:0x00 + msg.data.length] // @043A msg.data.length // @043D stack[-1] // @043E msg.gas // @043F address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @043F memory[0x00:0x00 + msg.data.length] // @0440 returndata.length // @0444 returndata[0x00:0x00 + returndata.length] // } 0431 5B JUMPDEST 0432 36 CALLDATASIZE 0433 60 PUSH1 0x00 0435 80 DUP1 0436 37 CALLDATACOPY 0437 60 PUSH1 0x00 0439 80 DUP1 043A 36 CALLDATASIZE 043B 60 PUSH1 0x00 043D 84 DUP5 043E 5A GAS 043F F4 DELEGATECALL 0440 3D RETURNDATASIZE 0441 60 PUSH1 0x00 0443 80 DUP1 0444 3E RETURNDATACOPY 0445 80 DUP1 0446 80 DUP1 0447 15 ISZERO 0448 61 PUSH2 0x0450 044B 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @0436 memory[0x00:0x00 + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @043F memory[0x00:0x00] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @043F stack[0] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // @0444 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0445 stack[1] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // } // Block ends with conditional jump to 0x0450, if !address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) label_044C: // Incoming jump from 0x044B, if not !address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // Inputs[2] // { // @044C returndata.length // @044F memory[0x00:0x00 + returndata.length] // } 044C 3D RETURNDATASIZE 044D 60 PUSH1 0x00 044F F3 *RETURN // Stack delta = +0 // Outputs[1] { @044F return memory[0x00:0x00 + returndata.length]; } // Block terminates label_0450: // Incoming jump from 0x044B, if !address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) // Inputs[2] // { // @0451 returndata.length // @0454 memory[0x00:0x00 + returndata.length] // } 0450 5B JUMPDEST 0451 3D RETURNDATASIZE 0452 60 PUSH1 0x00 0454 FD *REVERT // Stack delta = +0 // Outputs[1] { @0454 revert(memory[0x00:0x00 + returndata.length]); } // Block terminates label_0455: // Incoming call from 0x0389, returns to 0x038A // Incoming call from 0x0389, returns to 0x038A // Inputs[1] { @0458 stack[-3] } 0455 5B JUMPDEST 0456 60 PUSH1 0x60 0458 83 DUP4 0459 15 ISZERO 045A 61 PUSH2 0x04c1 045D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0456 stack[0] = 0x60 } // Block ends with conditional jump to 0x04c1, if !stack[-3] label_045E: // Incoming jump from 0x045D, if not !stack[-3] // Inputs[2] // { // @045E stack[-3] // @045F memory[stack[-3]:stack[-3] + 0x20] // } 045E 82 DUP3 045F 51 MLOAD 0460 61 PUSH2 0x04ba 0463 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ba, if memory[stack[-3]:stack[-3] + 0x20] label_0464: // Incoming jump from 0x0463, if not memory[stack[-3]:stack[-3] + 0x20] // Inputs[2] // { // @046C stack[-5] // @046E address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length // } 0464 60 PUSH1 0x01 0466 60 PUSH1 0x01 0468 60 PUSH1 0xa0 046A 1B SHL 046B 03 SUB 046C 85 DUP6 046D 16 AND 046E 3B EXTCODESIZE 046F 61 PUSH2 0x04ba 0472 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ba, if address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length label_0473: // Incoming jump from 0x0472, if not address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0475 memory[0x40:0x60] } 0473 60 PUSH1 0x40 0475 51 MLOAD 0476 62 PUSH3 0x461bcd 047A 60 PUSH1 0xe5 047C 1B SHL 047D 81 DUP2 047E 52 MSTORE 047F 60 PUSH1 0x20 0481 60 PUSH1 0x04 0483 82 DUP3 0484 01 ADD 0485 52 MSTORE 0486 60 PUSH1 0x1d 0488 60 PUSH1 0x24 048A 82 DUP3 048B 01 ADD 048C 52 MSTORE 048D 7F PUSH32 0x416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000 04AE 60 PUSH1 0x44 04B0 82 DUP3 04B1 01 ADD 04B2 52 MSTORE 04B3 60 PUSH1 0x64 04B5 01 ADD 04B6 61 PUSH2 0x015e 04B9 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @047E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0485 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @048C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1d // @04B2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000 // @04B5 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x015e label_04BA: // Incoming jump from 0x0463, if memory[stack[-3]:stack[-3] + 0x20] // Incoming jump from 0x0472, if address(stack[-5] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @04BC stack[-3] } 04BA 5B JUMPDEST 04BB 50 POP 04BC 81 DUP2 04BD 61 PUSH2 0x04cb 04C0 56 *JUMP // Stack delta = +0 // Outputs[1] { @04BC stack[-1] = stack[-3] } // Block ends with unconditional jump to 0x04cb label_04C1: // Incoming jump from 0x045D, if !stack[-3] // Inputs[2] // { // @04C5 stack[-3] // @04C6 stack[-2] // } 04C1 5B JUMPDEST 04C2 61 PUSH2 0x04cb 04C5 83 DUP4 04C6 83 DUP4 04C7 61 PUSH2 0x05e4 04CA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @04C2 stack[0] = 0x04cb // @04C5 stack[1] = stack[-3] // @04C6 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x05e4 label_04CB: // Incoming jump from 0x04C0 // Inputs[3] // { // @04CC stack[-1] // @04CC stack[-6] // @04CD stack[-5] // } 04CB 5B JUMPDEST 04CC 94 SWAP5 04CD 93 SWAP4 04CE 50 POP 04CF 50 POP 04D0 50 POP 04D1 50 POP 04D2 56 *JUMP // Stack delta = -5 // Outputs[1] { @04CC stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_04D3: // Incoming call from 0x03A7, returns to 0x03A8 // Inputs[1] { @04D7 stack[-1] } 04D3 5B JUMPDEST 04D4 61 PUSH2 0x04dc 04D7 81 DUP2 04D8 61 PUSH2 0x060e 04DB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @04D4 stack[0] = 0x04dc // @04D7 stack[1] = stack[-1] // } // Block ends with call to 0x060e, returns to 0x04DC label_04DC: // Incoming return from call to 0x060E at 0x04DB // Inputs[4] // { // @04DF memory[0x40:0x60] // @04E8 stack[-1] // @0510 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0512 stack[-2] // } 04DC 5B JUMPDEST 04DD 60 PUSH1 0x40 04DF 51 MLOAD 04E0 60 PUSH1 0x01 04E2 60 PUSH1 0x01 04E4 60 PUSH1 0xa0 04E6 1B SHL 04E7 03 SUB 04E8 82 DUP3 04E9 16 AND 04EA 90 SWAP1 04EB 7F PUSH32 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b 050C 90 SWAP1 050D 60 PUSH1 0x00 050F 90 SWAP1 0510 A2 LOG2 0511 50 POP 0512 56 *JUMP // Stack delta = -2 // Outputs[1] { @0510 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-2] label_0513: // Incoming jump from 0x041E // Inputs[1] { @051C stack[-1] } 0513 5B JUMPDEST 0514 60 PUSH1 0x01 0516 60 PUSH1 0x01 0518 60 PUSH1 0xa0 051A 1B SHL 051B 03 SUB 051C 81 DUP2 051D 16 AND 051E 61 PUSH2 0x0578 0521 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0578, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0522: // Incoming jump from 0x0521, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0524 memory[0x40:0x60] } 0522 60 PUSH1 0x40 0524 51 MLOAD 0525 62 PUSH3 0x461bcd 0529 60 PUSH1 0xe5 052B 1B SHL 052C 81 DUP2 052D 52 MSTORE 052E 60 PUSH1 0x20 0530 60 PUSH1 0x04 0532 82 DUP3 0533 01 ADD 0534 52 MSTORE 0535 60 PUSH1 0x26 0537 60 PUSH1 0x24 0539 82 DUP3 053A 01 ADD 053B 52 MSTORE 053C 7F PUSH32 0x455243313936373a206e65772061646d696e20697320746865207a65726f2061 055D 60 PUSH1 0x44 055F 82 DUP3 0560 01 ADD 0561 52 MSTORE 0562 65 PUSH6 0x646472657373 0569 60 PUSH1 0xd0 056B 1B SHL 056C 60 PUSH1 0x64 056E 82 DUP3 056F 01 ADD 0570 52 MSTORE 0571 60 PUSH1 0x84 0573 01 ADD 0574 61 PUSH2 0x015e 0577 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @052D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0534 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @053B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0561 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313936373a206e65772061646d696e20697320746865207a65726f2061 // @0570 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @0573 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x015e label_0578: // Incoming jump from 0x0521, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0579 stack[-1] } 0578 5B JUMPDEST 0579 80 DUP1 057A 7F PUSH32 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103 // Stack delta = +2 // Outputs[2] // { // @0579 stack[0] = stack[-1] // @057A stack[1] = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103 // } // Block continues label_059B: // Incoming jump from 0x057A // Incoming jump from 0x06A1 // Inputs[4] // { // @059C stack[-1] // @059D storage[stack[-1]] // @05B0 stack[-2] // @05BB stack[-4] // } 059B 5B JUMPDEST 059C 80 DUP1 059D 54 SLOAD 059E 60 PUSH1 0x01 05A0 60 PUSH1 0x01 05A2 60 PUSH1 0xa0 05A4 1B SHL 05A5 03 SUB 05A6 19 NOT 05A7 16 AND 05A8 60 PUSH1 0x01 05AA 60 PUSH1 0x01 05AC 60 PUSH1 0xa0 05AE 1B SHL 05AF 03 SUB 05B0 92 SWAP3 05B1 90 SWAP1 05B2 92 SWAP3 05B3 16 AND 05B4 91 SWAP2 05B5 90 SWAP1 05B6 91 SWAP2 05B7 17 OR 05B8 90 SWAP1 05B9 55 SSTORE 05BA 50 POP 05BB 56 *JUMP // Stack delta = -4 // Outputs[1] { @05B9 storage[stack[-1]] = ((0x01 << 0xa0) - 0x01 & stack[-2]) | (~((0x01 << 0xa0) - 0x01) & storage[stack[-1]]) } // Block ends with unconditional jump to stack[-4] label_05BC: // Incoming call from 0x042B, returns to 0x042C 05BC 5B JUMPDEST 05BD 60 PUSH1 0x00 05BF 7F PUSH32 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc 05E0 61 PUSH2 0x01db 05E3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @05BD stack[0] = 0x00 // @05BF stack[1] = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc // } // Block ends with unconditional jump to 0x01db label_05E4: // Incoming jump from 0x04CA // Inputs[2] // { // @05E5 stack[-2] // @05E6 memory[stack[-2]:stack[-2] + 0x20] // } 05E4 5B JUMPDEST 05E5 81 DUP2 05E6 51 MLOAD 05E7 15 ISZERO 05E8 61 PUSH2 0x05f4 05EB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f4, if !memory[stack[-2]:stack[-2] + 0x20] label_05EC: // Incoming jump from 0x05EB, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @05EC stack[-2] // @05ED memory[stack[-2]:stack[-2] + 0x20] // @05F3 memory[0x20 + stack[-2]:0x20 + stack[-2] + memory[stack[-2]:stack[-2] + 0x20]] // } 05EC 81 DUP2 05ED 51 MLOAD 05EE 80 DUP1 05EF 83 DUP4 05F0 60 PUSH1 0x20 05F2 01 ADD 05F3 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @05ED stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @05F3 revert(memory[0x20 + stack[-2]:0x20 + stack[-2] + memory[stack[-2]:stack[-2] + 0x20]]); // } // Block terminates label_05F4: // Incoming jump from 0x05EB, if !memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @05F5 stack[-1] // @05F8 memory[0x40:0x60] // } 05F4 5B JUMPDEST 05F5 80 DUP1 05F6 60 PUSH1 0x40 05F8 51 MLOAD 05F9 62 PUSH3 0x461bcd 05FD 60 PUSH1 0xe5 05FF 1B SHL 0600 81 DUP2 0601 52 MSTORE 0602 60 PUSH1 0x04 0604 01 ADD 0605 61 PUSH2 0x015e 0608 91 SWAP2 0609 90 SWAP1 060A 61 PUSH2 0x0823 060D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0601 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0608 stack[0] = 0x015e // @0609 stack[1] = stack[-1] // @0609 stack[2] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x0823, returns to 0x015E label_060E: // Incoming call from 0x04DB, returns to 0x04DC // Inputs[2] // { // @0617 stack[-1] // @0619 address(stack[-1] & (0x01 << 0xa0) - 0x01).code.length // } 060E 5B JUMPDEST 060F 60 PUSH1 0x01 0611 60 PUSH1 0x01 0613 60 PUSH1 0xa0 0615 1B SHL 0616 03 SUB 0617 81 DUP2 0618 16 AND 0619 3B EXTCODESIZE 061A 61 PUSH2 0x067b 061D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x067b, if address(stack[-1] & (0x01 << 0xa0) - 0x01).code.length label_061E: // Incoming jump from 0x061D, if not address(stack[-1] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0620 memory[0x40:0x60] } 061E 60 PUSH1 0x40 0620 51 MLOAD 0621 62 PUSH3 0x461bcd 0625 60 PUSH1 0xe5 0627 1B SHL 0628 81 DUP2 0629 52 MSTORE 062A 60 PUSH1 0x20 062C 60 PUSH1 0x04 062E 82 DUP3 062F 01 ADD 0630 52 MSTORE 0631 60 PUSH1 0x2d 0633 60 PUSH1 0x24 0635 82 DUP3 0636 01 ADD 0637 52 MSTORE 0638 7F PUSH32 0x455243313936373a206e657720696d706c656d656e746174696f6e206973206e 0659 60 PUSH1 0x44 065B 82 DUP3 065C 01 ADD 065D 52 MSTORE 065E 6C PUSH13 0x1bdd08184818dbdb9d1c9858dd 066C 60 PUSH1 0x9a 066E 1B SHL 066F 60 PUSH1 0x64 0671 82 DUP3 0672 01 ADD 0673 52 MSTORE 0674 60 PUSH1 0x84 0676 01 ADD 0677 61 PUSH2 0x015e 067A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0629 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0630 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0637 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2d // @065D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313936373a206e657720696d706c656d656e746174696f6e206973206e // @0673 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x1bdd08184818dbdb9d1c9858dd << 0x9a // @0676 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x015e label_067B: // Incoming jump from 0x061D, if address(stack[-1] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @067C stack[-1] } 067B 5B JUMPDEST 067C 80 DUP1 067D 7F PUSH32 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc 069E 61 PUSH2 0x059b 06A1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @067C stack[0] = stack[-1] // @067D stack[1] = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc // } // Block ends with unconditional jump to 0x059b label_06A2: // Incoming call from 0x0252, returns to 0x0253 // Incoming call from 0x029F, returns to 0x02A0 // Incoming call from 0x0202, returns to 0x0203 // Inputs[2] // { // @06A6 stack[-4] // @06A7 stack[-3] // } 06A2 5B JUMPDEST 06A3 60 PUSH1 0x00 06A5 80 DUP1 06A6 85 DUP6 06A7 85 DUP6 06A8 11 GT 06A9 15 ISZERO 06AA 61 PUSH2 0x06b2 06AD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @06A3 stack[0] = 0x00 // @06A5 stack[1] = 0x00 // } // Block ends with conditional jump to 0x06b2, if !(stack[-3] > stack[-4]) label_06AE: // Incoming jump from 0x06AD, if not !(stack[-3] > stack[-4]) // Inputs[1] { @06B1 memory[0x00:0x00] } 06AE 60 PUSH1 0x00 06B0 80 DUP1 06B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @06B1 revert(memory[0x00:0x00]); } // Block terminates label_06B2: // Incoming jump from 0x06AD, if !(stack[-3] > stack[-4]) // Inputs[2] // { // @06B3 stack[-4] // @06B4 stack[-6] // } 06B2 5B JUMPDEST 06B3 83 DUP4 06B4 86 DUP7 06B5 11 GT 06B6 15 ISZERO 06B7 61 PUSH2 0x06bf 06BA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06bf, if !(stack[-6] > stack[-4]) label_06BB: // Incoming jump from 0x06BA, if not !(stack[-6] > stack[-4]) // Inputs[1] { @06BE memory[0x00:0x00] } 06BB 60 PUSH1 0x00 06BD 80 DUP1 06BE FD *REVERT // Stack delta = +0 // Outputs[1] { @06BE revert(memory[0x00:0x00]); } // Block terminates label_06BF: // Incoming jump from 0x06BA, if !(stack[-6] > stack[-4]) // Inputs[5] // { // @06C2 stack[-5] // @06C3 stack[-3] // @06C4 stack[-7] // @06C6 stack[-4] // @06C7 stack[-6] // } 06BF 5B JUMPDEST 06C0 50 POP 06C1 50 POP 06C2 82 DUP3 06C3 01 ADD 06C4 93 SWAP4 06C5 91 SWAP2 06C6 90 SWAP1 06C7 92 SWAP3 06C8 03 SUB 06C9 91 SWAP2 06CA 50 POP 06CB 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @06C4 stack[-7] = stack[-5] + stack[-3] // @06C9 stack[-6] = stack[-6] - stack[-5] // } // Block ends with unconditional jump to stack[-7] label_06CC: // Incoming call from 0x0702, returns to 0x019E // Incoming call from 0x0734, returns to 0x0735 // Inputs[2] // { // @06CD stack[-1] // @06CE msg.data[stack[-1]:stack[-1] + 0x20] // } 06CC 5B JUMPDEST 06CD 80 DUP1 06CE 35 CALLDATALOAD 06CF 60 PUSH1 0x01 06D1 60 PUSH1 0x01 06D3 60 PUSH1 0xa0 06D5 1B SHL 06D6 03 SUB 06D7 81 DUP2 06D8 16 AND 06D9 81 DUP2 06DA 14 EQ 06DB 61 PUSH2 0x06e3 06DE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06CE stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x06e3, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_06DF: // Incoming jump from 0x06DE, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @06E2 memory[0x00:0x00] } 06DF 60 PUSH1 0x00 06E1 80 DUP1 06E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @06E2 revert(memory[0x00:0x00]); } // Block terminates label_06E3: // Incoming jump from 0x06DE, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @06E4 stack[-1] // @06E4 stack[-3] // @06E5 stack[-2] // } 06E3 5B JUMPDEST 06E4 91 SWAP2 06E5 90 SWAP1 06E6 50 POP 06E7 56 *JUMP // Stack delta = -2 // Outputs[1] { @06E4 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_06E8: // Incoming call from 0x02AC, returns to 0x02AD // Incoming call from 0x020F, returns to 0x0210 // Inputs[2] // { // @06ED stack[-1] // @06EE stack[-2] // } 06E8 5B JUMPDEST 06E9 60 PUSH1 0x00 06EB 60 PUSH1 0x20 06ED 82 DUP3 06EE 84 DUP5 06EF 03 SUB 06F0 12 SLT 06F1 15 ISZERO 06F2 61 PUSH2 0x06fa 06F5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06E9 stack[0] = 0x00 } // Block ends with conditional jump to 0x06fa, if !(stack[-2] - stack[-1] i< 0x20) label_06F6: // Incoming jump from 0x06F5, if not !(stack[-2] - stack[-1] i< 0x20) // 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< 0x20) // Inputs[1] { @06FE stack[-2] } 06FA 5B JUMPDEST 06FB 61 PUSH2 0x019e 06FE 82 DUP3 06FF 61 PUSH2 0x06cc 0702 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06FB stack[0] = 0x019e // @06FE stack[1] = stack[-2] // } // Block ends with call to 0x06cc, returns to 0x019E label_0703: // Incoming jump from 0x079F // Incoming jump from 0x0777 // Inputs[1] { @0718 memory[0x00:0x24] } 0703 5B JUMPDEST 0704 63 PUSH4 0x4e487b71 0709 60 PUSH1 0xe0 070B 1B SHL 070C 60 PUSH1 0x00 070E 52 MSTORE 070F 60 PUSH1 0x41 0711 60 PUSH1 0x04 0713 52 MSTORE 0714 60 PUSH1 0x24 0716 60 PUSH1 0x00 0718 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @070E memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0713 memory[0x04:0x24] = 0x41 // @0718 revert(memory[0x00:0x24]); // } // Block terminates label_0719: // Incoming call from 0x025F, returns to 0x0260 // Inputs[2] // { // @071F stack[-1] // @0720 stack[-2] // } 0719 5B JUMPDEST 071A 60 PUSH1 0x00 071C 80 DUP1 071D 60 PUSH1 0x40 071F 83 DUP4 0720 85 DUP6 0721 03 SUB 0722 12 SLT 0723 15 ISZERO 0724 61 PUSH2 0x072c 0727 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @071A stack[0] = 0x00 // @071C stack[1] = 0x00 // } // Block ends with conditional jump to 0x072c, if !(stack[-2] - stack[-1] i< 0x40) label_0728: // Incoming jump from 0x0727, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @072B memory[0x00:0x00] } 0728 60 PUSH1 0x00 072A 80 DUP1 072B FD *REVERT // Stack delta = +0 // Outputs[1] { @072B revert(memory[0x00:0x00]); } // Block terminates label_072C: // Incoming jump from 0x0727, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @0730 stack[-3] } 072C 5B JUMPDEST 072D 61 PUSH2 0x0735 0730 83 DUP4 0731 61 PUSH2 0x06cc 0734 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @072D stack[0] = 0x0735 // @0730 stack[1] = stack[-3] // } // Block ends with call to 0x06cc, returns to 0x0735 label_0735: // Incoming return from call to 0x06CC at 0x0734 // Inputs[4] // { // @0736 stack[-1] // @0736 stack[-3] // @073A stack[-4] // @073C msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 0735 5B JUMPDEST 0736 91 SWAP2 0737 50 POP 0738 60 PUSH1 0x20 073A 83 DUP4 073B 01 ADD 073C 35 CALLDATALOAD 073D 67 PUSH8 0xffffffffffffffff 0746 80 DUP1 0747 82 DUP3 0748 11 GT 0749 15 ISZERO 074A 61 PUSH2 0x0752 074D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0736 stack[-3] = stack[-1] // @073C stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @073D stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x0752, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) label_074E: // Incoming jump from 0x074D, if not !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @0751 memory[0x00:0x00] } 074E 60 PUSH1 0x00 0750 80 DUP1 0751 FD *REVERT // Stack delta = +0 // Outputs[1] { @0751 revert(memory[0x00:0x00]); } // Block terminates label_0752: // Incoming jump from 0x074D, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @0753 stack[-2] // @0754 stack[-5] // @0758 stack[-6] // } 0752 5B JUMPDEST 0753 81 DUP2 0754 85 DUP6 0755 01 ADD 0756 91 SWAP2 0757 50 POP 0758 85 DUP6 0759 60 PUSH1 0x1f 075B 83 DUP4 075C 01 ADD 075D 12 SLT 075E 61 PUSH2 0x0766 0761 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0756 stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x0766, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_0762: // Incoming jump from 0x0761, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @0765 memory[0x00:0x00] } 0762 60 PUSH1 0x00 0764 80 DUP1 0765 FD *REVERT // Stack delta = +0 // Outputs[1] { @0765 revert(memory[0x00:0x00]); } // Block terminates label_0766: // Incoming jump from 0x0761, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @0767 stack[-2] // @0768 msg.data[stack[-2]:stack[-2] + 0x20] // @0769 stack[-1] // } 0766 5B JUMPDEST 0767 81 DUP2 0768 35 CALLDATALOAD 0769 81 DUP2 076A 81 DUP2 076B 11 GT 076C 15 ISZERO 076D 61 PUSH2 0x0778 0770 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0768 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0778, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_0771: // Incoming jump from 0x0770, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) 0771 61 PUSH2 0x0778 0774 61 PUSH2 0x0703 0777 56 *JUMP // Stack delta = +1 // Outputs[1] { @0771 stack[0] = 0x0778 } // Block ends with unconditional jump to 0x0703 label_0778: // Incoming jump from 0x0770, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @077B memory[0x40:0x60] // @077E stack[-1] // @078D stack[-2] // } 0778 5B JUMPDEST 0779 60 PUSH1 0x40 077B 51 MLOAD 077C 60 PUSH1 0x1f 077E 82 DUP3 077F 01 ADD 0780 60 PUSH1 0x1f 0782 19 NOT 0783 90 SWAP1 0784 81 DUP2 0785 16 AND 0786 60 PUSH1 0x3f 0788 01 ADD 0789 16 AND 078A 81 DUP2 078B 01 ADD 078C 90 SWAP1 078D 83 DUP4 078E 82 DUP3 078F 11 GT 0790 81 DUP2 0791 83 DUP4 0792 10 LT 0793 17 OR 0794 15 ISZERO 0795 61 PUSH2 0x07a0 0798 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @078C stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) // @078C stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x07a0, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) > stack[-2])) label_0799: // Incoming jump from 0x0798, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) > stack[-2])) 0799 61 PUSH2 0x07a0 079C 61 PUSH2 0x0703 079F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0799 stack[0] = 0x07a0 } // Block ends with unconditional jump to 0x0703 label_07A0: // Incoming jump from 0x0798, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-1] + 0x1f) & ~0x1f) > stack[-2])) // Inputs[5] // { // @07A1 stack[-2] // @07A5 stack[-3] // @07A6 stack[-1] // @07A8 stack[-9] // @07AC stack[-5] // } 07A0 5B JUMPDEST 07A1 81 DUP2 07A2 60 PUSH1 0x40 07A4 52 MSTORE 07A5 82 DUP3 07A6 81 DUP2 07A7 52 MSTORE 07A8 88 DUP9 07A9 60 PUSH1 0x20 07AB 84 DUP5 07AC 87 DUP8 07AD 01 ADD 07AE 01 ADD 07AF 11 GT 07B0 15 ISZERO 07B1 61 PUSH2 0x07b9 07B4 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @07A4 memory[0x40:0x60] = stack[-2] // @07A7 memory[stack[-1]:stack[-1] + 0x20] = stack[-3] // } // Block ends with conditional jump to 0x07b9, if !(stack[-5] + stack[-3] + 0x20 > stack[-9]) label_07B5: // Incoming jump from 0x07B4, if not !(stack[-5] + stack[-3] + 0x20 > stack[-9]) // Inputs[1] { @07B8 memory[0x00:0x00] } 07B5 60 PUSH1 0x00 07B7 80 DUP1 07B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @07B8 revert(memory[0x00:0x00]); } // Block terminates label_07B9: // Incoming jump from 0x07B4, if !(stack[-5] + stack[-3] + 0x20 > stack[-9]) // Inputs[9] // { // @07BA stack[-3] // @07BD stack[-5] // @07C1 stack[-1] // @07C3 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + stack[-3]] // @07CE stack[-6] // @07D5 stack[-9] // @07D7 stack[-10] // @07D7 stack[-7] // @07D8 stack[-8] // } 07B9 5B JUMPDEST 07BA 82 DUP3 07BB 60 PUSH1 0x20 07BD 86 DUP7 07BE 01 ADD 07BF 60 PUSH1 0x20 07C1 83 DUP4 07C2 01 ADD 07C3 37 CALLDATACOPY 07C4 60 PUSH1 0x00 07C6 60 PUSH1 0x20 07C8 84 DUP5 07C9 83 DUP4 07CA 01 ADD 07CB 01 ADD 07CC 52 MSTORE 07CD 80 DUP1 07CE 95 SWAP6 07CF 50 POP 07D0 50 POP 07D1 50 POP 07D2 50 POP 07D3 50 POP 07D4 50 POP 07D5 92 SWAP3 07D6 50 POP 07D7 92 SWAP3 07D8 90 SWAP1 07D9 50 POP 07DA 56 *JUMP // Stack delta = -8 // Outputs[4] // { // @07C3 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-3]] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + stack[-3]] // @07CC memory[stack[-1] + stack[-3] + 0x20:stack[-1] + stack[-3] + 0x20 + 0x20] = 0x00 // @07D5 stack[-9] = stack[-1] // @07D7 stack[-10] = stack[-7] // } // Block ends with unconditional jump to stack[-10] label_07DB: // Incoming call from 0x0818, returns to 0x0819 // Incoming call from 0x0841, returns to 0x0842 // Inputs[1] { @07DF stack[-3] } 07DB 5B JUMPDEST 07DC 60 PUSH1 0x00 07DE 5B JUMPDEST 07DF 83 DUP4 07E0 81 DUP2 07E1 10 LT 07E2 15 ISZERO 07E3 61 PUSH2 0x07f6 07E6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07DC stack[0] = 0x00 } // Block ends with conditional jump to 0x07f6, if !(0x00 < stack[-3]) label_07E7: // Incoming jump from 0x07E6, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x07E6, if not !(0x00 < stack[-3]) // Inputs[4] // { // @07E7 stack[-2] // @07E8 stack[-1] // @07EA memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @07EB stack[-3] // } 07E7 81 DUP2 07E8 81 DUP2 07E9 01 ADD 07EA 51 MLOAD 07EB 83 DUP4 07EC 82 DUP3 07ED 01 ADD 07EE 52 MSTORE 07EF 60 PUSH1 0x20 07F1 01 ADD 07F2 61 PUSH2 0x07de 07F5 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @07EE memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @07F1 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x07de label_07F6: // Incoming jump from 0x07E6, if !(stack[-1] < stack[-4]) // Incoming jump from 0x07E6, if !(0x00 < stack[-3]) // Inputs[2] // { // @07F7 stack[-4] // @07F8 stack[-1] // } 07F6 5B JUMPDEST 07F7 83 DUP4 07F8 81 DUP2 07F9 11 GT 07FA 15 ISZERO 07FB 61 PUSH2 0x03c4 07FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c4, if !(stack[-1] > stack[-4]) label_07FF: // Incoming jump from 0x07FE, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @0803 stack[-4] // @0804 stack[-3] // @0806 stack[-5] // } 07FF 50 POP 0800 50 POP 0801 60 PUSH1 0x00 0803 91 SWAP2 0804 01 ADD 0805 52 MSTORE 0806 56 *JUMP // Stack delta = -5 // Outputs[1] { @0805 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_0807: // Incoming call from 0x0338, returns to 0x0339 // Inputs[3] // { // @080A stack[-2] // @080B memory[stack[-2]:stack[-2] + 0x20] // @0810 stack[-1] // } 0807 5B JUMPDEST 0808 60 PUSH1 0x00 080A 82 DUP3 080B 51 MLOAD 080C 61 PUSH2 0x0819 080F 81 DUP2 0810 84 DUP5 0811 60 PUSH1 0x20 0813 87 DUP8 0814 01 ADD 0815 61 PUSH2 0x07db 0818 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0808 stack[0] = 0x00 // @080B stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @080C stack[2] = 0x0819 // @080F stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @0810 stack[4] = stack[-1] // @0814 stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x07db, returns to 0x0819 label_0819: // Incoming return from call to 0x07DB at 0x0818 // Inputs[5] // { // @081A stack[-3] // @081A stack[-1] // @081B stack[-2] // @081E stack[-5] // @081F stack[-4] // } 0819 5B JUMPDEST 081A 91 SWAP2 081B 90 SWAP1 081C 91 SWAP2 081D 01 ADD 081E 92 SWAP3 081F 91 SWAP2 0820 50 POP 0821 50 POP 0822 56 *JUMP // Stack delta = -4 // Outputs[1] { @081E stack[-5] = stack[-1] + stack[-3] } // Block ends with unconditional jump to stack[-5] label_0823: // Incoming call from 0x060D, returns to 0x015E // Inputs[3] // { // @0826 stack[-1] // @082A stack[-2] // @082B memory[stack[-2]:stack[-2] + 0x20] // } 0823 5B JUMPDEST 0824 60 PUSH1 0x20 0826 81 DUP2 0827 52 MSTORE 0828 60 PUSH1 0x00 082A 82 DUP3 082B 51 MLOAD 082C 80 DUP1 082D 60 PUSH1 0x20 082F 84 DUP5 0830 01 ADD 0831 52 MSTORE 0832 61 PUSH2 0x0842 0835 81 DUP2 0836 60 PUSH1 0x40 0838 85 DUP6 0839 01 ADD 083A 60 PUSH1 0x20 083C 87 DUP8 083D 01 ADD 083E 61 PUSH2 0x07db 0841 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @0827 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @0828 stack[0] = 0x00 // @082B stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @0831 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @0832 stack[2] = 0x0842 // @0835 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @0839 stack[4] = stack[-1] + 0x40 // @083D stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x07db, returns to 0x0842 label_0842: // Incoming return from call to 0x07DB at 0x0841 // Inputs[5] // { // @0845 stack[-1] // @084A stack[-3] // @084B stack[-2] // @0851 stack[-5] // @0852 stack[-4] // } 0842 5B JUMPDEST 0843 60 PUSH1 0x1f 0845 01 ADD 0846 60 PUSH1 0x1f 0848 19 NOT 0849 16 AND 084A 91 SWAP2 084B 90 SWAP1 084C 91 SWAP2 084D 01 ADD 084E 60 PUSH1 0x40 0850 01 ADD 0851 92 SWAP3 0852 91 SWAP2 0853 50 POP 0854 50 POP 0855 56 *JUMP // Stack delta = -4 // Outputs[1] { @0851 stack[-5] = 0x40 + (~0x1f & 0x1f + stack[-1]) + stack[-3] } // Block ends with unconditional jump to stack[-5] 0856 FE *ASSERT 0857 41 COINBASE 0858 64 PUSH5 0x6472657373 085E 3A GASPRICE 085F 20 SHA3 0860 6C PUSH13 0x6f772d6c6576656c2064656c65 086E 67 PUSH8 0x6174652063616c6c 0877 20 SHA3 0878 66 PUSH7 0x61696c6564a264 0880 69 PUSH10 0x7066735822122012bb4f 088B 56 *JUMP 088C 4F 4F 088D 73 PUSH20 0x959a03513dc74fc3c6e40e8386e6f02c16b78d6d 08A2 B0 PUSH 08A3 0C 0C 08A4 E0 E0 08A5 AA AA 08A6 16 AND 08A7 AF AF 08A8 64 PUSH5 0x736f6c6343 08AE 00 *STOP 08AF 08 ADDMOD 08B0 09 MULMOD 08B1 00 *STOP 08B2 33 CALLER