Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x0036 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0036, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x893d20e8 0026 14 EQ 0027 61 PUSH2 0x003b 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x003b, if 0x893d20e8 == msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x893d20e8 == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xa6f9dae1 0031 14 EQ 0032 61 PUSH2 0x0059 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0059, if 0xa6f9dae1 == stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xa6f9dae1 == stack[-1] // Incoming jump from 0x0019, if msg.data.length < 0x04 // Inputs[1] { @003A memory[0x00:0x00] } 0036 5B JUMPDEST 0037 60 PUSH1 0x00 0039 80 DUP1 003A FD *REVERT // Stack delta = +0 // Outputs[1] { @003A revert(memory[0x00:0x00]); } // Block terminates label_003B: // Incoming jump from 0x002A, if 0x893d20e8 == msg.data[0x00:0x20] >> 0xe0 003B 5B JUMPDEST 003C 61 PUSH2 0x0043 003F 61 PUSH2 0x0075 0042 56 *JUMP // Stack delta = +1 // Outputs[1] { @003C stack[0] = 0x0043 } // Block ends with call to 0x0075, returns to 0x0043 label_0043: // Incoming return from call to 0x0075 at 0x0042 // Inputs[2] // { // @0046 memory[0x40:0x60] // @004A stack[-1] // } 0043 5B JUMPDEST 0044 60 PUSH1 0x40 0046 51 MLOAD 0047 61 PUSH2 0x0050 004A 91 SWAP2 004B 90 SWAP1 004C 61 PUSH2 0x0316 004F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @004A stack[-1] = 0x0050 // @004B stack[1] = memory[0x40:0x60] // @004B stack[0] = stack[-1] // } // Block ends with call to 0x0316, returns to 0x0050 label_0050: // Incoming return from call to 0x0316 at 0x004F // Inputs[3] // { // @0053 memory[0x40:0x60] // @0055 stack[-1] // @0058 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0050 5B JUMPDEST 0051 60 PUSH1 0x40 0053 51 MLOAD 0054 80 DUP1 0055 91 SWAP2 0056 03 SUB 0057 90 SWAP1 0058 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0058 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0059: // Incoming jump from 0x0035, if 0xa6f9dae1 == stack[-1] // Inputs[1] { @0060 msg.data.length } 0059 5B JUMPDEST 005A 61 PUSH2 0x0073 005D 60 PUSH1 0x04 005F 80 DUP1 0060 36 CALLDATASIZE 0061 03 SUB 0062 81 DUP2 0063 01 ADD 0064 90 SWAP1 0065 61 PUSH2 0x006e 0068 91 SWAP2 0069 90 SWAP1 006A 61 PUSH2 0x0362 006D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @005A stack[0] = 0x0073 // @0068 stack[1] = 0x006e // @0069 stack[2] = 0x04 + (msg.data.length - 0x04) // @0069 stack[3] = 0x04 // } // Block ends with call to 0x0362, returns to 0x006E label_006E: // Incoming return from call to 0x0362 at 0x006D 006E 5B JUMPDEST 006F 61 PUSH2 0x009e 0072 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x009e label_0073: // Incoming return from call to 0x006E at 0x006D 0073 5B JUMPDEST 0074 00 *STOP // Stack delta = +0 // Outputs[1] { @0074 stop(); } // Block terminates label_0075: // Incoming call from 0x0042, returns to 0x0043 // Inputs[2] // { // @007C storage[0x00] // @009C stack[-1] // } 0075 5B JUMPDEST 0076 60 PUSH1 0x00 0078 80 DUP1 0079 60 PUSH1 0x00 007B 90 SWAP1 007C 54 SLOAD 007D 90 SWAP1 007E 61 PUSH2 0x0100 0081 0A EXP 0082 90 SWAP1 0083 04 DIV 0084 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0099 16 AND 009A 90 SWAP1 009B 50 POP 009C 90 SWAP1 009D 56 *JUMP // Stack delta = +0 // Outputs[1] { @009C stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_009E: // Incoming jump from 0x0072 // Inputs[2] // { // @00A2 storage[0x00] // @00D6 msg.sender // } 009E 5B JUMPDEST 009F 60 PUSH1 0x00 00A1 80 DUP1 00A2 54 SLOAD 00A3 90 SWAP1 00A4 61 PUSH2 0x0100 00A7 0A EXP 00A8 90 SWAP1 00A9 04 DIV 00AA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00BF 16 AND 00C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00D5 16 AND 00D6 33 CALLER 00D7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00EC 16 AND 00ED 14 EQ 00EE 61 PUSH2 0x012c 00F1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x012c, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 label_00F2: // Incoming jump from 0x00F1, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 // Inputs[1] { @00F4 memory[0x40:0x60] } 00F2 60 PUSH1 0x40 00F4 51 MLOAD 00F5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0116 81 DUP2 0117 52 MSTORE 0118 60 PUSH1 0x04 011A 01 ADD 011B 61 PUSH2 0x0123 011E 90 SWAP1 011F 61 PUSH2 0x03ec 0122 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0117 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @011E stack[0] = 0x0123 // @011E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x03ec, returns to 0x0123 label_0123: // Incoming return from call to 0x03EC at 0x0122 // Inputs[3] // { // @0126 memory[0x40:0x60] // @0128 stack[-1] // @012B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0123 5B JUMPDEST 0124 60 PUSH1 0x40 0126 51 MLOAD 0127 80 DUP1 0128 91 SWAP2 0129 03 SUB 012A 90 SWAP1 012B FD *REVERT // Stack delta = -1 // Outputs[1] { @012B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_012C: // Incoming jump from 0x00F1, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 // Inputs[7] // { // @012D stack[-1] // @0147 storage[0x00] // @019E memory[0x40:0x60] // @01A1 memory[0x40:0x60] // @01A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @01B0 storage[0x00] // @01E8 stack[-2] // } 012C 5B JUMPDEST 012D 80 DUP1 012E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0143 16 AND 0144 60 PUSH1 0x00 0146 80 DUP1 0147 54 SLOAD 0148 90 SWAP1 0149 61 PUSH2 0x0100 014C 0A EXP 014D 90 SWAP1 014E 04 DIV 014F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0164 16 AND 0165 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 017A 16 AND 017B 7F PUSH32 0x342827c97908e5e2f71151c08502a66d44b6f758e3ac2f1de95f02eb95f0a735 019C 60 PUSH1 0x40 019E 51 MLOAD 019F 60 PUSH1 0x40 01A1 51 MLOAD 01A2 80 DUP1 01A3 91 SWAP2 01A4 03 SUB 01A5 90 SWAP1 01A6 A3 LOG3 01A7 80 DUP1 01A8 60 PUSH1 0x00 01AA 80 DUP1 01AB 61 PUSH2 0x0100 01AE 0A EXP 01AF 81 DUP2 01B0 54 SLOAD 01B1 81 DUP2 01B2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01C7 02 MUL 01C8 19 NOT 01C9 16 AND 01CA 90 SWAP1 01CB 83 DUP4 01CC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01E1 16 AND 01E2 02 MUL 01E3 17 OR 01E4 90 SWAP1 01E5 55 SSTORE 01E6 50 POP 01E7 50 POP 01E8 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @01A6 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x342827c97908e5e2f71151c08502a66d44b6f758e3ac2f1de95f02eb95f0a735, storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // @01E5 storage[0x00] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x00]) // } // Block ends with unconditional jump to stack[-2] 01E9 5B JUMPDEST 01EA 61 PUSH2 0x0281 01ED 82 DUP3 01EE 82 DUP3 01EF 60 PUSH1 0x40 01F1 51 MLOAD 01F2 60 PUSH1 0x24 01F4 01 ADD 01F5 61 PUSH2 0x01ff 01F8 92 SWAP3 01F9 91 SWAP2 01FA 90 SWAP1 01FB 61 PUSH2 0x048b 01FE 56 *JUMP 01FF 5B JUMPDEST 0200 60 PUSH1 0x40 0202 51 MLOAD 0203 60 PUSH1 0x20 0205 81 DUP2 0206 83 DUP4 0207 03 SUB 0208 03 SUB 0209 81 DUP2 020A 52 MSTORE 020B 90 SWAP1 020C 60 PUSH1 0x40 020E 52 MSTORE 020F 7F PUSH32 0x319af33300000000000000000000000000000000000000000000000000000000 0230 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 024D 19 NOT 024E 16 AND 024F 60 PUSH1 0x20 0251 82 DUP3 0252 01 ADD 0253 80 DUP1 0254 51 MLOAD 0255 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0272 83 DUP4 0273 81 DUP2 0274 83 DUP4 0275 16 AND 0276 17 OR 0277 83 DUP4 0278 52 MSTORE 0279 50 POP 027A 50 POP 027B 50 POP 027C 50 POP 027D 61 PUSH2 0x02a6 0280 56 *JUMP 0281 5B JUMPDEST 0282 50 POP 0283 50 POP 0284 56 *JUMP 0285 5B JUMPDEST 0286 60 PUSH1 0x00 0288 6A PUSH11 0x636f6e736f6c652e6c6f67 0294 90 SWAP1 0295 50 POP 0296 60 PUSH1 0x00 0298 80 DUP1 0299 83 DUP4 029A 51 MLOAD 029B 60 PUSH1 0x20 029D 85 DUP6 029E 01 ADD 029F 84 DUP5 02A0 5A GAS 02A1 FA STATICCALL 02A2 50 POP 02A3 50 POP 02A4 50 POP 02A5 56 *JUMP 02A6 5B JUMPDEST 02A7 61 PUSH2 0x02bd 02AA 81 DUP2 02AB 61 PUSH2 0x02b5 02AE 61 PUSH2 0x0285 02B1 61 PUSH2 0x02c0 02B4 56 *JUMP 02B5 5B JUMPDEST 02B6 63 PUSH4 0xffffffff 02BB 16 AND 02BC 56 *JUMP 02BD 5B JUMPDEST 02BE 50 POP 02BF 56 *JUMP 02C0 5B JUMPDEST 02C1 61 PUSH2 0x02cb 02C4 81 DUP2 02C5 90 SWAP1 02C6 50 POP 02C7 91 SWAP2 02C8 90 SWAP1 02C9 50 POP 02CA 56 *JUMP 02CB 5B JUMPDEST 02CC 61 PUSH2 0x02d3 02CF 61 PUSH2 0x04bb 02D2 56 *JUMP 02D3 5B JUMPDEST 02D4 56 *JUMP label_02D5: // Incoming call from 0x02FF, returns to 0x0300 // Inputs[2] // { // @02ED stack[-1] // @02F1 stack[-2] // } 02D5 5B JUMPDEST 02D6 60 PUSH1 0x00 02D8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02ED 82 DUP3 02EE 16 AND 02EF 90 SWAP1 02F0 50 POP 02F1 91 SWAP2 02F2 90 SWAP1 02F3 50 POP 02F4 56 *JUMP // Stack delta = -1 // Outputs[1] { @02F1 stack[-2] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff } // Block ends with unconditional jump to stack[-2] label_02F5: // Incoming call from 0x030F, returns to 0x0310 // Incoming call from 0x033E, returns to 0x033F // Inputs[1] { @02FB stack[-1] } 02F5 5B JUMPDEST 02F6 60 PUSH1 0x00 02F8 61 PUSH2 0x0300 02FB 82 DUP3 02FC 61 PUSH2 0x02d5 02FF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @02F6 stack[0] = 0x00 // @02F8 stack[1] = 0x0300 // @02FB stack[2] = stack[-1] // } // Block ends with call to 0x02d5, returns to 0x0300 label_0300: // Incoming return from call to 0x02D5 at 0x02FF // Inputs[4] // { // @0301 stack[-2] // @0301 stack[-1] // @0303 stack[-4] // @0304 stack[-3] // } 0300 5B JUMPDEST 0301 90 SWAP1 0302 50 POP 0303 91 SWAP2 0304 90 SWAP1 0305 50 POP 0306 56 *JUMP // Stack delta = -3 // Outputs[1] { @0303 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0307: // Incoming call from 0x032A, returns to 0x032B // Inputs[1] { @030B stack[-1] } 0307 5B JUMPDEST 0308 61 PUSH2 0x0310 030B 81 DUP2 030C 61 PUSH2 0x02f5 030F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0308 stack[0] = 0x0310 // @030B stack[1] = stack[-1] // } // Block ends with call to 0x02f5, returns to 0x0310 label_0310: // Incoming return from call to 0x02F5 at 0x030F // Inputs[3] // { // @0311 stack[-3] // @0312 stack[-1] // @0315 stack[-4] // } 0310 5B JUMPDEST 0311 82 DUP3 0312 52 MSTORE 0313 50 POP 0314 50 POP 0315 56 *JUMP // Stack delta = -4 // Outputs[1] { @0312 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0316: // Incoming call from 0x004F, returns to 0x0050 // Inputs[2] // { // @031B stack[-1] // @0326 stack[-2] // } 0316 5B JUMPDEST 0317 60 PUSH1 0x00 0319 60 PUSH1 0x20 031B 82 DUP3 031C 01 ADD 031D 90 SWAP1 031E 50 POP 031F 61 PUSH2 0x032b 0322 60 PUSH1 0x00 0324 83 DUP4 0325 01 ADD 0326 84 DUP5 0327 61 PUSH2 0x0307 032A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @031D stack[0] = stack[-1] + 0x20 // @031F stack[1] = 0x032b // @0325 stack[2] = stack[-1] + 0x00 // @0326 stack[3] = stack[-2] // } // Block ends with call to 0x0307, returns to 0x032B label_032B: // Incoming return from call to 0x0307 at 0x032A // Inputs[3] // { // @032C stack[-4] // @032C stack[-1] // @032D stack[-3] // } 032B 5B JUMPDEST 032C 92 SWAP3 032D 91 SWAP2 032E 50 POP 032F 50 POP 0330 56 *JUMP // Stack delta = -3 // Outputs[1] { @032C stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0331: // Incoming jump from 0x0376 // Inputs[1] { @0335 memory[0x00:0x00] } 0331 5B JUMPDEST 0332 60 PUSH1 0x00 0334 80 DUP1 0335 FD *REVERT // Stack delta = +0 // Outputs[1] { @0335 revert(memory[0x00:0x00]); } // Block terminates label_0336: // Incoming call from 0x035B, returns to 0x035C // Inputs[1] { @033A stack[-1] } 0336 5B JUMPDEST 0337 61 PUSH2 0x033f 033A 81 DUP2 033B 61 PUSH2 0x02f5 033E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0337 stack[0] = 0x033f // @033A stack[1] = stack[-1] // } // Block ends with call to 0x02f5, returns to 0x033F label_033F: // Incoming return from call to 0x02F5 at 0x033E // Inputs[2] // { // @0340 stack[-2] // @0341 stack[-1] // } 033F 5B JUMPDEST 0340 81 DUP2 0341 14 EQ 0342 61 PUSH2 0x034a 0345 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x034a, if stack[-2] == stack[-1] label_0346: // Incoming jump from 0x0345, if not stack[-2] == stack[-1] // Inputs[1] { @0349 memory[0x00:0x00] } 0346 60 PUSH1 0x00 0348 80 DUP1 0349 FD *REVERT // Stack delta = +0 // Outputs[1] { @0349 revert(memory[0x00:0x00]); } // Block terminates label_034A: // Incoming jump from 0x0345, if stack[-2] == stack[-1] // Inputs[1] { @034C stack[-2] } 034A 5B JUMPDEST 034B 50 POP 034C 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_034D: // Incoming call from 0x0385, returns to 0x0386 // Inputs[2] // { // @0350 stack[-1] // @0351 msg.data[stack[-1]:stack[-1] + 0x20] // } 034D 5B JUMPDEST 034E 60 PUSH1 0x00 0350 81 DUP2 0351 35 CALLDATALOAD 0352 90 SWAP1 0353 50 POP 0354 61 PUSH2 0x035c 0357 81 DUP2 0358 61 PUSH2 0x0336 035B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0352 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @0354 stack[1] = 0x035c // @0357 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x0336, returns to 0x035C label_035C: // Incoming return from call to 0x0336 at 0x035B // Inputs[3] // { // @035D stack[-1] // @035D stack[-4] // @035E stack[-3] // } 035C 5B JUMPDEST 035D 92 SWAP3 035E 91 SWAP2 035F 50 POP 0360 50 POP 0361 56 *JUMP // Stack delta = -3 // Outputs[1] { @035D stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0362: // Incoming call from 0x006D, returns to 0x006E // Inputs[2] // { // @0367 stack[-1] // @0368 stack[-2] // } 0362 5B JUMPDEST 0363 60 PUSH1 0x00 0365 60 PUSH1 0x20 0367 82 DUP3 0368 84 DUP5 0369 03 SUB 036A 12 SLT 036B 15 ISZERO 036C 61 PUSH2 0x0378 036F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0363 stack[0] = 0x00 } // Block ends with conditional jump to 0x0378, if !(stack[-2] - stack[-1] i< 0x20) label_0370: // Incoming jump from 0x036F, if not !(stack[-2] - stack[-1] i< 0x20) 0370 61 PUSH2 0x0377 0373 61 PUSH2 0x0331 0376 56 *JUMP // Stack delta = +1 // Outputs[1] { @0370 stack[0] = 0x0377 } // Block ends with unconditional jump to 0x0331 0377 5B JUMPDEST label_0378: // Incoming jump from 0x036F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @037E stack[-3] // @0380 stack[-2] // } 0378 5B JUMPDEST 0379 60 PUSH1 0x00 037B 61 PUSH2 0x0386 037E 84 DUP5 037F 82 DUP3 0380 85 DUP6 0381 01 ADD 0382 61 PUSH2 0x034d 0385 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0379 stack[0] = 0x00 // @037B stack[1] = 0x0386 // @037E stack[2] = stack[-3] // @0381 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x034d, returns to 0x0386 label_0386: // Incoming return from call to 0x034D at 0x0385 // Inputs[4] // { // @0387 stack[-1] // @0387 stack[-3] // @038A stack[-6] // @038B stack[-5] // } 0386 5B JUMPDEST 0387 91 SWAP2 0388 50 POP 0389 50 POP 038A 92 SWAP3 038B 91 SWAP2 038C 50 POP 038D 50 POP 038E 56 *JUMP // Stack delta = -5 // Outputs[1] { @038A stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_038F: // Incoming call from 0x03D5, returns to 0x03D6 // Inputs[3] // { // @0392 stack[-2] // @0393 stack[-1] // @039B stack[-3] // } 038F 5B JUMPDEST 0390 60 PUSH1 0x00 0392 82 DUP3 0393 82 DUP3 0394 52 MSTORE 0395 60 PUSH1 0x20 0397 82 DUP3 0398 01 ADD 0399 90 SWAP1 039A 50 POP 039B 92 SWAP3 039C 91 SWAP2 039D 50 POP 039E 50 POP 039F 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0394 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @039B stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_03A0: // Incoming call from 0x03E0, returns to 0x03E1 // Inputs[2] // { // @03C4 stack[-1] // @03C8 stack[-2] // } 03A0 5B JUMPDEST 03A1 7F PUSH32 0x43616c6c6572206973206e6f74206f776e657200000000000000000000000000 03C2 60 PUSH1 0x00 03C4 82 DUP3 03C5 01 ADD 03C6 52 MSTORE 03C7 50 POP 03C8 56 *JUMP // Stack delta = -2 // Outputs[1] { @03C6 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x43616c6c6572206973206e6f74206f776e657200000000000000000000000000 } // Block ends with unconditional jump to stack[-2] label_03C9: // Incoming call from 0x0404, returns to 0x0405 // Inputs[1] { @03D1 stack[-1] } 03C9 5B JUMPDEST 03CA 60 PUSH1 0x00 03CC 61 PUSH2 0x03d6 03CF 60 PUSH1 0x13 03D1 83 DUP4 03D2 61 PUSH2 0x038f 03D5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03CA stack[0] = 0x00 // @03CC stack[1] = 0x03d6 // @03CF stack[2] = 0x13 // @03D1 stack[3] = stack[-1] // } // Block ends with call to 0x038f, returns to 0x03D6 label_03D6: // Incoming return from call to 0x038F at 0x03D5 // Inputs[2] // { // @03D7 stack[-3] // @03D7 stack[-1] // } 03D6 5B JUMPDEST 03D7 91 SWAP2 03D8 50 POP 03D9 61 PUSH2 0x03e1 03DC 82 DUP3 03DD 61 PUSH2 0x03a0 03E0 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @03D7 stack[-3] = stack[-1] // @03D9 stack[-1] = 0x03e1 // @03DC stack[0] = stack[-1] // } // Block ends with call to 0x03a0, returns to 0x03E1 label_03E1: // Incoming return from call to 0x03A0 at 0x03E0 // Inputs[3] // { // @03E4 stack[-2] // @03E6 stack[-1] // @03E8 stack[-3] // } 03E1 5B JUMPDEST 03E2 60 PUSH1 0x20 03E4 82 DUP3 03E5 01 ADD 03E6 90 SWAP1 03E7 50 POP 03E8 91 SWAP2 03E9 90 SWAP1 03EA 50 POP 03EB 56 *JUMP // Stack delta = -2 // Outputs[1] { @03E8 stack[-3] = stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_03EC: // Incoming call from 0x0122, returns to 0x0123 // Inputs[1] { @03F1 stack[-1] } 03EC 5B JUMPDEST 03ED 60 PUSH1 0x00 03EF 60 PUSH1 0x20 03F1 82 DUP3 03F2 01 ADD 03F3 90 SWAP1 03F4 50 POP 03F5 81 DUP2 03F6 81 DUP2 03F7 03 SUB 03F8 60 PUSH1 0x00 03FA 83 DUP4 03FB 01 ADD 03FC 52 MSTORE 03FD 61 PUSH2 0x0405 0400 81 DUP2 0401 61 PUSH2 0x03c9 0404 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03F3 stack[0] = stack[-1] + 0x20 // @03FC memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @03FD stack[1] = 0x0405 // @0400 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x03c9, returns to 0x0405 label_0405: // Incoming return from call to 0x03C9 at 0x0404 // Inputs[4] // { // @0406 stack[-1] // @0406 stack[-2] // @0408 stack[-4] // @0409 stack[-3] // } 0405 5B JUMPDEST 0406 90 SWAP1 0407 50 POP 0408 91 SWAP2 0409 90 SWAP1 040A 50 POP 040B 56 *JUMP // Stack delta = -3 // Outputs[1] { @0408 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] 040C 5B JUMPDEST 040D 60 PUSH1 0x00 040F 81 DUP2 0410 51 MLOAD 0411 90 SWAP1 0412 50 POP 0413 91 SWAP2 0414 90 SWAP1 0415 50 POP 0416 56 *JUMP 0417 5B JUMPDEST 0418 60 PUSH1 0x00 041A 5B JUMPDEST 041B 83 DUP4 041C 81 DUP2 041D 10 LT 041E 15 ISZERO 041F 61 PUSH2 0x0435 0422 57 *JUMPI 0423 80 DUP1 0424 82 DUP3 0425 01 ADD 0426 51 MLOAD 0427 81 DUP2 0428 84 DUP5 0429 01 ADD 042A 52 MSTORE 042B 60 PUSH1 0x20 042D 81 DUP2 042E 01 ADD 042F 90 SWAP1 0430 50 POP 0431 61 PUSH2 0x041a 0434 56 *JUMP 0435 5B JUMPDEST 0436 60 PUSH1 0x00 0438 84 DUP5 0439 84 DUP5 043A 01 ADD 043B 52 MSTORE 043C 50 POP 043D 50 POP 043E 50 POP 043F 50 POP 0440 56 *JUMP 0441 5B JUMPDEST 0442 60 PUSH1 0x00 0444 60 PUSH1 0x1f 0446 19 NOT 0447 60 PUSH1 0x1f 0449 83 DUP4 044A 01 ADD 044B 16 AND 044C 90 SWAP1 044D 50 POP 044E 91 SWAP2 044F 90 SWAP1 0450 50 POP 0451 56 *JUMP 0452 5B JUMPDEST 0453 60 PUSH1 0x00 0455 61 PUSH2 0x045d 0458 82 DUP3 0459 61 PUSH2 0x040c 045C 56 *JUMP 045D 5B JUMPDEST 045E 61 PUSH2 0x0467 0461 81 DUP2 0462 85 DUP6 0463 61 PUSH2 0x038f 0466 56 *JUMP 0467 5B JUMPDEST 0468 93 SWAP4 0469 50 POP 046A 61 PUSH2 0x0477 046D 81 DUP2 046E 85 DUP6 046F 60 PUSH1 0x20 0471 86 DUP7 0472 01 ADD 0473 61 PUSH2 0x0417 0476 56 *JUMP 0477 5B JUMPDEST 0478 61 PUSH2 0x0480 047B 81 DUP2 047C 61 PUSH2 0x0441 047F 56 *JUMP 0480 5B JUMPDEST 0481 84 DUP5 0482 01 ADD 0483 91 SWAP2 0484 50 POP 0485 50 POP 0486 92 SWAP3 0487 91 SWAP2 0488 50 POP 0489 50 POP 048A 56 *JUMP 048B 5B JUMPDEST 048C 60 PUSH1 0x00 048E 60 PUSH1 0x40 0490 82 DUP3 0491 01 ADD 0492 90 SWAP1 0493 50 POP 0494 81 DUP2 0495 81 DUP2 0496 03 SUB 0497 60 PUSH1 0x00 0499 83 DUP4 049A 01 ADD 049B 52 MSTORE 049C 61 PUSH2 0x04a5 049F 81 DUP2 04A0 85 DUP6 04A1 61 PUSH2 0x0452 04A4 56 *JUMP 04A5 5B JUMPDEST 04A6 90 SWAP1 04A7 50 POP 04A8 61 PUSH2 0x04b4 04AB 60 PUSH1 0x20 04AD 83 DUP4 04AE 01 ADD 04AF 84 DUP5 04B0 61 PUSH2 0x0307 04B3 56 *JUMP 04B4 5B JUMPDEST 04B5 93 SWAP4 04B6 92 SWAP3 04B7 50 POP 04B8 50 POP 04B9 50 POP 04BA 56 *JUMP 04BB 5B JUMPDEST 04BC 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 04DD 60 PUSH1 0x00 04DF 52 MSTORE 04E0 60 PUSH1 0x51 04E2 60 PUSH1 0x04 04E4 52 MSTORE 04E5 60 PUSH1 0x24 04E7 60 PUSH1 0x00 04E9 FD *REVERT 04EA FE *ASSERT 04EB A2 LOG2 04EC 64 PUSH5 0x6970667358 04F2 22 22 04F3 12 SLT 04F4 20 SHA3 04F5 8F DUP16 04F6 F1 CALL 04F7 A9 A9 04F8 92 SWAP3 04F9 6D PUSH14 0x39cc99a583c9f1928e90a84a7bbd 0508 61 PUSH2 0x7c41 050B B5 B5 050C 35 CALLDATALOAD 050D 39 CODECOPY 050E 55 SSTORE 050F F9 F9 0510 85 DUP6 0511 FE *ASSERT 0512 1D SAR 0513 B9 B9 0514 AD AD 0515 64 PUSH5 0x736f6c6343 051B 00 *STOP 051C 08 ADDMOD 051D 12 SLT 051E 00 *STOP 051F 33 CALLER