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 0x018b 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x018b, 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 0x6352211e 0019 11 GT 001A 61 PUSH2 0x00d6 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00d6, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xa0712d68 0024 11 GT 0025 61 PUSH2 0x007f 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007f, if 0xa0712d68 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xa0712d68 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xc87b56dd 002F 11 GT 0030 61 PUSH2 0x0059 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0059, if 0xc87b56dd > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xc87b56dd > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xc87b56dd 003A 14 EQ 003B 61 PUSH2 0x043f 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x043f, if 0xc87b56dd == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xc87b56dd == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe985e9c5 0045 14 EQ 0046 61 PUSH2 0x045f 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x045f, if 0xe985e9c5 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xf2fde38b 0050 14 EQ 0051 61 PUSH2 0x04b5 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b5, if 0xf2fde38b == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0058 memory[0x00:0x00] } 0055 60 PUSH1 0x00 0057 80 DUP1 0058 FD *REVERT // Stack delta = +0 // Outputs[1] { @0058 revert(memory[0x00:0x00]); } // Block terminates label_0059: // Incoming jump from 0x0033, if 0xc87b56dd > stack[-1] // Inputs[1] { @005A stack[-1] } 0059 5B JUMPDEST 005A 80 DUP1 005B 63 PUSH4 0xa0712d68 0060 14 EQ 0061 61 PUSH2 0x03ec 0064 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ec, if 0xa0712d68 == stack[-1] label_0065: // Incoming jump from 0x0064, if not 0xa0712d68 == stack[-1] // Inputs[1] { @0065 stack[-1] } 0065 80 DUP1 0066 63 PUSH4 0xa22cb465 006B 14 EQ 006C 61 PUSH2 0x03ff 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ff, if 0xa22cb465 == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xb88d4fde 0076 14 EQ 0077 61 PUSH2 0x041f 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x041f, if 0xb88d4fde == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xb88d4fde == stack[-1] // Inputs[1] { @007E memory[0x00:0x00] } 007B 60 PUSH1 0x00 007D 80 DUP1 007E FD *REVERT // Stack delta = +0 // Outputs[1] { @007E revert(memory[0x00:0x00]); } // Block terminates label_007F: // Incoming jump from 0x0028, if 0xa0712d68 > stack[-1] // Inputs[1] { @0080 stack[-1] } 007F 5B JUMPDEST 0080 80 DUP1 0081 63 PUSH4 0x715018a6 0086 11 GT 0087 61 PUSH2 0x00b0 008A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b0, if 0x715018a6 > stack[-1] label_008B: // Incoming jump from 0x008A, if not 0x715018a6 > stack[-1] // Inputs[1] { @008B stack[-1] } 008B 80 DUP1 008C 63 PUSH4 0x715018a6 0091 14 EQ 0092 61 PUSH2 0x0397 0095 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0397, if 0x715018a6 == stack[-1] label_0096: // Incoming jump from 0x0095, if not 0x715018a6 == stack[-1] // Inputs[1] { @0096 stack[-1] } 0096 80 DUP1 0097 63 PUSH4 0x8da5cb5b 009C 14 EQ 009D 61 PUSH2 0x03ac 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ac, if 0x8da5cb5b == stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0x95d89b41 00A7 14 EQ 00A8 61 PUSH2 0x03d7 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d7, if 0x95d89b41 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00AF memory[0x00:0x00] } 00AC 60 PUSH1 0x00 00AE 80 DUP1 00AF FD *REVERT // Stack delta = +0 // Outputs[1] { @00AF revert(memory[0x00:0x00]); } // Block terminates label_00B0: // Incoming jump from 0x008A, if 0x715018a6 > stack[-1] // Inputs[1] { @00B1 stack[-1] } 00B0 5B JUMPDEST 00B1 80 DUP1 00B2 63 PUSH4 0x6352211e 00B7 14 EQ 00B8 61 PUSH2 0x0342 00BB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0342, if 0x6352211e == stack[-1] label_00BC: // Incoming jump from 0x00BB, if not 0x6352211e == stack[-1] // Inputs[1] { @00BC stack[-1] } 00BC 80 DUP1 00BD 63 PUSH4 0x70a08231 00C2 14 EQ 00C3 61 PUSH2 0x0362 00C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0362, if 0x70a08231 == stack[-1] label_00C7: // Incoming jump from 0x00C6, if not 0x70a08231 == stack[-1] // Inputs[1] { @00C7 stack[-1] } 00C7 80 DUP1 00C8 63 PUSH4 0x714c5398 00CD 14 EQ 00CE 61 PUSH2 0x0382 00D1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0382, if 0x714c5398 == stack[-1] label_00D2: // Incoming jump from 0x00D1, if not 0x714c5398 == stack[-1] // Inputs[1] { @00D5 memory[0x00:0x00] } 00D2 60 PUSH1 0x00 00D4 80 DUP1 00D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D5 revert(memory[0x00:0x00]); } // Block terminates label_00D6: // Incoming jump from 0x001D, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00D7 stack[-1] } 00D6 5B JUMPDEST 00D7 80 DUP1 00D8 63 PUSH4 0x2e1a7d4d 00DD 11 GT 00DE 61 PUSH2 0x0138 00E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0138, if 0x2e1a7d4d > stack[-1] label_00E2: // Incoming jump from 0x00E1, if not 0x2e1a7d4d > stack[-1] // Inputs[1] { @00E2 stack[-1] } 00E2 80 DUP1 00E3 63 PUSH4 0x42842e0e 00E8 11 GT 00E9 61 PUSH2 0x0112 00EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0112, if 0x42842e0e > stack[-1] label_00ED: // Incoming jump from 0x00EC, if not 0x42842e0e > stack[-1] // Inputs[1] { @00ED stack[-1] } 00ED 80 DUP1 00EE 63 PUSH4 0x42842e0e 00F3 14 EQ 00F4 61 PUSH2 0x02e2 00F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e2, if 0x42842e0e == stack[-1] label_00F8: // Incoming jump from 0x00F7, if not 0x42842e0e == stack[-1] // Inputs[1] { @00F8 stack[-1] } 00F8 80 DUP1 00F9 63 PUSH4 0x4f6ccce7 00FE 14 EQ 00FF 61 PUSH2 0x0302 0102 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0302, if 0x4f6ccce7 == stack[-1] label_0103: // Incoming jump from 0x0102, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @0103 stack[-1] } 0103 80 DUP1 0104 63 PUSH4 0x55f804b3 0109 14 EQ 010A 61 PUSH2 0x0322 010D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0322, if 0x55f804b3 == stack[-1] label_010E: // Incoming jump from 0x010D, if not 0x55f804b3 == stack[-1] // Inputs[1] { @0111 memory[0x00:0x00] } 010E 60 PUSH1 0x00 0110 80 DUP1 0111 FD *REVERT // Stack delta = +0 // Outputs[1] { @0111 revert(memory[0x00:0x00]); } // Block terminates label_0112: // Incoming jump from 0x00EC, if 0x42842e0e > stack[-1] // Inputs[1] { @0113 stack[-1] } 0112 5B JUMPDEST 0113 80 DUP1 0114 63 PUSH4 0x2e1a7d4d 0119 14 EQ 011A 61 PUSH2 0x028d 011D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x028d, if 0x2e1a7d4d == stack[-1] label_011E: // Incoming jump from 0x011D, if not 0x2e1a7d4d == stack[-1] // Inputs[1] { @011E stack[-1] } 011E 80 DUP1 011F 63 PUSH4 0x2f745c59 0124 14 EQ 0125 61 PUSH2 0x02ad 0128 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ad, if 0x2f745c59 == stack[-1] label_0129: // Incoming jump from 0x0128, if not 0x2f745c59 == stack[-1] // Inputs[1] { @0129 stack[-1] } 0129 80 DUP1 012A 63 PUSH4 0x3ccfd60b 012F 14 EQ 0130 61 PUSH2 0x02cd 0133 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02cd, if 0x3ccfd60b == stack[-1] label_0134: // Incoming jump from 0x0133, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @0137 memory[0x00:0x00] } 0134 60 PUSH1 0x00 0136 80 DUP1 0137 FD *REVERT // Stack delta = +0 // Outputs[1] { @0137 revert(memory[0x00:0x00]); } // Block terminates label_0138: // Incoming jump from 0x00E1, if 0x2e1a7d4d > stack[-1] // Inputs[1] { @0139 stack[-1] } 0138 5B JUMPDEST 0139 80 DUP1 013A 63 PUSH4 0x095ea7b3 013F 11 GT 0140 61 PUSH2 0x0169 0143 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0169, if 0x095ea7b3 > stack[-1] label_0144: // Incoming jump from 0x0143, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @0144 stack[-1] } 0144 80 DUP1 0145 63 PUSH4 0x095ea7b3 014A 14 EQ 014B 61 PUSH2 0x022c 014E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x022c, if 0x095ea7b3 == stack[-1] label_014F: // Incoming jump from 0x014E, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @014F stack[-1] } 014F 80 DUP1 0150 63 PUSH4 0x18160ddd 0155 14 EQ 0156 61 PUSH2 0x024e 0159 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024e, if 0x18160ddd == stack[-1] label_015A: // Incoming jump from 0x0159, if not 0x18160ddd == stack[-1] // Inputs[1] { @015A stack[-1] } 015A 80 DUP1 015B 63 PUSH4 0x23b872dd 0160 14 EQ 0161 61 PUSH2 0x026d 0164 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026d, if 0x23b872dd == stack[-1] label_0165: // Incoming jump from 0x0164, if not 0x23b872dd == stack[-1] // Inputs[1] { @0168 memory[0x00:0x00] } 0165 60 PUSH1 0x00 0167 80 DUP1 0168 FD *REVERT // Stack delta = +0 // Outputs[1] { @0168 revert(memory[0x00:0x00]); } // Block terminates label_0169: // Incoming jump from 0x0143, if 0x095ea7b3 > stack[-1] // Inputs[1] { @016A stack[-1] } 0169 5B JUMPDEST 016A 80 DUP1 016B 63 PUSH4 0x01ffc9a7 0170 14 EQ 0171 61 PUSH2 0x0190 0174 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0190, if 0x01ffc9a7 == stack[-1] label_0175: // Incoming jump from 0x0174, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0175 stack[-1] } 0175 80 DUP1 0176 63 PUSH4 0x06fdde03 017B 14 EQ 017C 61 PUSH2 0x01c5 017F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c5, if 0x06fdde03 == stack[-1] label_0180: // Incoming jump from 0x017F, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0180 stack[-1] } 0180 80 DUP1 0181 63 PUSH4 0x081812fc 0186 14 EQ 0187 61 PUSH2 0x01e7 018A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e7, if 0x081812fc == stack[-1] label_018B: // Incoming jump from 0x018A, if not 0x081812fc == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @018F memory[0x00:0x00] } 018B 5B JUMPDEST 018C 60 PUSH1 0x00 018E 80 DUP1 018F FD *REVERT // Stack delta = +0 // Outputs[1] { @018F revert(memory[0x00:0x00]); } // Block terminates label_0190: // Incoming jump from 0x0174, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0191 msg.value } 0190 5B JUMPDEST 0191 34 CALLVALUE 0192 80 DUP1 0193 15 ISZERO 0194 61 PUSH2 0x019c 0197 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0191 stack[0] = msg.value } // Block ends with conditional jump to 0x019c, if !msg.value label_0198: // Incoming jump from 0x0197, if not !msg.value // Inputs[1] { @019B memory[0x00:0x00] } 0198 60 PUSH1 0x00 019A 80 DUP1 019B FD *REVERT // Stack delta = +0 // Outputs[1] { @019B revert(memory[0x00:0x00]); } // Block terminates label_019C: // Incoming jump from 0x0197, if !msg.value // Inputs[1] { @01A4 msg.data.length } 019C 5B JUMPDEST 019D 50 POP 019E 61 PUSH2 0x01b0 01A1 61 PUSH2 0x01ab 01A4 36 CALLDATASIZE 01A5 60 PUSH1 0x04 01A7 61 PUSH2 0x221f 01AA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @019E stack[-1] = 0x01b0 // @01A1 stack[0] = 0x01ab // @01A4 stack[1] = msg.data.length // @01A5 stack[2] = 0x04 // } // Block ends with call to 0x221f, returns to 0x01AB label_01AB: // Incoming return from call to 0x221F at 0x01AA 01AB 5B JUMPDEST 01AC 61 PUSH2 0x04d5 01AF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04d5 label_01B0: // Incoming return from call to 0x047A at 0x0479 // Inputs[2] // { // @01B3 memory[0x40:0x60] // @01B4 stack[-1] // } 01B0 5B JUMPDEST 01B1 60 PUSH1 0x40 01B3 51 MLOAD 01B4 90 SWAP1 01B5 15 ISZERO 01B6 15 ISZERO 01B7 81 DUP2 01B8 52 MSTORE 01B9 60 PUSH1 0x20 01BB 01 ADD // Stack delta = +0 // Outputs[2] // { // @01B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @01BB stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_01BC: // Incoming jump from 0x01BB // Incoming jump from 0x022B // Incoming jump from 0x026C // Incoming jump from 0x026C // Inputs[3] // { // @01BF memory[0x40:0x60] // @01C1 stack[-1] // @01C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01BC 5B JUMPDEST 01BD 60 PUSH1 0x40 01BF 51 MLOAD 01C0 80 DUP1 01C1 91 SWAP2 01C2 03 SUB 01C3 90 SWAP1 01C4 F3 *RETURN // Stack delta = -1 // Outputs[1] { @01C4 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01C5: // Incoming jump from 0x017F, if 0x06fdde03 == stack[-1] // Inputs[1] { @01C6 msg.value } 01C5 5B JUMPDEST 01C6 34 CALLVALUE 01C7 80 DUP1 01C8 15 ISZERO 01C9 61 PUSH2 0x01d1 01CC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01C6 stack[0] = msg.value } // Block ends with conditional jump to 0x01d1, if !msg.value label_01CD: // Incoming jump from 0x01CC, if not !msg.value // Inputs[1] { @01D0 memory[0x00:0x00] } 01CD 60 PUSH1 0x00 01CF 80 DUP1 01D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D0 revert(memory[0x00:0x00]); } // Block terminates label_01D1: // Incoming jump from 0x01CC, if !msg.value 01D1 5B JUMPDEST 01D2 50 POP 01D3 61 PUSH2 0x01da 01D6 61 PUSH2 0x04e6 01D9 56 *JUMP // Stack delta = +0 // Outputs[1] { @01D3 stack[-1] = 0x01da } // Block ends with call to 0x04e6, returns to 0x01DA label_01DA: // Incoming return from call to 0x04E6 at 0x01D9 // Incoming return from call to 0x045A at 0x0459 // Incoming return from call to 0x0E3F at 0x03EB // Incoming return from call to 0x0DA3 at 0x0396 // Inputs[2] // { // @01DD memory[0x40:0x60] // @01E1 stack[-1] // } 01DA 5B JUMPDEST 01DB 60 PUSH1 0x40 01DD 51 MLOAD 01DE 61 PUSH2 0x01bc 01E1 91 SWAP2 01E2 90 SWAP1 01E3 61 PUSH2 0x22b9 01E6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01E1 stack[-1] = 0x01bc // @01E2 stack[1] = memory[0x40:0x60] // @01E2 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x22b9 label_01E7: // Incoming jump from 0x018A, if 0x081812fc == stack[-1] // Inputs[1] { @01E8 msg.value } 01E7 5B JUMPDEST 01E8 34 CALLVALUE 01E9 80 DUP1 01EA 15 ISZERO 01EB 61 PUSH2 0x01f3 01EE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01E8 stack[0] = msg.value } // Block ends with conditional jump to 0x01f3, if !msg.value label_01EF: // Incoming jump from 0x01EE, if not !msg.value // Inputs[1] { @01F2 memory[0x00:0x00] } 01EF 60 PUSH1 0x00 01F1 80 DUP1 01F2 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F2 revert(memory[0x00:0x00]); } // Block terminates label_01F3: // Incoming jump from 0x01EE, if !msg.value // Inputs[1] { @01FB msg.data.length } 01F3 5B JUMPDEST 01F4 50 POP 01F5 61 PUSH2 0x0207 01F8 61 PUSH2 0x0202 01FB 36 CALLDATASIZE 01FC 60 PUSH1 0x04 01FE 61 PUSH2 0x22cc 0201 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @01F5 stack[-1] = 0x0207 // @01F8 stack[0] = 0x0202 // @01FB stack[1] = msg.data.length // @01FC stack[2] = 0x04 // } // Block ends with call to 0x22cc, returns to 0x0202 label_0202: // Incoming return from call to 0x22CC at 0x0201 0202 5B JUMPDEST 0203 61 PUSH2 0x0578 0206 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0578 label_0207: // Incoming return from call to 0x0202 at 0x0201 // Incoming jump from 0x03D6 // Incoming return from call to 0x035D at 0x035C // Inputs[2] // { // @020A memory[0x40:0x60] // @0221 stack[-1] // } 0207 5B JUMPDEST 0208 60 PUSH1 0x40 020A 51 MLOAD 020B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0220 90 SWAP1 0221 91 SWAP2 0222 16 AND 0223 81 DUP2 0224 52 MSTORE 0225 60 PUSH1 0x20 0227 01 ADD 0228 61 PUSH2 0x01bc 022B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0224 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @0227 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01bc label_022C: // Incoming jump from 0x014E, if 0x095ea7b3 == stack[-1] // Inputs[1] { @022D msg.value } 022C 5B JUMPDEST 022D 34 CALLVALUE 022E 80 DUP1 022F 15 ISZERO 0230 61 PUSH2 0x0238 0233 57 *JUMPI // Stack delta = +1 // Outputs[1] { @022D stack[0] = msg.value } // Block ends with conditional jump to 0x0238, if !msg.value label_0234: // Incoming jump from 0x0233, if not !msg.value // Inputs[1] { @0237 memory[0x00:0x00] } 0234 60 PUSH1 0x00 0236 80 DUP1 0237 FD *REVERT // Stack delta = +0 // Outputs[1] { @0237 revert(memory[0x00:0x00]); } // Block terminates label_0238: // Incoming jump from 0x0233, if !msg.value // Inputs[1] { @0240 msg.data.length } 0238 5B JUMPDEST 0239 50 POP 023A 61 PUSH2 0x024c 023D 61 PUSH2 0x0247 0240 36 CALLDATASIZE 0241 60 PUSH1 0x04 0243 61 PUSH2 0x230e 0246 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @023A stack[-1] = 0x024c // @023D stack[0] = 0x0247 // @0240 stack[1] = msg.data.length // @0241 stack[2] = 0x04 // } // Block ends with call to 0x230e, returns to 0x0247 label_0247: // Incoming return from call to 0x230E at 0x0246 0247 5B JUMPDEST 0248 61 PUSH2 0x0657 024B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0657 label_024C: // Incoming return from call to 0x0A06 at 0x02E1 // Incoming return from call to 0x041A at 0x0419 // Incoming return from call to 0x02A8 at 0x02A7 // Incoming return from call to 0x0DB2 at 0x03AB 024C 5B JUMPDEST 024D 00 *STOP // Stack delta = +0 // Outputs[1] { @024D stop(); } // Block terminates label_024E: // Incoming jump from 0x0159, if 0x18160ddd == stack[-1] // Inputs[1] { @024F msg.value } 024E 5B JUMPDEST 024F 34 CALLVALUE 0250 80 DUP1 0251 15 ISZERO 0252 61 PUSH2 0x025a 0255 57 *JUMPI // Stack delta = +1 // Outputs[1] { @024F stack[0] = msg.value } // Block ends with conditional jump to 0x025a, if !msg.value label_0256: // Incoming jump from 0x0255, if not !msg.value // Inputs[1] { @0259 memory[0x00:0x00] } 0256 60 PUSH1 0x00 0258 80 DUP1 0259 FD *REVERT // Stack delta = +0 // Outputs[1] { @0259 revert(memory[0x00:0x00]); } // Block terminates label_025A: // Incoming jump from 0x0255, if !msg.value // Inputs[2] // { // @025E storage[0x08] // @0262 memory[0x40:0x60] // } 025A 5B JUMPDEST 025B 50 POP 025C 60 PUSH1 0x08 025E 54 SLOAD 025F 5B JUMPDEST 0260 60 PUSH1 0x40 0262 51 MLOAD 0263 90 SWAP1 0264 81 DUP2 0265 52 MSTORE 0266 60 PUSH1 0x20 0268 01 ADD 0269 61 PUSH2 0x01bc 026C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0265 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x08] // @0268 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01bc label_026D: // Incoming jump from 0x0164, if 0x23b872dd == stack[-1] // Inputs[1] { @026E msg.value } 026D 5B JUMPDEST 026E 34 CALLVALUE 026F 80 DUP1 0270 15 ISZERO 0271 61 PUSH2 0x0279 0274 57 *JUMPI // Stack delta = +1 // Outputs[1] { @026E stack[0] = msg.value } // Block ends with conditional jump to 0x0279, if !msg.value label_0275: // Incoming jump from 0x0274, if not !msg.value // Inputs[1] { @0278 memory[0x00:0x00] } 0275 60 PUSH1 0x00 0277 80 DUP1 0278 FD *REVERT // Stack delta = +0 // Outputs[1] { @0278 revert(memory[0x00:0x00]); } // Block terminates label_0279: // Incoming jump from 0x0274, if !msg.value // Inputs[1] { @0281 msg.data.length } 0279 5B JUMPDEST 027A 50 POP 027B 61 PUSH2 0x024c 027E 61 PUSH2 0x0288 0281 36 CALLDATASIZE 0282 60 PUSH1 0x04 0284 61 PUSH2 0x2338 0287 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @027B stack[-1] = 0x024c // @027E stack[0] = 0x0288 // @0281 stack[1] = msg.data.length // @0282 stack[2] = 0x04 // } // Block ends with call to 0x2338, returns to 0x0288 label_0288: // Incoming return from call to 0x2338 at 0x0287 0288 5B JUMPDEST 0289 61 PUSH2 0x07e4 028C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07e4 label_028D: // Incoming jump from 0x011D, if 0x2e1a7d4d == stack[-1] // Inputs[1] { @028E msg.value } 028D 5B JUMPDEST 028E 34 CALLVALUE 028F 80 DUP1 0290 15 ISZERO 0291 61 PUSH2 0x0299 0294 57 *JUMPI // Stack delta = +1 // Outputs[1] { @028E stack[0] = msg.value } // Block ends with conditional jump to 0x0299, if !msg.value label_0295: // Incoming jump from 0x0294, if not !msg.value // Inputs[1] { @0298 memory[0x00:0x00] } 0295 60 PUSH1 0x00 0297 80 DUP1 0298 FD *REVERT // Stack delta = +0 // Outputs[1] { @0298 revert(memory[0x00:0x00]); } // Block terminates label_0299: // Incoming jump from 0x0294, if !msg.value // Inputs[1] { @02A1 msg.data.length } 0299 5B JUMPDEST 029A 50 POP 029B 61 PUSH2 0x024c 029E 61 PUSH2 0x02a8 02A1 36 CALLDATASIZE 02A2 60 PUSH1 0x04 02A4 61 PUSH2 0x22cc 02A7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @029B stack[-1] = 0x024c // @029E stack[0] = 0x02a8 // @02A1 stack[1] = msg.data.length // @02A2 stack[2] = 0x04 // } // Block ends with call to 0x22cc, returns to 0x02A8 label_02A8: // Incoming return from call to 0x22CC at 0x02A7 02A8 5B JUMPDEST 02A9 61 PUSH2 0x0885 02AC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0885 label_02AD: // Incoming jump from 0x0128, if 0x2f745c59 == stack[-1] // Inputs[1] { @02AE msg.value } 02AD 5B JUMPDEST 02AE 34 CALLVALUE 02AF 80 DUP1 02B0 15 ISZERO 02B1 61 PUSH2 0x02b9 02B4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02AE stack[0] = msg.value } // Block ends with conditional jump to 0x02b9, if !msg.value label_02B5: // Incoming jump from 0x02B4, if not !msg.value // Inputs[1] { @02B8 memory[0x00:0x00] } 02B5 60 PUSH1 0x00 02B7 80 DUP1 02B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B8 revert(memory[0x00:0x00]); } // Block terminates label_02B9: // Incoming jump from 0x02B4, if !msg.value // Inputs[1] { @02C1 msg.data.length } 02B9 5B JUMPDEST 02BA 50 POP 02BB 61 PUSH2 0x025f 02BE 61 PUSH2 0x02c8 02C1 36 CALLDATASIZE 02C2 60 PUSH1 0x04 02C4 61 PUSH2 0x230e 02C7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02BB stack[-1] = 0x025f // @02BE stack[0] = 0x02c8 // @02C1 stack[1] = msg.data.length // @02C2 stack[2] = 0x04 // } // Block ends with call to 0x230e, returns to 0x02C8 label_02C8: // Incoming return from call to 0x230E at 0x02C7 02C8 5B JUMPDEST 02C9 61 PUSH2 0x0937 02CC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0937 label_02CD: // Incoming jump from 0x0133, if 0x3ccfd60b == stack[-1] // Inputs[1] { @02CE msg.value } 02CD 5B JUMPDEST 02CE 34 CALLVALUE 02CF 80 DUP1 02D0 15 ISZERO 02D1 61 PUSH2 0x02d9 02D4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02CE stack[0] = msg.value } // Block ends with conditional jump to 0x02d9, if !msg.value label_02D5: // Incoming jump from 0x02D4, if not !msg.value // Inputs[1] { @02D8 memory[0x00:0x00] } 02D5 60 PUSH1 0x00 02D7 80 DUP1 02D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D8 revert(memory[0x00:0x00]); } // Block terminates label_02D9: // Incoming jump from 0x02D4, if !msg.value 02D9 5B JUMPDEST 02DA 50 POP 02DB 61 PUSH2 0x024c 02DE 61 PUSH2 0x0a06 02E1 56 *JUMP // Stack delta = +0 // Outputs[1] { @02DB stack[-1] = 0x024c } // Block ends with call to 0x0a06, returns to 0x024C label_02E2: // Incoming jump from 0x00F7, if 0x42842e0e == stack[-1] // Inputs[1] { @02E3 msg.value } 02E2 5B JUMPDEST 02E3 34 CALLVALUE 02E4 80 DUP1 02E5 15 ISZERO 02E6 61 PUSH2 0x02ee 02E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02E3 stack[0] = msg.value } // Block ends with conditional jump to 0x02ee, if !msg.value label_02EA: // Incoming jump from 0x02E9, if not !msg.value // Inputs[1] { @02ED memory[0x00:0x00] } 02EA 60 PUSH1 0x00 02EC 80 DUP1 02ED FD *REVERT // Stack delta = +0 // Outputs[1] { @02ED revert(memory[0x00:0x00]); } // Block terminates label_02EE: // Incoming jump from 0x02E9, if !msg.value // Inputs[1] { @02F6 msg.data.length } 02EE 5B JUMPDEST 02EF 50 POP 02F0 61 PUSH2 0x024c 02F3 61 PUSH2 0x02fd 02F6 36 CALLDATASIZE 02F7 60 PUSH1 0x04 02F9 61 PUSH2 0x2338 02FC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02F0 stack[-1] = 0x024c // @02F3 stack[0] = 0x02fd // @02F6 stack[1] = msg.data.length // @02F7 stack[2] = 0x04 // } // Block ends with call to 0x2338, returns to 0x02FD label_02FD: // Incoming return from call to 0x2338 at 0x02FC 02FD 5B JUMPDEST 02FE 61 PUSH2 0x0ab6 0301 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ab6 label_0302: // Incoming jump from 0x0102, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @0303 msg.value } 0302 5B JUMPDEST 0303 34 CALLVALUE 0304 80 DUP1 0305 15 ISZERO 0306 61 PUSH2 0x030e 0309 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0303 stack[0] = msg.value } // Block ends with conditional jump to 0x030e, if !msg.value label_030A: // Incoming jump from 0x0309, if not !msg.value // Inputs[1] { @030D memory[0x00:0x00] } 030A 60 PUSH1 0x00 030C 80 DUP1 030D FD *REVERT // Stack delta = +0 // Outputs[1] { @030D revert(memory[0x00:0x00]); } // Block terminates label_030E: // Incoming jump from 0x0309, if !msg.value // Inputs[1] { @0316 msg.data.length } 030E 5B JUMPDEST 030F 50 POP 0310 61 PUSH2 0x025f 0313 61 PUSH2 0x031d 0316 36 CALLDATASIZE 0317 60 PUSH1 0x04 0319 61 PUSH2 0x22cc 031C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0310 stack[-1] = 0x025f // @0313 stack[0] = 0x031d // @0316 stack[1] = msg.data.length // @0317 stack[2] = 0x04 // } // Block ends with call to 0x22cc, returns to 0x031D label_031D: // Incoming return from call to 0x22CC at 0x031C 031D 5B JUMPDEST 031E 61 PUSH2 0x0ad1 0321 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ad1 label_0322: // Incoming jump from 0x010D, if 0x55f804b3 == stack[-1] // Inputs[1] { @0323 msg.value } 0322 5B JUMPDEST 0323 34 CALLVALUE 0324 80 DUP1 0325 15 ISZERO 0326 61 PUSH2 0x032e 0329 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0323 stack[0] = msg.value } // Block ends with conditional jump to 0x032e, if !msg.value label_032A: // Incoming jump from 0x0329, if not !msg.value // Inputs[1] { @032D memory[0x00:0x00] } 032A 60 PUSH1 0x00 032C 80 DUP1 032D FD *REVERT // Stack delta = +0 // Outputs[1] { @032D revert(memory[0x00:0x00]); } // Block terminates label_032E: // Incoming jump from 0x0329, if !msg.value // Inputs[1] { @0336 msg.data.length } 032E 5B JUMPDEST 032F 50 POP 0330 61 PUSH2 0x024c 0333 61 PUSH2 0x033d 0336 36 CALLDATASIZE 0337 60 PUSH1 0x04 0339 61 PUSH2 0x2437 033C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0330 stack[-1] = 0x024c // @0333 stack[0] = 0x033d // @0336 stack[1] = msg.data.length // @0337 stack[2] = 0x04 // } // Block ends with call to 0x2437, returns to 0x033D label_033D: // Incoming return from call to 0x2437 at 0x033C 033D 5B JUMPDEST 033E 61 PUSH2 0x0b8f 0341 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b8f label_0342: // Incoming jump from 0x00BB, if 0x6352211e == stack[-1] // Inputs[1] { @0343 msg.value } 0342 5B JUMPDEST 0343 34 CALLVALUE 0344 80 DUP1 0345 15 ISZERO 0346 61 PUSH2 0x034e 0349 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0343 stack[0] = msg.value } // Block ends with conditional jump to 0x034e, if !msg.value label_034A: // Incoming jump from 0x0349, if not !msg.value // Inputs[1] { @034D memory[0x00:0x00] } 034A 60 PUSH1 0x00 034C 80 DUP1 034D FD *REVERT // Stack delta = +0 // Outputs[1] { @034D revert(memory[0x00:0x00]); } // Block terminates label_034E: // Incoming jump from 0x0349, if !msg.value // Inputs[1] { @0356 msg.data.length } 034E 5B JUMPDEST 034F 50 POP 0350 61 PUSH2 0x0207 0353 61 PUSH2 0x035d 0356 36 CALLDATASIZE 0357 60 PUSH1 0x04 0359 61 PUSH2 0x22cc 035C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0350 stack[-1] = 0x0207 // @0353 stack[0] = 0x035d // @0356 stack[1] = msg.data.length // @0357 stack[2] = 0x04 // } // Block ends with call to 0x22cc, returns to 0x035D label_035D: // Incoming return from call to 0x22CC at 0x035C 035D 5B JUMPDEST 035E 61 PUSH2 0x0c23 0361 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c23 label_0362: // Incoming jump from 0x00C6, if 0x70a08231 == stack[-1] // Inputs[1] { @0363 msg.value } 0362 5B JUMPDEST 0363 34 CALLVALUE 0364 80 DUP1 0365 15 ISZERO 0366 61 PUSH2 0x036e 0369 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0363 stack[0] = msg.value } // Block ends with conditional jump to 0x036e, if !msg.value label_036A: // Incoming jump from 0x0369, if not !msg.value // Inputs[1] { @036D memory[0x00:0x00] } 036A 60 PUSH1 0x00 036C 80 DUP1 036D FD *REVERT // Stack delta = +0 // Outputs[1] { @036D revert(memory[0x00:0x00]); } // Block terminates label_036E: // Incoming jump from 0x0369, if !msg.value // Inputs[1] { @0376 msg.data.length } 036E 5B JUMPDEST 036F 50 POP 0370 61 PUSH2 0x025f 0373 61 PUSH2 0x037d 0376 36 CALLDATASIZE 0377 60 PUSH1 0x04 0379 61 PUSH2 0x2480 037C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0370 stack[-1] = 0x025f // @0373 stack[0] = 0x037d // @0376 stack[1] = msg.data.length // @0377 stack[2] = 0x04 // } // Block ends with call to 0x2480, returns to 0x037D label_037D: // Incoming return from call to 0x2480 at 0x037C 037D 5B JUMPDEST 037E 61 PUSH2 0x0cd5 0381 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cd5 label_0382: // Incoming jump from 0x00D1, if 0x714c5398 == stack[-1] // Inputs[1] { @0383 msg.value } 0382 5B JUMPDEST 0383 34 CALLVALUE 0384 80 DUP1 0385 15 ISZERO 0386 61 PUSH2 0x038e 0389 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0383 stack[0] = msg.value } // Block ends with conditional jump to 0x038e, if !msg.value label_038A: // Incoming jump from 0x0389, if not !msg.value // Inputs[1] { @038D memory[0x00:0x00] } 038A 60 PUSH1 0x00 038C 80 DUP1 038D FD *REVERT // Stack delta = +0 // Outputs[1] { @038D revert(memory[0x00:0x00]); } // Block terminates label_038E: // Incoming jump from 0x0389, if !msg.value 038E 5B JUMPDEST 038F 50 POP 0390 61 PUSH2 0x01da 0393 61 PUSH2 0x0da3 0396 56 *JUMP // Stack delta = +0 // Outputs[1] { @0390 stack[-1] = 0x01da } // Block ends with call to 0x0da3, returns to 0x01DA label_0397: // Incoming jump from 0x0095, if 0x715018a6 == stack[-1] // Inputs[1] { @0398 msg.value } 0397 5B JUMPDEST 0398 34 CALLVALUE 0399 80 DUP1 039A 15 ISZERO 039B 61 PUSH2 0x03a3 039E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0398 stack[0] = msg.value } // Block ends with conditional jump to 0x03a3, if !msg.value label_039F: // Incoming jump from 0x039E, if not !msg.value // Inputs[1] { @03A2 memory[0x00:0x00] } 039F 60 PUSH1 0x00 03A1 80 DUP1 03A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A2 revert(memory[0x00:0x00]); } // Block terminates label_03A3: // Incoming jump from 0x039E, if !msg.value 03A3 5B JUMPDEST 03A4 50 POP 03A5 61 PUSH2 0x024c 03A8 61 PUSH2 0x0db2 03AB 56 *JUMP // Stack delta = +0 // Outputs[1] { @03A5 stack[-1] = 0x024c } // Block ends with call to 0x0db2, returns to 0x024C label_03AC: // Incoming jump from 0x00A0, if 0x8da5cb5b == stack[-1] // Inputs[1] { @03AD msg.value } 03AC 5B JUMPDEST 03AD 34 CALLVALUE 03AE 80 DUP1 03AF 15 ISZERO 03B0 61 PUSH2 0x03b8 03B3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03AD stack[0] = msg.value } // Block ends with conditional jump to 0x03b8, if !msg.value label_03B4: // Incoming jump from 0x03B3, if not !msg.value // Inputs[1] { @03B7 memory[0x00:0x00] } 03B4 60 PUSH1 0x00 03B6 80 DUP1 03B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @03B7 revert(memory[0x00:0x00]); } // Block terminates label_03B8: // Incoming jump from 0x03B3, if !msg.value // Inputs[1] { @03BC storage[0x0a] } 03B8 5B JUMPDEST 03B9 50 POP 03BA 60 PUSH1 0x0a 03BC 54 SLOAD 03BD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03D2 16 AND 03D3 61 PUSH2 0x0207 03D6 56 *JUMP // Stack delta = +0 // Outputs[1] { @03D2 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] } // Block ends with unconditional jump to 0x0207 label_03D7: // Incoming jump from 0x00AB, if 0x95d89b41 == stack[-1] // Inputs[1] { @03D8 msg.value } 03D7 5B JUMPDEST 03D8 34 CALLVALUE 03D9 80 DUP1 03DA 15 ISZERO 03DB 61 PUSH2 0x03e3 03DE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03D8 stack[0] = msg.value } // Block ends with conditional jump to 0x03e3, if !msg.value label_03DF: // Incoming jump from 0x03DE, if not !msg.value // Inputs[1] { @03E2 memory[0x00:0x00] } 03DF 60 PUSH1 0x00 03E1 80 DUP1 03E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @03E2 revert(memory[0x00:0x00]); } // Block terminates label_03E3: // Incoming jump from 0x03DE, if !msg.value 03E3 5B JUMPDEST 03E4 50 POP 03E5 61 PUSH2 0x01da 03E8 61 PUSH2 0x0e3f 03EB 56 *JUMP // Stack delta = +0 // Outputs[1] { @03E5 stack[-1] = 0x01da } // Block ends with call to 0x0e3f, returns to 0x01DA label_03EC: // Incoming jump from 0x0064, if 0xa0712d68 == stack[-1] // Inputs[1] { @03F3 msg.data.length } 03EC 5B JUMPDEST 03ED 61 PUSH2 0x024c 03F0 61 PUSH2 0x03fa 03F3 36 CALLDATASIZE 03F4 60 PUSH1 0x04 03F6 61 PUSH2 0x22cc 03F9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03ED stack[0] = 0x024c // @03F0 stack[1] = 0x03fa // @03F3 stack[2] = msg.data.length // @03F4 stack[3] = 0x04 // } // Block ends with call to 0x22cc, returns to 0x03FA label_03FA: // Incoming return from call to 0x22CC at 0x03F9 03FA 5B JUMPDEST 03FB 61 PUSH2 0x0e4e 03FE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e4e label_03FF: // Incoming jump from 0x006F, if 0xa22cb465 == stack[-1] // Inputs[1] { @0400 msg.value } 03FF 5B JUMPDEST 0400 34 CALLVALUE 0401 80 DUP1 0402 15 ISZERO 0403 61 PUSH2 0x040b 0406 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0400 stack[0] = msg.value } // Block ends with conditional jump to 0x040b, if !msg.value label_0407: // Incoming jump from 0x0406, if not !msg.value // Inputs[1] { @040A memory[0x00:0x00] } 0407 60 PUSH1 0x00 0409 80 DUP1 040A FD *REVERT // Stack delta = +0 // Outputs[1] { @040A revert(memory[0x00:0x00]); } // Block terminates label_040B: // Incoming jump from 0x0406, if !msg.value // Inputs[1] { @0413 msg.data.length } 040B 5B JUMPDEST 040C 50 POP 040D 61 PUSH2 0x024c 0410 61 PUSH2 0x041a 0413 36 CALLDATASIZE 0414 60 PUSH1 0x04 0416 61 PUSH2 0x249b 0419 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @040D stack[-1] = 0x024c // @0410 stack[0] = 0x041a // @0413 stack[1] = msg.data.length // @0414 stack[2] = 0x04 // } // Block ends with call to 0x249b, returns to 0x041A label_041A: // Incoming return from call to 0x249B at 0x0419 041A 5B JUMPDEST 041B 61 PUSH2 0x0fab 041E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fab label_041F: // Incoming jump from 0x007A, if 0xb88d4fde == stack[-1] // Inputs[1] { @0420 msg.value } 041F 5B JUMPDEST 0420 34 CALLVALUE 0421 80 DUP1 0422 15 ISZERO 0423 61 PUSH2 0x042b 0426 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0420 stack[0] = msg.value } // Block ends with conditional jump to 0x042b, if !msg.value label_0427: // Incoming jump from 0x0426, if not !msg.value // Inputs[1] { @042A memory[0x00:0x00] } 0427 60 PUSH1 0x00 0429 80 DUP1 042A FD *REVERT // Stack delta = +0 // Outputs[1] { @042A revert(memory[0x00:0x00]); } // Block terminates label_042B: // Incoming jump from 0x0426, if !msg.value // Inputs[1] { @0433 msg.data.length } 042B 5B JUMPDEST 042C 50 POP 042D 61 PUSH2 0x024c 0430 61 PUSH2 0x043a 0433 36 CALLDATASIZE 0434 60 PUSH1 0x04 0436 61 PUSH2 0x24d7 0439 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @042D stack[-1] = 0x024c // @0430 stack[0] = 0x043a // @0433 stack[1] = msg.data.length // @0434 stack[2] = 0x04 // } // Block ends with call to 0x24d7, returns to 0x043A label_043A: // Incoming return from call to 0x24D7 at 0x0439 043A 5B JUMPDEST 043B 61 PUSH2 0x10c2 043E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10c2 label_043F: // Incoming jump from 0x003E, if 0xc87b56dd == stack[-1] // Inputs[1] { @0440 msg.value } 043F 5B JUMPDEST 0440 34 CALLVALUE 0441 80 DUP1 0442 15 ISZERO 0443 61 PUSH2 0x044b 0446 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0440 stack[0] = msg.value } // Block ends with conditional jump to 0x044b, if !msg.value label_0447: // Incoming jump from 0x0446, if not !msg.value // Inputs[1] { @044A memory[0x00:0x00] } 0447 60 PUSH1 0x00 0449 80 DUP1 044A FD *REVERT // Stack delta = +0 // Outputs[1] { @044A revert(memory[0x00:0x00]); } // Block terminates label_044B: // Incoming jump from 0x0446, if !msg.value // Inputs[1] { @0453 msg.data.length } 044B 5B JUMPDEST 044C 50 POP 044D 61 PUSH2 0x01da 0450 61 PUSH2 0x045a 0453 36 CALLDATASIZE 0454 60 PUSH1 0x04 0456 61 PUSH2 0x22cc 0459 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @044D stack[-1] = 0x01da // @0450 stack[0] = 0x045a // @0453 stack[1] = msg.data.length // @0454 stack[2] = 0x04 // } // Block ends with call to 0x22cc, returns to 0x045A label_045A: // Incoming return from call to 0x22CC at 0x0459 045A 5B JUMPDEST 045B 61 PUSH2 0x116a 045E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x116a label_045F: // Incoming jump from 0x0049, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0460 msg.value } 045F 5B JUMPDEST 0460 34 CALLVALUE 0461 80 DUP1 0462 15 ISZERO 0463 61 PUSH2 0x046b 0466 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0460 stack[0] = msg.value } // Block ends with conditional jump to 0x046b, if !msg.value label_0467: // Incoming jump from 0x0466, if not !msg.value // Inputs[1] { @046A memory[0x00:0x00] } 0467 60 PUSH1 0x00 0469 80 DUP1 046A FD *REVERT // Stack delta = +0 // Outputs[1] { @046A revert(memory[0x00:0x00]); } // Block terminates label_046B: // Incoming jump from 0x0466, if !msg.value // Inputs[1] { @0473 msg.data.length } 046B 5B JUMPDEST 046C 50 POP 046D 61 PUSH2 0x01b0 0470 61 PUSH2 0x047a 0473 36 CALLDATASIZE 0474 60 PUSH1 0x04 0476 61 PUSH2 0x2553 0479 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @046D stack[-1] = 0x01b0 // @0470 stack[0] = 0x047a // @0473 stack[1] = msg.data.length // @0474 stack[2] = 0x04 // } // Block ends with call to 0x2553, returns to 0x047A label_047A: // Incoming call from 0x0748, returns to 0x0749 // Incoming return from call to 0x2553 at 0x0479 // Inputs[6] // { // @0490 stack[-2] // @04A3 memory[0x00:0x40] // @04A4 stack[-1] // @04AE memory[0x00:0x40] // @04AF storage[keccak256(memory[0x00:0x40])] // @04B3 stack[-3] // } 047A 5B JUMPDEST 047B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0490 91 SWAP2 0491 82 DUP3 0492 16 AND 0493 60 PUSH1 0x00 0495 90 SWAP1 0496 81 DUP2 0497 52 MSTORE 0498 60 PUSH1 0x05 049A 60 PUSH1 0x20 049C 90 SWAP1 049D 81 DUP2 049E 52 MSTORE 049F 60 PUSH1 0x40 04A1 80 DUP1 04A2 83 DUP4 04A3 20 SHA3 04A4 93 SWAP4 04A5 90 SWAP1 04A6 94 SWAP5 04A7 16 AND 04A8 82 DUP3 04A9 52 MSTORE 04AA 91 SWAP2 04AB 90 SWAP1 04AC 91 SWAP2 04AD 52 MSTORE 04AE 20 SHA3 04AF 54 SLOAD 04B0 60 PUSH1 0xff 04B2 16 AND 04B3 90 SWAP1 04B4 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0497 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @049E memory[0x20:0x40] = 0x05 // @04A9 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @04AD memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @04B3 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_04B5: // Incoming jump from 0x0054, if 0xf2fde38b == stack[-1] // Inputs[1] { @04B6 msg.value } 04B5 5B JUMPDEST 04B6 34 CALLVALUE 04B7 80 DUP1 04B8 15 ISZERO 04B9 61 PUSH2 0x04c1 04BC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04B6 stack[0] = msg.value } // Block ends with conditional jump to 0x04c1, if !msg.value label_04BD: // Incoming jump from 0x04BC, if not !msg.value // Inputs[1] { @04C0 memory[0x00:0x00] } 04BD 60 PUSH1 0x00 04BF 80 DUP1 04C0 FD *REVERT // Stack delta = +0 // Outputs[1] { @04C0 revert(memory[0x00:0x00]); } // Block terminates label_04C1: // Incoming jump from 0x04BC, if !msg.value // Inputs[1] { @04C9 msg.data.length } 04C1 5B JUMPDEST 04C2 50 POP 04C3 61 PUSH2 0x024c 04C6 61 PUSH2 0x04d0 04C9 36 CALLDATASIZE 04CA 60 PUSH1 0x04 04CC 61 PUSH2 0x2480 04CF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04C3 stack[-1] = 0x024c // @04C6 stack[0] = 0x04d0 // @04C9 stack[1] = msg.data.length // @04CA stack[2] = 0x04 // } // Block ends with call to 0x2480, returns to 0x04D0 label_04D0: // Incoming return from call to 0x2480 at 0x04CF 04D0 5B JUMPDEST 04D1 61 PUSH2 0x119e 04D4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x119e label_04D5: // Incoming jump from 0x01AF // Inputs[1] { @04DB stack[-1] } 04D5 5B JUMPDEST 04D6 60 PUSH1 0x00 04D8 61 PUSH2 0x04e0 04DB 82 DUP3 04DC 61 PUSH2 0x12cb 04DF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @04D6 stack[0] = 0x00 // @04D8 stack[1] = 0x04e0 // @04DB stack[2] = stack[-1] // } // Block ends with call to 0x12cb, returns to 0x04E0 label_04E0: // Incoming return from call to 0x1BBD at 0x1320 // Incoming jump from 0x1C55, if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x0C4D, if 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1317, if 0x780e9d6300000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x1C9F // Incoming return from call to 0x12CB at 0x04DF // Incoming jump from 0x1C55, if stack[-1] // Inputs[3] // { // @04E1 stack[-4] // @04E1 stack[-1] // @04E2 stack[-3] // } 04E0 5B JUMPDEST 04E1 92 SWAP3 04E2 91 SWAP2 04E3 50 POP 04E4 50 POP 04E5 56 *JUMP // Stack delta = -3 // Outputs[1] { @04E1 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_04E6: // Incoming call from 0x01D9, returns to 0x01DA // Inputs[1] { @04EC storage[0x00] } 04E6 5B JUMPDEST 04E7 60 PUSH1 0x60 04E9 60 PUSH1 0x00 04EB 80 DUP1 04EC 54 SLOAD 04ED 61 PUSH2 0x04f5 04F0 90 SWAP1 04F1 61 PUSH2 0x2586 04F4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04E7 stack[0] = 0x60 // @04E9 stack[1] = 0x00 // @04F0 stack[2] = 0x04f5 // @04F0 stack[3] = storage[0x00] // } // Block ends with call to 0x2586, returns to 0x04F5 label_04F5: // Incoming return from call to 0x2586 at 0x0E4D // Incoming return from call to 0x2586 at 0x04F4 // Incoming return from call to 0x2586 at 0x0DB1 // Inputs[4] // { // @04F6 stack[-1] // @0505 memory[0x40:0x60] // @050D stack[-2] // @0518 storage[stack[-2]] // } 04F5 5B JUMPDEST 04F6 80 DUP1 04F7 60 PUSH1 0x1f 04F9 01 ADD 04FA 60 PUSH1 0x20 04FC 80 DUP1 04FD 91 SWAP2 04FE 04 DIV 04FF 02 MUL 0500 60 PUSH1 0x20 0502 01 ADD 0503 60 PUSH1 0x40 0505 51 MLOAD 0506 90 SWAP1 0507 81 DUP2 0508 01 ADD 0509 60 PUSH1 0x40 050B 52 MSTORE 050C 80 DUP1 050D 92 SWAP3 050E 91 SWAP2 050F 90 SWAP1 0510 81 DUP2 0511 81 DUP2 0512 52 MSTORE 0513 60 PUSH1 0x20 0515 01 ADD 0516 82 DUP3 0517 80 DUP1 0518 54 SLOAD 0519 61 PUSH2 0x0521 051C 90 SWAP1 051D 61 PUSH2 0x2586 0520 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @050B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @050D stack[-2] = memory[0x40:0x60] // @050E stack[-1] = stack[-2] // @050F stack[0] = stack[-1] // @0512 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0515 stack[1] = 0x20 + memory[0x40:0x60] // @0516 stack[2] = stack[-2] // @051C stack[4] = storage[stack[-2]] // @051C stack[3] = 0x0521 // } // Block ends with call to 0x2586, returns to 0x0521 label_0521: // Incoming return from call to 0x2586 at 0x0520 // Inputs[1] { @0522 stack[-1] } 0521 5B JUMPDEST 0522 80 DUP1 0523 15 ISZERO 0524 61 PUSH2 0x056e 0527 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x056e, if !stack[-1] label_0528: // Incoming jump from 0x0527, if not !stack[-1] // Inputs[1] { @0528 stack[-1] } 0528 80 DUP1 0529 60 PUSH1 0x1f 052B 10 LT 052C 61 PUSH2 0x0543 052F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0543, if 0x1f < stack[-1] label_0530: // Incoming jump from 0x052F, if not 0x1f < stack[-1] // Inputs[4] // { // @0534 stack[-2] // @0535 storage[stack[-2]] // @0538 stack[-3] // @053A stack[-1] // } 0530 61 PUSH2 0x0100 0533 80 DUP1 0534 83 DUP4 0535 54 SLOAD 0536 04 DIV 0537 02 MUL 0538 83 DUP4 0539 52 MSTORE 053A 91 SWAP2 053B 60 PUSH1 0x20 053D 01 ADD 053E 91 SWAP2 053F 61 PUSH2 0x056e 0542 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0539 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @053E stack[-1] = stack[-1] // @053E stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x056e label_0543: // Incoming jump from 0x052F, if 0x1f < stack[-1] // Inputs[5] // { // @0544 stack[-3] // @0545 stack[-1] // @0547 stack[-2] // @054F memory[0x00:0x20] // @0553 storage[keccak256(memory[0x00:0x20])] // } 0543 5B JUMPDEST 0544 82 DUP3 0545 01 ADD 0546 91 SWAP2 0547 90 SWAP1 0548 60 PUSH1 0x00 054A 52 MSTORE 054B 60 PUSH1 0x20 054D 60 PUSH1 0x00 054F 20 SHA3 0550 90 SWAP1 0551 5B JUMPDEST 0552 81 DUP2 0553 54 SLOAD 0554 81 DUP2 0555 52 MSTORE 0556 90 SWAP1 0557 60 PUSH1 0x01 0559 01 ADD 055A 90 SWAP1 055B 60 PUSH1 0x20 055D 01 ADD 055E 80 DUP1 055F 83 DUP4 0560 11 GT 0561 61 PUSH2 0x0551 0564 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0546 stack[-3] = stack[-3] + stack[-1] // @054A memory[0x00:0x20] = stack[-2] // @0555 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @055A stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @055D stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0551, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0565: // Incoming jump from 0x0564, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0564, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0565 stack[-3] // @0566 stack[-1] // } 0565 82 DUP3 0566 90 SWAP1 0567 03 SUB 0568 60 PUSH1 0x1f 056A 16 AND 056B 82 DUP3 056C 01 ADD 056D 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @056D stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @056D stack[-1] = stack[-3] // } // Block continues label_056E: // Incoming jump from 0x0542 // Incoming jump from 0x056D // Incoming jump from 0x0527, if !stack[-1] // Inputs[3] // { // @0574 stack[-7] // @0574 stack[-6] // @0576 stack[-8] // } 056E 5B JUMPDEST 056F 50 POP 0570 50 POP 0571 50 POP 0572 50 POP 0573 50 POP 0574 90 SWAP1 0575 50 POP 0576 90 SWAP1 0577 56 *JUMP // Stack delta = -7 // Outputs[1] { @0576 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0578: // Incoming call from 0x14D3, returns to 0x14D4 // Incoming jump from 0x0206 // Inputs[3] // { // @057B stack[-1] // @0586 memory[0x00:0x40] // @0587 storage[keccak256(memory[0x00:0x40])] // } 0578 5B JUMPDEST 0579 60 PUSH1 0x00 057B 81 DUP2 057C 81 DUP2 057D 52 MSTORE 057E 60 PUSH1 0x02 0580 60 PUSH1 0x20 0582 52 MSTORE 0583 60 PUSH1 0x40 0585 81 DUP2 0586 20 SHA3 0587 54 SLOAD 0588 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 059D 16 AND 059E 61 PUSH2 0x062e 05A1 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0579 stack[0] = 0x00 // @057D memory[0x00:0x20] = stack[-1] // @0582 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x062e, if 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] label_05A2: // Incoming jump from 0x05A1, if not 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @05A4 memory[0x40:0x60] } 05A2 60 PUSH1 0x40 05A4 51 MLOAD 05A5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 05C6 81 DUP2 05C7 52 MSTORE 05C8 60 PUSH1 0x20 05CA 60 PUSH1 0x04 05CC 82 DUP3 05CD 01 ADD 05CE 52 MSTORE 05CF 60 PUSH1 0x2c 05D1 60 PUSH1 0x24 05D3 82 DUP3 05D4 01 ADD 05D5 52 MSTORE 05D6 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 05F7 60 PUSH1 0x44 05F9 82 DUP3 05FA 01 ADD 05FB 52 MSTORE 05FC 7F PUSH32 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 061D 60 PUSH1 0x64 061F 82 DUP3 0620 01 ADD 0621 52 MSTORE 0622 60 PUSH1 0x84 0624 01 ADD // Stack delta = +1 // Outputs[6] // { // @05C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @05CE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @05D5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @05FB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 // @0621 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 // @0624 stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_0625: // Incoming jump from 0x1471 // Incoming jump from 0x0CD4 // Incoming jump from 0x121E // Incoming jump from 0x0879 // Incoming jump from 0x0E32 // Incoming jump from 0x1157 // Incoming jump from 0x102A // Incoming jump from 0x09CF // Incoming jump from 0x12C1 // Incoming jump from 0x0905 // Incoming jump from 0x0F25 // Incoming jump from 0x0624 // Incoming jump from 0x0D79 // Incoming jump from 0x15F3 // Incoming jump from 0x0B69 // Incoming jump from 0x0EB9 // Incoming jump from 0x1896 // Incoming jump from 0x1695 // Incoming jump from 0x071F // Incoming jump from 0x07D4 // Incoming jump from 0x0A86 // Incoming jump from 0x0C0F // Incoming jump from 0x1922 // Incoming jump from 0x0FA0 // Inputs[3] // { // @0628 memory[0x40:0x60] // @062A stack[-1] // @062D memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0625 5B JUMPDEST 0626 60 PUSH1 0x40 0628 51 MLOAD 0629 80 DUP1 062A 91 SWAP2 062B 03 SUB 062C 90 SWAP1 062D FD *REVERT // Stack delta = -1 // Outputs[1] { @062D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_062E: // Incoming jump from 0x05A1, if 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @0632 stack[-2] // @063D memory[0x00:0x40] // @063E storage[keccak256(memory[0x00:0x40])] // @0655 stack[-3] // } 062E 5B JUMPDEST 062F 50 POP 0630 60 PUSH1 0x00 0632 90 SWAP1 0633 81 DUP2 0634 52 MSTORE 0635 60 PUSH1 0x04 0637 60 PUSH1 0x20 0639 52 MSTORE 063A 60 PUSH1 0x40 063C 90 SWAP1 063D 20 SHA3 063E 54 SLOAD 063F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0654 16 AND 0655 90 SWAP1 0656 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0634 memory[0x00:0x20] = stack[-2] // @0639 memory[0x20:0x40] = 0x04 // @0655 stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0657: // Incoming jump from 0x024B // Inputs[1] { @065D stack[-1] } 0657 5B JUMPDEST 0658 60 PUSH1 0x00 065A 61 PUSH2 0x0662 065D 82 DUP3 065E 61 PUSH2 0x0c23 0661 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0658 stack[0] = 0x00 // @065A stack[1] = 0x0662 // @065D stack[2] = stack[-1] // } // Block ends with call to 0x0c23, returns to 0x0662 label_0662: // Incoming return from call to 0x0C23 at 0x0661 // Inputs[3] // { // @0663 stack[-2] // @0663 stack[-1] // @067C stack[-4] // } 0662 5B JUMPDEST 0663 90 SWAP1 0664 50 POP 0665 80 DUP1 0666 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 067B 16 AND 067C 83 DUP4 067D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0692 16 AND 0693 14 EQ 0694 15 ISZERO 0695 61 PUSH2 0x0720 0698 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0663 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0720, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_0699: // Incoming jump from 0x0698, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @069B memory[0x40:0x60] } 0699 60 PUSH1 0x40 069B 51 MLOAD 069C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 06BD 81 DUP2 06BE 52 MSTORE 06BF 60 PUSH1 0x20 06C1 60 PUSH1 0x04 06C3 82 DUP3 06C4 01 ADD 06C5 52 MSTORE 06C6 60 PUSH1 0x21 06C8 60 PUSH1 0x24 06CA 82 DUP3 06CB 01 ADD 06CC 52 MSTORE 06CD 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 06EE 60 PUSH1 0x44 06F0 82 DUP3 06F1 01 ADD 06F2 52 MSTORE 06F3 7F PUSH32 0x7200000000000000000000000000000000000000000000000000000000000000 0714 60 PUSH1 0x64 0716 82 DUP3 0717 01 ADD 0718 52 MSTORE 0719 60 PUSH1 0x84 071B 01 ADD 071C 61 PUSH2 0x0625 071F 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @06BE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @06C5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @06CC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @06F2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 // @0718 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7200000000000000000000000000000000000000000000000000000000000000 // @071B stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_0720: // Incoming jump from 0x0698, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[2] // { // @0721 msg.sender // @0737 stack[-1] // } 0720 5B JUMPDEST 0721 33 CALLER 0722 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0737 82 DUP3 0738 16 AND 0739 14 EQ 073A 80 DUP1 073B 61 PUSH2 0x0749 073E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0739 stack[0] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender } // Block ends with conditional jump to 0x0749, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender label_073F: // Incoming jump from 0x073E, if not stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender // Inputs[2] // { // @0743 stack[-2] // @0744 msg.sender // } 073F 50 POP 0740 61 PUSH2 0x0749 0743 81 DUP2 0744 33 CALLER 0745 61 PUSH2 0x047a 0748 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0740 stack[-1] = 0x0749 // @0743 stack[0] = stack[-2] // @0744 stack[1] = msg.sender // } // Block ends with call to 0x047a, returns to 0x0749 label_0749: // Incoming jump from 0x073E, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender // Incoming return from call to 0x047A at 0x0748 // Inputs[1] { @074D stack[-1] } 0749 5B JUMPDEST 074A 61 PUSH2 0x07d5 074D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x07d5, if stack[-1] label_074E: // Incoming jump from 0x074D, if not stack[-1] // Inputs[1] { @0750 memory[0x40:0x60] } 074E 60 PUSH1 0x40 0750 51 MLOAD 0751 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0772 81 DUP2 0773 52 MSTORE 0774 60 PUSH1 0x20 0776 60 PUSH1 0x04 0778 82 DUP3 0779 01 ADD 077A 52 MSTORE 077B 60 PUSH1 0x38 077D 60 PUSH1 0x24 077F 82 DUP3 0780 01 ADD 0781 52 MSTORE 0782 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 07A3 60 PUSH1 0x44 07A5 82 DUP3 07A6 01 ADD 07A7 52 MSTORE 07A8 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 07C9 60 PUSH1 0x64 07CB 82 DUP3 07CC 01 ADD 07CD 52 MSTORE 07CE 60 PUSH1 0x84 07D0 01 ADD 07D1 61 PUSH2 0x0625 07D4 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0773 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @077A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0781 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x38 // @07A7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 // @07CD memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 // @07D0 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_07D5: // Incoming jump from 0x074D, if stack[-1] // Inputs[2] // { // @07D9 stack[-3] // @07DA stack[-2] // } 07D5 5B JUMPDEST 07D6 61 PUSH2 0x07df 07D9 83 DUP4 07DA 83 DUP4 07DB 61 PUSH2 0x1321 07DE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07D6 stack[0] = 0x07df // @07D9 stack[1] = stack[-3] // @07DA stack[2] = stack[-2] // } // Block ends with call to 0x1321, returns to 0x07DF label_07DF: // Incoming return from call to 0x1321 at 0x07DE // Incoming return from call to 0x2107 at 0x1FA0 // Incoming return from call to 0x2058 at 0x1F63 // Incoming return from call to 0x1E9B at 0x1CAA // Incoming jump from 0x1F97, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // Inputs[1] { @07E3 stack[-4] } 07DF 5B JUMPDEST 07E0 50 POP 07E1 50 POP 07E2 50 POP 07E3 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_07E4: // Incoming jump from 0x028C // Inputs[2] // { // @07E8 msg.sender // @07E9 stack[-1] // } 07E4 5B JUMPDEST 07E5 61 PUSH2 0x07ee 07E8 33 CALLER 07E9 82 DUP3 07EA 61 PUSH2 0x13c1 07ED 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07E5 stack[0] = 0x07ee // @07E8 stack[1] = msg.sender // @07E9 stack[2] = stack[-1] // } // Block ends with call to 0x13c1, returns to 0x07EE label_07EE: // Incoming return from call to 0x13C1 at 0x07ED // Inputs[1] { @07F2 stack[-1] } 07EE 5B JUMPDEST 07EF 61 PUSH2 0x087a 07F2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x087a, if stack[-1] label_07F3: // Incoming jump from 0x07F2, if not stack[-1] // Inputs[1] { @07F5 memory[0x40:0x60] } 07F3 60 PUSH1 0x40 07F5 51 MLOAD 07F6 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0817 81 DUP2 0818 52 MSTORE 0819 60 PUSH1 0x20 081B 60 PUSH1 0x04 081D 82 DUP3 081E 01 ADD 081F 52 MSTORE 0820 60 PUSH1 0x31 0822 60 PUSH1 0x24 0824 82 DUP3 0825 01 ADD 0826 52 MSTORE 0827 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 0848 60 PUSH1 0x44 084A 82 DUP3 084B 01 ADD 084C 52 MSTORE 084D 7F PUSH32 0x776e6572206e6f7220617070726f766564000000000000000000000000000000 086E 60 PUSH1 0x64 0870 82 DUP3 0871 01 ADD 0872 52 MSTORE 0873 60 PUSH1 0x84 0875 01 ADD 0876 61 PUSH2 0x0625 0879 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0818 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @081F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0826 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x31 // @084C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f // @0872 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x776e6572206e6f7220617070726f766564000000000000000000000000000000 // @0875 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_087A: // Incoming jump from 0x07F2, if stack[-1] // Inputs[3] // { // @087E stack[-3] // @087F stack[-2] // @0880 stack[-1] // } 087A 5B JUMPDEST 087B 61 PUSH2 0x07df 087E 83 DUP4 087F 83 DUP4 0880 83 DUP4 0881 61 PUSH2 0x1531 0884 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @087B stack[0] = 0x07df // @087E stack[1] = stack[-3] // @087F stack[2] = stack[-2] // @0880 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1531 label_0885: // Incoming jump from 0x02AC // Inputs[2] // { // @0888 storage[0x0a] // @089F msg.sender // } 0885 5B JUMPDEST 0886 60 PUSH1 0x0a 0888 54 SLOAD 0889 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 089E 16 AND 089F 33 CALLER 08A0 14 EQ 08A1 61 PUSH2 0x0906 08A4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0906, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] label_08A5: // Incoming jump from 0x08A4, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] // Inputs[1] { @08A7 memory[0x40:0x60] } 08A5 60 PUSH1 0x40 08A7 51 MLOAD 08A8 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 08C9 81 DUP2 08CA 52 MSTORE 08CB 60 PUSH1 0x20 08CD 60 PUSH1 0x04 08CF 82 DUP3 08D0 01 ADD 08D1 81 DUP2 08D2 90 SWAP1 08D3 52 MSTORE 08D4 60 PUSH1 0x24 08D6 82 DUP3 08D7 01 ADD 08D8 52 MSTORE 08D9 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 08FA 60 PUSH1 0x44 08FC 82 DUP3 08FD 01 ADD 08FE 52 MSTORE 08FF 60 PUSH1 0x64 0901 01 ADD 0902 61 PUSH2 0x0625 0905 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @08CA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @08D3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @08D8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @08FE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0901 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_0906: // Incoming jump from 0x08A4, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] // Inputs[5] // { // @0909 memory[0x40:0x60] // @090A msg.sender // @090C stack[-1] // @091D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @091D address(msg.sender).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } 0906 5B JUMPDEST 0907 60 PUSH1 0x40 0909 51 MLOAD 090A 33 CALLER 090B 90 SWAP1 090C 82 DUP3 090D 15 ISZERO 090E 61 PUSH2 0x08fc 0911 02 MUL 0912 90 SWAP1 0913 83 DUP4 0914 90 SWAP1 0915 60 PUSH1 0x00 0917 81 DUP2 0918 81 DUP2 0919 81 DUP2 091A 85 DUP6 091B 88 DUP9 091C 88 DUP9 091D F1 CALL 091E 93 SWAP4 091F 50 POP 0920 50 POP 0921 50 POP 0922 50 POP 0923 15 ISZERO 0924 80 DUP1 0925 15 ISZERO 0926 61 PUSH2 0x0933 0929 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @091D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(msg.sender).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0923 stack[0] = !address(msg.sender).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x0933, if !!address(msg.sender).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_092A: // Incoming jump from 0x0929, if not !!address(msg.sender).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @092A returndata.length // @092E returndata[0x00:0x00 + returndata.length] // @092F returndata.length // @0932 memory[0x00:0x00 + returndata.length] // } 092A 3D RETURNDATASIZE 092B 60 PUSH1 0x00 092D 80 DUP1 092E 3E RETURNDATACOPY 092F 3D RETURNDATASIZE 0930 60 PUSH1 0x00 0932 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @092E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0932 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0933: // Incoming jump from 0x0929, if !!address(msg.sender).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[1] { @0936 stack[-3] } 0933 5B JUMPDEST 0934 50 POP 0935 50 POP 0936 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0937: // Incoming jump from 0x02CC // Inputs[1] { @093D stack[-2] } 0937 5B JUMPDEST 0938 60 PUSH1 0x00 093A 61 PUSH2 0x0942 093D 83 DUP4 093E 61 PUSH2 0x0cd5 0941 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0938 stack[0] = 0x00 // @093A stack[1] = 0x0942 // @093D stack[2] = stack[-2] // } // Block ends with call to 0x0cd5, returns to 0x0942 label_0942: // Incoming return from call to 0x0CD5 at 0x0941 // Inputs[2] // { // @0943 stack[-3] // @0944 stack[-1] // } 0942 5B JUMPDEST 0943 82 DUP3 0944 10 LT 0945 61 PUSH2 0x09d0 0948 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x09d0, if stack[-3] < stack[-1] label_0949: // Incoming jump from 0x0948, if not stack[-3] < stack[-1] // Inputs[1] { @094B memory[0x40:0x60] } 0949 60 PUSH1 0x40 094B 51 MLOAD 094C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 096D 81 DUP2 096E 52 MSTORE 096F 60 PUSH1 0x20 0971 60 PUSH1 0x04 0973 82 DUP3 0974 01 ADD 0975 52 MSTORE 0976 60 PUSH1 0x2b 0978 60 PUSH1 0x24 097A 82 DUP3 097B 01 ADD 097C 52 MSTORE 097D 7F PUSH32 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 099E 60 PUSH1 0x44 09A0 82 DUP3 09A1 01 ADD 09A2 52 MSTORE 09A3 7F PUSH32 0x74206f6620626f756e6473000000000000000000000000000000000000000000 09C4 60 PUSH1 0x64 09C6 82 DUP3 09C7 01 ADD 09C8 52 MSTORE 09C9 60 PUSH1 0x84 09CB 01 ADD 09CC 61 PUSH2 0x0625 09CF 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @096E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0975 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @097C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @09A2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 // @09C8 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x74206f6620626f756e6473000000000000000000000000000000000000000000 // @09CB stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_09D0: // Incoming jump from 0x0948, if stack[-3] < stack[-1] // Inputs[6] // { // @09E7 stack[-3] // @09E8 stack[-2] // @09FB memory[0x00:0x40] // @0A02 memory[0x00:0x40] // @0A03 storage[keccak256(memory[0x00:0x40])] // @0A04 stack[-4] // } 09D0 5B JUMPDEST 09D1 50 POP 09D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09E7 91 SWAP2 09E8 90 SWAP1 09E9 91 SWAP2 09EA 16 AND 09EB 60 PUSH1 0x00 09ED 90 SWAP1 09EE 81 DUP2 09EF 52 MSTORE 09F0 60 PUSH1 0x06 09F2 60 PUSH1 0x20 09F4 90 SWAP1 09F5 81 DUP2 09F6 52 MSTORE 09F7 60 PUSH1 0x40 09F9 80 DUP1 09FA 83 DUP4 09FB 20 SHA3 09FC 93 SWAP4 09FD 83 DUP4 09FE 52 MSTORE 09FF 92 SWAP3 0A00 90 SWAP1 0A01 52 MSTORE 0A02 20 SHA3 0A03 54 SLOAD 0A04 90 SWAP1 0A05 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @09EF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @09F6 memory[0x20:0x40] = 0x06 // @09FE memory[0x00:0x20] = stack[-2] // @0A01 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0A04 stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_0A06: // Incoming call from 0x02E1, returns to 0x024C // Inputs[2] // { // @0A09 storage[0x0a] // @0A20 msg.sender // } 0A06 5B JUMPDEST 0A07 60 PUSH1 0x0a 0A09 54 SLOAD 0A0A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A1F 16 AND 0A20 33 CALLER 0A21 14 EQ 0A22 61 PUSH2 0x0a87 0A25 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a87, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] label_0A26: // Incoming jump from 0x0A25, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] // Inputs[1] { @0A28 memory[0x40:0x60] } 0A26 60 PUSH1 0x40 0A28 51 MLOAD 0A29 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0A4A 81 DUP2 0A4B 52 MSTORE 0A4C 60 PUSH1 0x20 0A4E 60 PUSH1 0x04 0A50 82 DUP3 0A51 01 ADD 0A52 81 DUP2 0A53 90 SWAP1 0A54 52 MSTORE 0A55 60 PUSH1 0x24 0A57 82 DUP3 0A58 01 ADD 0A59 52 MSTORE 0A5A 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0A7B 60 PUSH1 0x44 0A7D 82 DUP3 0A7E 01 ADD 0A7F 52 MSTORE 0A80 60 PUSH1 0x64 0A82 01 ADD 0A83 61 PUSH2 0x0625 0A86 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A4B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0A54 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A59 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0A7F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0A82 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_0A87: // Incoming jump from 0x0A25, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] // Inputs[6] // { // @0A8A memory[0x40:0x60] // @0A8B msg.sender // @0A8D address(this).balance // @0A8D address(this) // @0A9D address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0A9D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // } 0A87 5B JUMPDEST 0A88 60 PUSH1 0x40 0A8A 51 MLOAD 0A8B 33 CALLER 0A8C 90 SWAP1 0A8D 47 SELFBALANCE 0A8E 80 DUP1 0A8F 15 ISZERO 0A90 61 PUSH2 0x08fc 0A93 02 MUL 0A94 91 SWAP2 0A95 60 PUSH1 0x00 0A97 81 DUP2 0A98 81 DUP2 0A99 81 DUP2 0A9A 85 DUP6 0A9B 88 DUP9 0A9C 88 DUP9 0A9D F1 CALL 0A9E 93 SWAP4 0A9F 50 POP 0AA0 50 POP 0AA1 50 POP 0AA2 50 POP 0AA3 15 ISZERO 0AA4 80 DUP1 0AA5 15 ISZERO 0AA6 61 PUSH2 0x0ab3 0AA9 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0A9D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0AA3 stack[0] = !address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x0ab3, if !!address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_0AAA: // Incoming jump from 0x0AA9, if not !!address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @0AAA returndata.length // @0AAE returndata[0x00:0x00 + returndata.length] // @0AAF returndata.length // @0AB2 memory[0x00:0x00 + returndata.length] // } 0AAA 3D RETURNDATASIZE 0AAB 60 PUSH1 0x00 0AAD 80 DUP1 0AAE 3E RETURNDATACOPY 0AAF 3D RETURNDATASIZE 0AB0 60 PUSH1 0x00 0AB2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0AAE memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0AB2 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0AB3: // Incoming jump from 0x221A, if stack[-1] == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x0AA9, if !!address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Incoming return from call to 0x17A3 at 0x12CA // Inputs[1] { @0AB5 stack[-2] } 0AB3 5B JUMPDEST 0AB4 50 POP 0AB5 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0AB6: // Incoming jump from 0x0301 // Inputs[4] // { // @0ABA stack[-3] // @0ABB stack[-2] // @0ABC stack[-1] // @0ABF memory[0x40:0x60] // } 0AB6 5B JUMPDEST 0AB7 61 PUSH2 0x07df 0ABA 83 DUP4 0ABB 83 DUP4 0ABC 83 DUP4 0ABD 60 PUSH1 0x40 0ABF 51 MLOAD 0AC0 80 DUP1 0AC1 60 PUSH1 0x20 0AC3 01 ADD 0AC4 60 PUSH1 0x40 0AC6 52 MSTORE 0AC7 80 DUP1 0AC8 60 PUSH1 0x00 0ACA 81 DUP2 0ACB 52 MSTORE 0ACC 50 POP 0ACD 61 PUSH2 0x10c2 0AD0 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0AB7 stack[0] = 0x07df // @0ABA stack[1] = stack[-3] // @0ABB stack[2] = stack[-2] // @0ABC stack[3] = stack[-1] // @0ABF stack[4] = memory[0x40:0x60] // @0AC6 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0ACB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x10c2 label_0AD1: // Incoming jump from 0x0321 // Inputs[1] { @0AD9 storage[0x08] } 0AD1 5B JUMPDEST 0AD2 60 PUSH1 0x00 0AD4 61 PUSH2 0x0adc 0AD7 60 PUSH1 0x08 0AD9 54 SLOAD 0ADA 90 SWAP1 0ADB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0AD2 stack[0] = 0x00 // @0ADA stack[1] = storage[0x08] // } // Block ends with unconditional jump to 0x0adc label_0ADC: // Incoming jump from 0x0ADB // Inputs[2] // { // @0ADD stack[-3] // @0ADE stack[-1] // } 0ADC 5B JUMPDEST 0ADD 82 DUP3 0ADE 10 LT 0ADF 61 PUSH2 0x0b6a 0AE2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b6a, if stack[-3] < stack[-1] label_0AE3: // Incoming jump from 0x0AE2, if not stack[-3] < stack[-1] // Inputs[1] { @0AE5 memory[0x40:0x60] } 0AE3 60 PUSH1 0x40 0AE5 51 MLOAD 0AE6 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0B07 81 DUP2 0B08 52 MSTORE 0B09 60 PUSH1 0x20 0B0B 60 PUSH1 0x04 0B0D 82 DUP3 0B0E 01 ADD 0B0F 52 MSTORE 0B10 60 PUSH1 0x2c 0B12 60 PUSH1 0x24 0B14 82 DUP3 0B15 01 ADD 0B16 52 MSTORE 0B17 7F PUSH32 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f 0B38 60 PUSH1 0x44 0B3A 82 DUP3 0B3B 01 ADD 0B3C 52 MSTORE 0B3D 7F PUSH32 0x7574206f6620626f756e64730000000000000000000000000000000000000000 0B5E 60 PUSH1 0x64 0B60 82 DUP3 0B61 01 ADD 0B62 52 MSTORE 0B63 60 PUSH1 0x84 0B65 01 ADD 0B66 61 PUSH2 0x0625 0B69 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0B08 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0B0F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B16 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @0B3C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f // @0B62 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7574206f6620626f756e64730000000000000000000000000000000000000000 // @0B65 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_0B6A: // Incoming jump from 0x0AE2, if stack[-3] < stack[-1] // Inputs[2] // { // @0B6D stack[-2] // @0B6F storage[0x08] // } 0B6A 5B JUMPDEST 0B6B 60 PUSH1 0x08 0B6D 82 DUP3 0B6E 81 DUP2 0B6F 54 SLOAD 0B70 81 DUP2 0B71 10 LT 0B72 61 PUSH2 0x0b7d 0B75 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0B6B stack[0] = 0x08 // @0B6D stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0b7d, if stack[-2] < storage[0x08] label_0B76: // Incoming jump from 0x0B75, if not stack[-2] < storage[0x08] 0B76 61 PUSH2 0x0b7d 0B79 61 PUSH2 0x25da 0B7C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B76 stack[0] = 0x0b7d } // Block ends with unconditional jump to 0x25da label_0B7D: // Incoming jump from 0x0B75, if stack[-2] < storage[0x08] // Inputs[7] // { // @0B7E stack[-2] // @0B7E stack[-1] // @0B86 memory[0x00:0x20] // @0B88 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0B89 stack[-3] // @0B8B stack[-5] // @0B8C stack[-4] // } 0B7D 5B JUMPDEST 0B7E 90 SWAP1 0B7F 60 PUSH1 0x00 0B81 52 MSTORE 0B82 60 PUSH1 0x20 0B84 60 PUSH1 0x00 0B86 20 SHA3 0B87 01 ADD 0B88 54 SLOAD 0B89 90 SWAP1 0B8A 50 POP 0B8B 91 SWAP2 0B8C 90 SWAP1 0B8D 50 POP 0B8E 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @0B81 memory[0x00:0x20] = stack[-2] // @0B8B stack[-5] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-5] label_0B8F: // Incoming jump from 0x0341 // Inputs[2] // { // @0B92 storage[0x0a] // @0BA9 msg.sender // } 0B8F 5B JUMPDEST 0B90 60 PUSH1 0x0a 0B92 54 SLOAD 0B93 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BA8 16 AND 0BA9 33 CALLER 0BAA 14 EQ 0BAB 61 PUSH2 0x0c10 0BAE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c10, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] label_0BAF: // Incoming jump from 0x0BAE, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] // Inputs[1] { @0BB1 memory[0x40:0x60] } 0BAF 60 PUSH1 0x40 0BB1 51 MLOAD 0BB2 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0BD3 81 DUP2 0BD4 52 MSTORE 0BD5 60 PUSH1 0x20 0BD7 60 PUSH1 0x04 0BD9 82 DUP3 0BDA 01 ADD 0BDB 81 DUP2 0BDC 90 SWAP1 0BDD 52 MSTORE 0BDE 60 PUSH1 0x24 0BE0 82 DUP3 0BE1 01 ADD 0BE2 52 MSTORE 0BE3 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0C04 60 PUSH1 0x44 0C06 82 DUP3 0C07 01 ADD 0C08 52 MSTORE 0C09 60 PUSH1 0x64 0C0B 01 ADD 0C0C 61 PUSH2 0x0625 0C0F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0BD4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0BDD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BE2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0C08 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0C0B stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_0C10: // Incoming jump from 0x0BAE, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] // Inputs[2] // { // @0C11 stack[-1] // @0C12 memory[stack[-1]:stack[-1] + 0x20] // } 0C10 5B JUMPDEST 0C11 80 DUP1 0C12 51 MLOAD 0C13 61 PUSH2 0x0933 0C16 90 SWAP1 0C17 60 PUSH1 0x0e 0C19 90 SWAP1 0C1A 60 PUSH1 0x20 0C1C 84 DUP5 0C1D 01 ADD 0C1E 90 SWAP1 0C1F 61 PUSH2 0x2158 0C22 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0C16 stack[0] = 0x0933 // @0C19 stack[1] = 0x0e // @0C1E stack[2] = stack[-1] + 0x20 // @0C1E stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2158 label_0C23: // Incoming call from 0x137A, returns to 0x137B // Incoming call from 0x147C, returns to 0x147D // Incoming jump from 0x0361 // Incoming call from 0x1550, returns to 0x1551 // Incoming call from 0x0661, returns to 0x0662 // Inputs[3] // { // @0C26 stack[-1] // @0C31 memory[0x00:0x40] // @0C32 storage[keccak256(memory[0x00:0x40])] // } 0C23 5B JUMPDEST 0C24 60 PUSH1 0x00 0C26 81 DUP2 0C27 81 DUP2 0C28 52 MSTORE 0C29 60 PUSH1 0x02 0C2B 60 PUSH1 0x20 0C2D 52 MSTORE 0C2E 60 PUSH1 0x40 0C30 81 DUP2 0C31 20 SHA3 0C32 54 SLOAD 0C33 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C48 16 AND 0C49 80 DUP1 0C4A 61 PUSH2 0x04e0 0C4D 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0C24 stack[0] = 0x00 // @0C28 memory[0x00:0x20] = stack[-1] // @0C2D memory[0x20:0x40] = 0x02 // @0C48 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x04e0, if 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] label_0C4E: // Incoming jump from 0x0C4D, if not 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0C50 memory[0x40:0x60] } 0C4E 60 PUSH1 0x40 0C50 51 MLOAD 0C51 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0C72 81 DUP2 0C73 52 MSTORE 0C74 60 PUSH1 0x20 0C76 60 PUSH1 0x04 0C78 82 DUP3 0C79 01 ADD 0C7A 52 MSTORE 0C7B 60 PUSH1 0x29 0C7D 60 PUSH1 0x24 0C7F 82 DUP3 0C80 01 ADD 0C81 52 MSTORE 0C82 7F PUSH32 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 0CA3 60 PUSH1 0x44 0CA5 82 DUP3 0CA6 01 ADD 0CA7 52 MSTORE 0CA8 7F PUSH32 0x656e7420746f6b656e0000000000000000000000000000000000000000000000 0CC9 60 PUSH1 0x64 0CCB 82 DUP3 0CCC 01 ADD 0CCD 52 MSTORE 0CCE 60 PUSH1 0x84 0CD0 01 ADD 0CD1 61 PUSH2 0x0625 0CD4 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0C73 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0C7A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C81 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0CA7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 // @0CCD memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x656e7420746f6b656e0000000000000000000000000000000000000000000000 // @0CD0 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_0CD5: // Incoming call from 0x0941, returns to 0x0942 // Incoming call from 0x2111, returns to 0x2112 // Incoming call from 0x1FAD, returns to 0x1FAE // Incoming jump from 0x0381 // Inputs[1] { @0CED stack[-1] } 0CD5 5B JUMPDEST 0CD6 60 PUSH1 0x00 0CD8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CED 82 DUP3 0CEE 16 AND 0CEF 61 PUSH2 0x0d7a 0CF2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0CD6 stack[0] = 0x00 } // Block ends with conditional jump to 0x0d7a, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff label_0CF3: // Incoming jump from 0x0CF2, if not stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @0CF5 memory[0x40:0x60] } 0CF3 60 PUSH1 0x40 0CF5 51 MLOAD 0CF6 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0D17 81 DUP2 0D18 52 MSTORE 0D19 60 PUSH1 0x20 0D1B 60 PUSH1 0x04 0D1D 82 DUP3 0D1E 01 ADD 0D1F 52 MSTORE 0D20 60 PUSH1 0x2a 0D22 60 PUSH1 0x24 0D24 82 DUP3 0D25 01 ADD 0D26 52 MSTORE 0D27 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 0D48 60 PUSH1 0x44 0D4A 82 DUP3 0D4B 01 ADD 0D4C 52 MSTORE 0D4D 7F PUSH32 0x726f206164647265737300000000000000000000000000000000000000000000 0D6E 60 PUSH1 0x64 0D70 82 DUP3 0D71 01 ADD 0D72 52 MSTORE 0D73 60 PUSH1 0x84 0D75 01 ADD 0D76 61 PUSH2 0x0625 0D79 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0D18 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0D1F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D26 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @0D4C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 // @0D72 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x726f206164647265737300000000000000000000000000000000000000000000 // @0D75 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_0D7A: // Incoming jump from 0x0CF2, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[4] // { // @0D91 stack[-2] // @0D9F memory[0x00:0x40] // @0DA0 storage[keccak256(memory[0x00:0x40])] // @0DA1 stack[-3] // } 0D7A 5B JUMPDEST 0D7B 50 POP 0D7C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D91 16 AND 0D92 60 PUSH1 0x00 0D94 90 SWAP1 0D95 81 DUP2 0D96 52 MSTORE 0D97 60 PUSH1 0x03 0D99 60 PUSH1 0x20 0D9B 52 MSTORE 0D9C 60 PUSH1 0x40 0D9E 90 SWAP1 0D9F 20 SHA3 0DA0 54 SLOAD 0DA1 90 SWAP1 0DA2 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0D96 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0D9B memory[0x20:0x40] = 0x03 // @0DA1 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0DA3: // Incoming call from 0x0396, returns to 0x01DA // Inputs[1] { @0DA9 storage[0x0e] } 0DA3 5B JUMPDEST 0DA4 60 PUSH1 0x60 0DA6 60 PUSH1 0x0e 0DA8 80 DUP1 0DA9 54 SLOAD 0DAA 61 PUSH2 0x04f5 0DAD 90 SWAP1 0DAE 61 PUSH2 0x2586 0DB1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0DA4 stack[0] = 0x60 // @0DA6 stack[1] = 0x0e // @0DAD stack[2] = 0x04f5 // @0DAD stack[3] = storage[0x0e] // } // Block ends with call to 0x2586, returns to 0x04F5 label_0DB2: // Incoming call from 0x03AB, returns to 0x024C // Inputs[2] // { // @0DB5 storage[0x0a] // @0DCC msg.sender // } 0DB2 5B JUMPDEST 0DB3 60 PUSH1 0x0a 0DB5 54 SLOAD 0DB6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DCB 16 AND 0DCC 33 CALLER 0DCD 14 EQ 0DCE 61 PUSH2 0x0e33 0DD1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e33, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] label_0DD2: // Incoming jump from 0x0DD1, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] // Inputs[1] { @0DD4 memory[0x40:0x60] } 0DD2 60 PUSH1 0x40 0DD4 51 MLOAD 0DD5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0DF6 81 DUP2 0DF7 52 MSTORE 0DF8 60 PUSH1 0x20 0DFA 60 PUSH1 0x04 0DFC 82 DUP3 0DFD 01 ADD 0DFE 81 DUP2 0DFF 90 SWAP1 0E00 52 MSTORE 0E01 60 PUSH1 0x24 0E03 82 DUP3 0E04 01 ADD 0E05 52 MSTORE 0E06 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0E27 60 PUSH1 0x44 0E29 82 DUP3 0E2A 01 ADD 0E2B 52 MSTORE 0E2C 60 PUSH1 0x64 0E2E 01 ADD 0E2F 61 PUSH2 0x0625 0E32 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0DF7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0E00 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E05 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0E2B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0E2E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_0E33: // Incoming jump from 0x0DD1, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] 0E33 5B JUMPDEST 0E34 61 PUSH2 0x0e3d 0E37 60 PUSH1 0x00 0E39 61 PUSH2 0x17a3 0E3C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0E34 stack[0] = 0x0e3d // @0E37 stack[1] = 0x00 // } // Block ends with call to 0x17a3, returns to 0x0E3D label_0E3D: // Incoming return from call to 0x17A3 at 0x0E3C // Inputs[1] { @0E3E stack[-1] } 0E3D 5B JUMPDEST 0E3E 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0E3F: // Incoming call from 0x03EB, returns to 0x01DA // Inputs[1] { @0E45 storage[0x01] } 0E3F 5B JUMPDEST 0E40 60 PUSH1 0x60 0E42 60 PUSH1 0x01 0E44 80 DUP1 0E45 54 SLOAD 0E46 61 PUSH2 0x04f5 0E49 90 SWAP1 0E4A 61 PUSH2 0x2586 0E4D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E40 stack[0] = 0x60 // @0E42 stack[1] = 0x01 // @0E49 stack[2] = 0x04f5 // @0E49 stack[3] = storage[0x01] // } // Block ends with call to 0x2586, returns to 0x04F5 label_0E4E: // Incoming jump from 0x03FE // Inputs[2] // { // @0E51 storage[0x0b] // @0E52 msg.value // } 0E4E 5B JUMPDEST 0E4F 60 PUSH1 0x0b 0E51 54 SLOAD 0E52 34 CALLVALUE 0E53 10 LT 0E54 15 ISZERO 0E55 61 PUSH2 0x0eba 0E58 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0eba, if !(msg.value < storage[0x0b]) label_0E59: // Incoming jump from 0x0E58, if not !(msg.value < storage[0x0b]) // Inputs[1] { @0E5B memory[0x40:0x60] } 0E59 60 PUSH1 0x40 0E5B 51 MLOAD 0E5C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0E7D 81 DUP2 0E7E 52 MSTORE 0E7F 60 PUSH1 0x20 0E81 60 PUSH1 0x04 0E83 82 DUP3 0E84 01 ADD 0E85 52 MSTORE 0E86 60 PUSH1 0x06 0E88 60 PUSH1 0x24 0E8A 82 DUP3 0E8B 01 ADD 0E8C 52 MSTORE 0E8D 7F PUSH32 0x214e454554480000000000000000000000000000000000000000000000000000 0EAE 60 PUSH1 0x44 0EB0 82 DUP3 0EB1 01 ADD 0EB2 52 MSTORE 0EB3 60 PUSH1 0x64 0EB5 01 ADD 0EB6 61 PUSH2 0x0625 0EB9 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0E7E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0E85 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E8C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x06 // @0EB2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x214e454554480000000000000000000000000000000000000000000000000000 // @0EB5 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_0EBA: // Incoming jump from 0x0E58, if !(msg.value < storage[0x0b]) // Inputs[2] // { // @0EBD storage[0x0d] // @0EBE block.timestamp // } 0EBA 5B JUMPDEST 0EBB 60 PUSH1 0x0d 0EBD 54 SLOAD 0EBE 42 TIMESTAMP 0EBF 10 LT 0EC0 15 ISZERO 0EC1 61 PUSH2 0x0f26 0EC4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f26, if !(block.timestamp < storage[0x0d]) label_0EC5: // Incoming jump from 0x0EC4, if not !(block.timestamp < storage[0x0d]) // Inputs[1] { @0EC7 memory[0x40:0x60] } 0EC5 60 PUSH1 0x40 0EC7 51 MLOAD 0EC8 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0EE9 81 DUP2 0EEA 52 MSTORE 0EEB 60 PUSH1 0x20 0EED 60 PUSH1 0x04 0EEF 82 DUP3 0EF0 01 ADD 0EF1 52 MSTORE 0EF2 60 PUSH1 0x03 0EF4 60 PUSH1 0x24 0EF6 82 DUP3 0EF7 01 ADD 0EF8 52 MSTORE 0EF9 7F PUSH32 0x214e520000000000000000000000000000000000000000000000000000000000 0F1A 60 PUSH1 0x44 0F1C 82 DUP3 0F1D 01 ADD 0F1E 52 MSTORE 0F1F 60 PUSH1 0x64 0F21 01 ADD 0F22 61 PUSH2 0x0625 0F25 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0EEA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0EF1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0EF8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @0F1E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x214e520000000000000000000000000000000000000000000000000000000000 // @0F21 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_0F26: // Incoming jump from 0x0EC4, if !(block.timestamp < storage[0x0d]) // Inputs[2] // { // @0F29 storage[0x0c] // @0F2C storage[0x08] // } 0F26 5B JUMPDEST 0F27 60 PUSH1 0x0c 0F29 54 SLOAD 0F2A 60 PUSH1 0x08 0F2C 54 SLOAD 0F2D 61 PUSH2 0x0f37 0F30 90 SWAP1 0F31 60 PUSH1 0x01 0F33 61 PUSH2 0x2638 0F36 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F29 stack[0] = storage[0x0c] // @0F30 stack[1] = 0x0f37 // @0F30 stack[2] = storage[0x08] // @0F31 stack[3] = 0x01 // } // Block ends with call to 0x2638, returns to 0x0F37 label_0F37: // Incoming return from call to 0x2638 at 0x0F36 // Inputs[2] // { // @0F38 stack[-2] // @0F38 stack[-1] // } 0F37 5B JUMPDEST 0F38 11 GT 0F39 15 ISZERO 0F3A 61 PUSH2 0x0fa1 0F3D 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0fa1, if !(stack[-1] > stack[-2]) label_0F3E: // Incoming jump from 0x0F3D, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0F40 memory[0x40:0x60] } 0F3E 60 PUSH1 0x40 0F40 51 MLOAD 0F41 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0F62 81 DUP2 0F63 52 MSTORE 0F64 60 PUSH1 0x04 0F66 01 ADD 0F67 61 PUSH2 0x0625 0F6A 90 SWAP1 0F6B 60 PUSH1 0x20 0F6D 80 DUP1 0F6E 82 DUP3 0F6F 52 MSTORE 0F70 60 PUSH1 0x04 0F72 90 SWAP1 0F73 82 DUP3 0F74 01 ADD 0F75 52 MSTORE 0F76 7F PUSH32 0x214f4f5300000000000000000000000000000000000000000000000000000000 0F97 60 PUSH1 0x40 0F99 82 DUP3 0F9A 01 ADD 0F9B 52 MSTORE 0F9C 60 PUSH1 0x60 0F9E 01 ADD 0F9F 90 SWAP1 0FA0 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0F63 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0F6F memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @0F75 memory[0x04 + memory[0x40:0x60] + 0x20:0x04 + memory[0x40:0x60] + 0x20 + 0x20] = 0x04 // @0F9B memory[0x04 + memory[0x40:0x60] + 0x40:0x04 + memory[0x40:0x60] + 0x40 + 0x20] = 0x214f4f5300000000000000000000000000000000000000000000000000000000 // @0F9F stack[0] = 0x60 + 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_0FA1: // Incoming jump from 0x0F3D, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @0FA5 msg.sender // @0FA6 stack[-1] // } 0FA1 5B JUMPDEST 0FA2 61 PUSH2 0x0ab3 0FA5 33 CALLER 0FA6 82 DUP3 0FA7 61 PUSH2 0x181a 0FAA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FA2 stack[0] = 0x0ab3 // @0FA5 stack[1] = msg.sender // @0FA6 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x181a label_0FAB: // Incoming jump from 0x041E // Inputs[2] // { // @0FC1 stack[-2] // @0FC3 msg.sender // } 0FAB 5B JUMPDEST 0FAC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FC1 82 DUP3 0FC2 16 AND 0FC3 33 CALLER 0FC4 14 EQ 0FC5 15 ISZERO 0FC6 61 PUSH2 0x102b 0FC9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x102b, if !(msg.sender == stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff) label_0FCA: // Incoming jump from 0x0FC9, if not !(msg.sender == stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[1] { @0FCC memory[0x40:0x60] } 0FCA 60 PUSH1 0x40 0FCC 51 MLOAD 0FCD 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0FEE 81 DUP2 0FEF 52 MSTORE 0FF0 60 PUSH1 0x20 0FF2 60 PUSH1 0x04 0FF4 82 DUP3 0FF5 01 ADD 0FF6 52 MSTORE 0FF7 60 PUSH1 0x19 0FF9 60 PUSH1 0x24 0FFB 82 DUP3 0FFC 01 ADD 0FFD 52 MSTORE 0FFE 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 101F 60 PUSH1 0x44 1021 82 DUP3 1022 01 ADD 1023 52 MSTORE 1024 60 PUSH1 0x64 1026 01 ADD 1027 61 PUSH2 0x0625 102A 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0FEF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0FF6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0FFD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @1023 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @1026 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_102B: // Incoming jump from 0x0FC9, if !(msg.sender == stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[10] // { // @102C msg.sender // @103D memory[0x00:0x40] // @1053 stack[-2] // @105E memory[0x00:0x40] // @1060 storage[keccak256(memory[0x00:0x40])] // @1083 stack[-1] // @108D memory[0x40:0x60] // @10B9 memory[0x40:0x60] // @10BE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @10C1 stack[-3] // } 102B 5B JUMPDEST 102C 33 CALLER 102D 60 PUSH1 0x00 102F 81 DUP2 1030 81 DUP2 1031 52 MSTORE 1032 60 PUSH1 0x05 1034 60 PUSH1 0x20 1036 90 SWAP1 1037 81 DUP2 1038 52 MSTORE 1039 60 PUSH1 0x40 103B 80 DUP1 103C 83 DUP4 103D 20 SHA3 103E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1053 87 DUP8 1054 16 AND 1055 80 DUP1 1056 85 DUP6 1057 52 MSTORE 1058 90 SWAP1 1059 83 DUP4 105A 52 MSTORE 105B 92 SWAP3 105C 81 DUP2 105D 90 SWAP1 105E 20 SHA3 105F 80 DUP1 1060 54 SLOAD 1061 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 1082 16 AND 1083 86 DUP7 1084 15 ISZERO 1085 15 ISZERO 1086 90 SWAP1 1087 81 DUP2 1088 17 OR 1089 90 SWAP1 108A 91 SWAP2 108B 55 SSTORE 108C 90 SWAP1 108D 51 MLOAD 108E 90 SWAP1 108F 81 DUP2 1090 52 MSTORE 1091 91 SWAP2 1092 92 SWAP3 1093 91 SWAP2 1094 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 10B5 91 SWAP2 10B6 01 ADD 10B7 60 PUSH1 0x40 10B9 51 MLOAD 10BA 80 DUP1 10BB 91 SWAP2 10BC 03 SUB 10BD 90 SWAP1 10BE A3 LOG3 10BF 50 POP 10C0 50 POP 10C1 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @1031 memory[0x00:0x20] = msg.sender // @1038 memory[0x20:0x40] = 0x05 // @1057 memory[0x00:0x20] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @105A memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @108B storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & storage[keccak256(memory[0x00:0x40])]) // @1090 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @10BE log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-3] label_10C2: // Incoming jump from 0x0AD0 // Incoming jump from 0x043E // Inputs[2] // { // @10C6 msg.sender // @10C7 stack[-2] // } 10C2 5B JUMPDEST 10C3 61 PUSH2 0x10cc 10C6 33 CALLER 10C7 83 DUP4 10C8 61 PUSH2 0x13c1 10CB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10C3 stack[0] = 0x10cc // @10C6 stack[1] = msg.sender // @10C7 stack[2] = stack[-2] // } // Block ends with call to 0x13c1, returns to 0x10CC label_10CC: // Incoming return from call to 0x13C1 at 0x10CB // Inputs[1] { @10D0 stack[-1] } 10CC 5B JUMPDEST 10CD 61 PUSH2 0x1158 10D0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1158, if stack[-1] label_10D1: // Incoming jump from 0x10D0, if not stack[-1] // Inputs[1] { @10D3 memory[0x40:0x60] } 10D1 60 PUSH1 0x40 10D3 51 MLOAD 10D4 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 10F5 81 DUP2 10F6 52 MSTORE 10F7 60 PUSH1 0x20 10F9 60 PUSH1 0x04 10FB 82 DUP3 10FC 01 ADD 10FD 52 MSTORE 10FE 60 PUSH1 0x31 1100 60 PUSH1 0x24 1102 82 DUP3 1103 01 ADD 1104 52 MSTORE 1105 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 1126 60 PUSH1 0x44 1128 82 DUP3 1129 01 ADD 112A 52 MSTORE 112B 7F PUSH32 0x776e6572206e6f7220617070726f766564000000000000000000000000000000 114C 60 PUSH1 0x64 114E 82 DUP3 114F 01 ADD 1150 52 MSTORE 1151 60 PUSH1 0x84 1153 01 ADD 1154 61 PUSH2 0x0625 1157 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @10F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @10FD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1104 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x31 // @112A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f // @1150 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x776e6572206e6f7220617070726f766564000000000000000000000000000000 // @1153 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_1158: // Incoming jump from 0x10D0, if stack[-1] // Inputs[4] // { // @115C stack[-4] // @115D stack[-3] // @115E stack[-2] // @115F stack[-1] // } 1158 5B JUMPDEST 1159 61 PUSH2 0x1164 115C 84 DUP5 115D 84 DUP5 115E 84 DUP5 115F 84 DUP5 1160 61 PUSH2 0x19e8 1163 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1159 stack[0] = 0x1164 // @115C stack[1] = stack[-4] // @115D stack[2] = stack[-3] // @115E stack[3] = stack[-2] // @115F stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x19e8 label_1164: // Incoming jump from 0x2266, if !(stack[-1] > stack[-4]) // Inputs[1] { @1169 stack[-5] } 1164 5B JUMPDEST 1165 50 POP 1166 50 POP 1167 50 POP 1168 50 POP 1169 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_116A: // Incoming jump from 0x045E // Inputs[1] { @1172 stack[-1] } 116A 5B JUMPDEST 116B 60 PUSH1 0x60 116D 60 PUSH1 0x0e 116F 61 PUSH2 0x1177 1172 83 DUP4 1173 61 PUSH2 0x1a8b 1176 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @116B stack[0] = 0x60 // @116D stack[1] = 0x0e // @116F stack[2] = 0x1177 // @1172 stack[3] = stack[-1] // } // Block ends with call to 0x1a8b, returns to 0x1177 label_1177: // Incoming return from call to 0x1A8B at 0x1176 // Inputs[3] // { // @117A memory[0x40:0x60] // @1181 stack[-2] // @1182 stack[-1] // } 1177 5B JUMPDEST 1178 60 PUSH1 0x40 117A 51 MLOAD 117B 60 PUSH1 0x20 117D 01 ADD 117E 61 PUSH2 0x1188 1181 92 SWAP3 1182 91 SWAP2 1183 90 SWAP1 1184 61 PUSH2 0x266c 1187 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1181 stack[-2] = 0x1188 // @1182 stack[-1] = stack[-2] // @1183 stack[1] = 0x20 + memory[0x40:0x60] // @1183 stack[0] = stack[-1] // } // Block ends with call to 0x266c, returns to 0x1188 label_1188: // Incoming return from call to 0x266C at 0x1187 // Inputs[5] // { // @118B memory[0x40:0x60] // @118F stack[-1] // @1198 stack[-2] // @119A stack[-4] // @119B stack[-3] // } 1188 5B JUMPDEST 1189 60 PUSH1 0x40 118B 51 MLOAD 118C 60 PUSH1 0x20 118E 81 DUP2 118F 83 DUP4 1190 03 SUB 1191 03 SUB 1192 81 DUP2 1193 52 MSTORE 1194 90 SWAP1 1195 60 PUSH1 0x40 1197 52 MSTORE 1198 90 SWAP1 1199 50 POP 119A 91 SWAP2 119B 90 SWAP1 119C 50 POP 119D 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1193 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @1197 memory[0x40:0x60] = stack[-1] // @119A stack[-4] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-4] label_119E: // Incoming jump from 0x04D4 // Inputs[2] // { // @11A1 storage[0x0a] // @11B8 msg.sender // } 119E 5B JUMPDEST 119F 60 PUSH1 0x0a 11A1 54 SLOAD 11A2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11B7 16 AND 11B8 33 CALLER 11B9 14 EQ 11BA 61 PUSH2 0x121f 11BD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x121f, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] label_11BE: // Incoming jump from 0x11BD, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] // Inputs[1] { @11C0 memory[0x40:0x60] } 11BE 60 PUSH1 0x40 11C0 51 MLOAD 11C1 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 11E2 81 DUP2 11E3 52 MSTORE 11E4 60 PUSH1 0x20 11E6 60 PUSH1 0x04 11E8 82 DUP3 11E9 01 ADD 11EA 81 DUP2 11EB 90 SWAP1 11EC 52 MSTORE 11ED 60 PUSH1 0x24 11EF 82 DUP3 11F0 01 ADD 11F1 52 MSTORE 11F2 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1213 60 PUSH1 0x44 1215 82 DUP3 1216 01 ADD 1217 52 MSTORE 1218 60 PUSH1 0x64 121A 01 ADD 121B 61 PUSH2 0x0625 121E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @11E3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @11EC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11F1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1217 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @121A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_121F: // Incoming jump from 0x11BD, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] // Inputs[1] { @1235 stack[-1] } 121F 5B JUMPDEST 1220 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1235 81 DUP2 1236 16 AND 1237 61 PUSH2 0x12c2 123A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12c2, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff label_123B: // Incoming jump from 0x123A, if not stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @123D memory[0x40:0x60] } 123B 60 PUSH1 0x40 123D 51 MLOAD 123E 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 125F 81 DUP2 1260 52 MSTORE 1261 60 PUSH1 0x20 1263 60 PUSH1 0x04 1265 82 DUP3 1266 01 ADD 1267 52 MSTORE 1268 60 PUSH1 0x26 126A 60 PUSH1 0x24 126C 82 DUP3 126D 01 ADD 126E 52 MSTORE 126F 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 1290 60 PUSH1 0x44 1292 82 DUP3 1293 01 ADD 1294 52 MSTORE 1295 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 12B6 60 PUSH1 0x64 12B8 82 DUP3 12B9 01 ADD 12BA 52 MSTORE 12BB 60 PUSH1 0x84 12BD 01 ADD 12BE 61 PUSH2 0x0625 12C1 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1260 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1267 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @126E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1294 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @12BA memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // @12BD stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_12C2: // Incoming jump from 0x123A, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @12C6 stack[-1] } 12C2 5B JUMPDEST 12C3 61 PUSH2 0x0ab3 12C6 81 DUP2 12C7 61 PUSH2 0x17a3 12CA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @12C3 stack[0] = 0x0ab3 // @12C6 stack[1] = stack[-1] // } // Block ends with call to 0x17a3, returns to 0x0AB3 label_12CB: // Incoming call from 0x04DF, returns to 0x04E0 // Inputs[1] { @12EF stack[-1] } 12CB 5B JUMPDEST 12CC 60 PUSH1 0x00 12CE 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 12EF 82 DUP3 12F0 16 AND 12F1 7F PUSH32 0x780e9d6300000000000000000000000000000000000000000000000000000000 1312 14 EQ 1313 80 DUP1 1314 61 PUSH2 0x04e0 1317 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @12CC stack[0] = 0x00 // @1312 stack[1] = 0x780e9d6300000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x04e0, if 0x780e9d6300000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_1318: // Incoming jump from 0x1317, if not 0x780e9d6300000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @131C stack[-3] } 1318 50 POP 1319 61 PUSH2 0x04e0 131C 82 DUP3 131D 61 PUSH2 0x1bbd 1320 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1319 stack[-1] = 0x04e0 // @131C stack[0] = stack[-3] // } // Block ends with call to 0x1bbd, returns to 0x04E0 label_1321: // Incoming call from 0x07DE, returns to 0x07DF // Inputs[4] // { // @1324 stack[-1] // @132F memory[0x00:0x40] // @1331 storage[keccak256(memory[0x00:0x40])] // @1369 stack[-2] // } 1321 5B JUMPDEST 1322 60 PUSH1 0x00 1324 81 DUP2 1325 81 DUP2 1326 52 MSTORE 1327 60 PUSH1 0x04 1329 60 PUSH1 0x20 132B 52 MSTORE 132C 60 PUSH1 0x40 132E 90 SWAP1 132F 20 SHA3 1330 80 DUP1 1331 54 SLOAD 1332 7F PUSH32 0xffffffffffffffffffffffff0000000000000000000000000000000000000000 1353 16 AND 1354 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1369 84 DUP5 136A 16 AND 136B 90 SWAP1 136C 81 DUP2 136D 17 OR 136E 90 SWAP1 136F 91 SWAP2 1370 55 SSTORE 1371 81 DUP2 1372 90 SWAP1 1373 61 PUSH2 0x137b 1376 82 DUP3 1377 61 PUSH2 0x0c23 137A 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @1326 memory[0x00:0x20] = stack[-1] // @132B memory[0x20:0x40] = 0x04 // @1370 storage[keccak256(memory[0x00:0x40])] = (stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & storage[keccak256(memory[0x00:0x40])]) // @1372 stack[0] = stack[-1] // @1372 stack[1] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @1373 stack[2] = 0x137b // @1376 stack[3] = stack[-1] // } // Block ends with call to 0x0c23, returns to 0x137B label_137B: // Incoming return from call to 0x0C23 at 0x137A // Inputs[7] // { // @1391 stack[-1] // @13B5 memory[0x40:0x60] // @13B8 memory[0x40:0x60] // @13BD stack[-2] // @13BD memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @13BD stack[-3] // @13C0 stack[-6] // } 137B 5B JUMPDEST 137C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1391 16 AND 1392 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 13B3 60 PUSH1 0x40 13B5 51 MLOAD 13B6 60 PUSH1 0x40 13B8 51 MLOAD 13B9 80 DUP1 13BA 91 SWAP2 13BB 03 SUB 13BC 90 SWAP1 13BD A4 LOG4 13BE 50 POP 13BF 50 POP 13C0 56 *JUMP // Stack delta = -6 // Outputs[1] { @13BD log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2], stack[-3]]); } // Block ends with unconditional jump to stack[-6] label_13C1: // Incoming call from 0x10CB, returns to 0x10CC // Incoming call from 0x07ED, returns to 0x07EE // Inputs[3] // { // @13C4 stack[-1] // @13CF memory[0x00:0x40] // @13D0 storage[keccak256(memory[0x00:0x40])] // } 13C1 5B JUMPDEST 13C2 60 PUSH1 0x00 13C4 81 DUP2 13C5 81 DUP2 13C6 52 MSTORE 13C7 60 PUSH1 0x02 13C9 60 PUSH1 0x20 13CB 52 MSTORE 13CC 60 PUSH1 0x40 13CE 81 DUP2 13CF 20 SHA3 13D0 54 SLOAD 13D1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13E6 16 AND 13E7 61 PUSH2 0x1472 13EA 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @13C2 stack[0] = 0x00 // @13C6 memory[0x00:0x20] = stack[-1] // @13CB memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x1472, if 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] label_13EB: // Incoming jump from 0x13EA, if not 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @13ED memory[0x40:0x60] } 13EB 60 PUSH1 0x40 13ED 51 MLOAD 13EE 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 140F 81 DUP2 1410 52 MSTORE 1411 60 PUSH1 0x20 1413 60 PUSH1 0x04 1415 82 DUP3 1416 01 ADD 1417 52 MSTORE 1418 60 PUSH1 0x2c 141A 60 PUSH1 0x24 141C 82 DUP3 141D 01 ADD 141E 52 MSTORE 141F 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 1440 60 PUSH1 0x44 1442 82 DUP3 1443 01 ADD 1444 52 MSTORE 1445 7F PUSH32 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 1466 60 PUSH1 0x64 1468 82 DUP3 1469 01 ADD 146A 52 MSTORE 146B 60 PUSH1 0x84 146D 01 ADD 146E 61 PUSH2 0x0625 1471 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1410 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1417 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @141E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @1444 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 // @146A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 // @146D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_1472: // Incoming jump from 0x13EA, if 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1478 stack[-2] } 1472 5B JUMPDEST 1473 60 PUSH1 0x00 1475 61 PUSH2 0x147d 1478 83 DUP4 1479 61 PUSH2 0x0c23 147C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1473 stack[0] = 0x00 // @1475 stack[1] = 0x147d // @1478 stack[2] = stack[-2] // } // Block ends with call to 0x0c23, returns to 0x147D label_147D: // Incoming return from call to 0x0C23 at 0x147C // Inputs[3] // { // @147E stack[-1] // @147E stack[-2] // @1497 stack[-5] // } 147D 5B JUMPDEST 147E 90 SWAP1 147F 50 POP 1480 80 DUP1 1481 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1496 16 AND 1497 84 DUP5 1498 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14AD 16 AND 14AE 14 EQ 14AF 80 DUP1 14B0 61 PUSH2 0x14ec 14B3 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @147E stack[-2] = stack[-1] // @14AE stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // } // Block ends with conditional jump to 0x14ec, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] label_14B4: // Incoming jump from 0x14B3, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[2] // { // @14B5 stack[-5] // @14CF stack[-4] // } 14B4 50 POP 14B5 83 DUP4 14B6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14CB 16 AND 14CC 61 PUSH2 0x14d4 14CF 84 DUP5 14D0 61 PUSH2 0x0578 14D3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @14CB stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @14CC stack[0] = 0x14d4 // @14CF stack[1] = stack[-4] // } // Block ends with call to 0x0578, returns to 0x14D4 label_14D4: // Incoming return from call to 0x0578 at 0x14D3 // Inputs[2] // { // @14EA stack[-1] // @14EB stack[-2] // } 14D4 5B JUMPDEST 14D5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14EA 16 AND 14EB 14 EQ // Stack delta = -1 // Outputs[1] { @14EB stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block continues label_14EC: // Incoming jump from 0x14B3, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Incoming jump from 0x14EB // Inputs[1] { @14ED stack[-1] } 14EC 5B JUMPDEST 14ED 80 DUP1 14EE 61 PUSH2 0x1529 14F1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1529, if stack[-1] label_14F2: // Incoming jump from 0x14F1, if not stack[-1] // Inputs[5] // { // @1509 stack[-2] // @151B memory[0x00:0x40] // @151D stack[-5] // @1524 memory[0x00:0x40] // @1525 storage[keccak256(memory[0x00:0x40])] // } 14F2 50 POP 14F3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1508 80 DUP1 1509 82 DUP3 150A 16 AND 150B 60 PUSH1 0x00 150D 90 SWAP1 150E 81 DUP2 150F 52 MSTORE 1510 60 PUSH1 0x05 1512 60 PUSH1 0x20 1514 90 SWAP1 1515 81 DUP2 1516 52 MSTORE 1517 60 PUSH1 0x40 1519 80 DUP1 151A 83 DUP4 151B 20 SHA3 151C 93 SWAP4 151D 88 DUP9 151E 16 AND 151F 83 DUP4 1520 52 MSTORE 1521 92 SWAP3 1522 90 SWAP1 1523 52 MSTORE 1524 20 SHA3 1525 54 SLOAD 1526 60 PUSH1 0xff 1528 16 AND // Stack delta = +0 // Outputs[5] // { // @150F memory[0x00:0x20] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @1516 memory[0x20:0x40] = 0x05 // @1520 memory[0x00:0x20] = stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff // @1523 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1528 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block continues label_1529: // Incoming jump from 0x1B44, if !stack[-7] // Incoming jump from 0x1B44, if !stack[-5] // Incoming return from call to 0x23A3 at 0x247F // Incoming jump from 0x1B44, if !stack[-7] // Incoming jump from 0x1528 // Incoming jump from 0x14F1, if stack[-1] // Inputs[3] // { // @152A stack[-1] // @152A stack[-6] // @152B stack[-5] // } 1529 5B JUMPDEST 152A 94 SWAP5 152B 93 SWAP4 152C 50 POP 152D 50 POP 152E 50 POP 152F 50 POP 1530 56 *JUMP // Stack delta = -5 // Outputs[1] { @152A stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1531: // Incoming jump from 0x0884 // Incoming jump from 0x19F2 // Inputs[2] // { // @1532 stack[-3] // @154C stack[-1] // } 1531 5B JUMPDEST 1532 82 DUP3 1533 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1548 16 AND 1549 61 PUSH2 0x1551 154C 82 DUP3 154D 61 PUSH2 0x0c23 1550 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1548 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1549 stack[1] = 0x1551 // @154C stack[2] = stack[-1] // } // Block ends with call to 0x0c23, returns to 0x1551 label_1551: // Incoming return from call to 0x0C23 at 0x1550 // Inputs[2] // { // @1567 stack[-1] // @1568 stack[-2] // } 1551 5B JUMPDEST 1552 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1567 16 AND 1568 14 EQ 1569 61 PUSH2 0x15f4 156C 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x15f4, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_156D: // Incoming jump from 0x156C, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @156F memory[0x40:0x60] } 156D 60 PUSH1 0x40 156F 51 MLOAD 1570 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1591 81 DUP2 1592 52 MSTORE 1593 60 PUSH1 0x20 1595 60 PUSH1 0x04 1597 82 DUP3 1598 01 ADD 1599 52 MSTORE 159A 60 PUSH1 0x29 159C 60 PUSH1 0x24 159E 82 DUP3 159F 01 ADD 15A0 52 MSTORE 15A1 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 15C2 60 PUSH1 0x44 15C4 82 DUP3 15C5 01 ADD 15C6 52 MSTORE 15C7 7F PUSH32 0x73206e6f74206f776e0000000000000000000000000000000000000000000000 15E8 60 PUSH1 0x64 15EA 82 DUP3 15EB 01 ADD 15EC 52 MSTORE 15ED 60 PUSH1 0x84 15EF 01 ADD 15F0 61 PUSH2 0x0625 15F3 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1592 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1599 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @15A0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @15C6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 // @15EC memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x73206e6f74206f776e0000000000000000000000000000000000000000000000 // @15EF stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_15F4: // Incoming jump from 0x156C, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @160A stack[-2] } 15F4 5B JUMPDEST 15F5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 160A 82 DUP3 160B 16 AND 160C 61 PUSH2 0x1696 160F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1696, if stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff label_1610: // Incoming jump from 0x160F, if not stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @1612 memory[0x40:0x60] } 1610 60 PUSH1 0x40 1612 51 MLOAD 1613 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1634 81 DUP2 1635 52 MSTORE 1636 60 PUSH1 0x20 1638 60 PUSH1 0x04 163A 82 DUP3 163B 01 ADD 163C 52 MSTORE 163D 60 PUSH1 0x24 163F 80 DUP1 1640 82 DUP3 1641 01 ADD 1642 52 MSTORE 1643 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 1664 60 PUSH1 0x44 1666 82 DUP3 1667 01 ADD 1668 52 MSTORE 1669 7F PUSH32 0x7265737300000000000000000000000000000000000000000000000000000000 168A 60 PUSH1 0x64 168C 82 DUP3 168D 01 ADD 168E 52 MSTORE 168F 60 PUSH1 0x84 1691 01 ADD 1692 61 PUSH2 0x0625 1695 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1635 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @163C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1642 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @1668 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 // @168E memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7265737300000000000000000000000000000000000000000000000000000000 // @1691 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_1696: // Incoming jump from 0x160F, if stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[3] // { // @169A stack[-3] // @169B stack[-2] // @169C stack[-1] // } 1696 5B JUMPDEST 1697 61 PUSH2 0x16a1 169A 83 DUP4 169B 83 DUP4 169C 83 DUP4 169D 61 PUSH2 0x1ca0 16A0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1697 stack[0] = 0x16a1 // @169A stack[1] = stack[-3] // @169B stack[2] = stack[-2] // @169C stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1ca0 16A1 5B JUMPDEST 16A2 61 PUSH2 0x16ac 16A5 60 PUSH1 0x00 16A7 82 DUP3 16A8 61 PUSH2 0x1321 16AB 56 *JUMP 16AC 5B JUMPDEST 16AD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16C2 83 DUP4 16C3 16 AND 16C4 60 PUSH1 0x00 16C6 90 SWAP1 16C7 81 DUP2 16C8 52 MSTORE 16C9 60 PUSH1 0x03 16CB 60 PUSH1 0x20 16CD 52 MSTORE 16CE 60 PUSH1 0x40 16D0 81 DUP2 16D1 20 SHA3 16D2 80 DUP1 16D3 54 SLOAD 16D4 60 PUSH1 0x01 16D6 92 SWAP3 16D7 90 SWAP1 16D8 61 PUSH2 0x16e2 16DB 90 SWAP1 16DC 84 DUP5 16DD 90 SWAP1 16DE 61 PUSH2 0x274a 16E1 56 *JUMP 16E2 5B JUMPDEST 16E3 90 SWAP1 16E4 91 SWAP2 16E5 55 SSTORE 16E6 50 POP 16E7 50 POP 16E8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16FD 82 DUP3 16FE 16 AND 16FF 60 PUSH1 0x00 1701 90 SWAP1 1702 81 DUP2 1703 52 MSTORE 1704 60 PUSH1 0x03 1706 60 PUSH1 0x20 1708 52 MSTORE 1709 60 PUSH1 0x40 170B 81 DUP2 170C 20 SHA3 170D 80 DUP1 170E 54 SLOAD 170F 60 PUSH1 0x01 1711 92 SWAP3 1712 90 SWAP1 1713 61 PUSH2 0x171d 1716 90 SWAP1 1717 84 DUP5 1718 90 SWAP1 1719 61 PUSH2 0x2638 171C 56 *JUMP 171D 5B JUMPDEST 171E 90 SWAP1 171F 91 SWAP2 1720 55 SSTORE 1721 50 POP 1722 50 POP 1723 60 PUSH1 0x00 1725 81 DUP2 1726 81 DUP2 1727 52 MSTORE 1728 60 PUSH1 0x02 172A 60 PUSH1 0x20 172C 52 MSTORE 172D 60 PUSH1 0x40 172F 80 DUP1 1730 82 DUP3 1731 20 SHA3 1732 80 DUP1 1733 54 SLOAD 1734 7F PUSH32 0xffffffffffffffffffffffff0000000000000000000000000000000000000000 1755 16 AND 1756 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 176B 86 DUP7 176C 81 DUP2 176D 16 AND 176E 91 SWAP2 176F 82 DUP3 1770 17 OR 1771 90 SWAP1 1772 92 SWAP3 1773 55 SSTORE 1774 91 SWAP2 1775 51 MLOAD 1776 84 DUP5 1777 93 SWAP4 1778 91 SWAP2 1779 87 DUP8 177A 16 AND 177B 91 SWAP2 177C 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 179D 91 SWAP2 179E A4 LOG4 179F 50 POP 17A0 50 POP 17A1 50 POP 17A2 56 *JUMP label_17A3: // Incoming call from 0x0E3C, returns to 0x0E3D // Incoming call from 0x12CA, returns to 0x0AB3 // Inputs[5] // { // @17A7 storage[0x0a] // @17BD stack[-1] // @17EA memory[0x40:0x60] // @1816 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1819 stack[-2] // } 17A3 5B JUMPDEST 17A4 60 PUSH1 0x0a 17A6 80 DUP1 17A7 54 SLOAD 17A8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17BD 83 DUP4 17BE 81 DUP2 17BF 16 AND 17C0 7F PUSH32 0xffffffffffffffffffffffff0000000000000000000000000000000000000000 17E1 83 DUP4 17E2 16 AND 17E3 81 DUP2 17E4 17 OR 17E5 90 SWAP1 17E6 93 SWAP4 17E7 55 SSTORE 17E8 60 PUSH1 0x40 17EA 51 MLOAD 17EB 91 SWAP2 17EC 16 AND 17ED 91 SWAP2 17EE 90 SWAP1 17EF 82 DUP3 17F0 90 SWAP1 17F1 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1812 90 SWAP1 1813 60 PUSH1 0x00 1815 90 SWAP1 1816 A3 LOG3 1817 50 POP 1818 50 POP 1819 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @17E7 storage[0x0a] = (stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[0x0a] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000) // @1816 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0a] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-2] label_181A: // Incoming jump from 0x0FAA // Inputs[1] { @1830 stack[-2] } 181A 5B JUMPDEST 181B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1830 82 DUP3 1831 16 AND 1832 61 PUSH2 0x1897 1835 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1897, if stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff label_1836: // Incoming jump from 0x1835, if not stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @1838 memory[0x40:0x60] } 1836 60 PUSH1 0x40 1838 51 MLOAD 1839 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 185A 81 DUP2 185B 52 MSTORE 185C 60 PUSH1 0x20 185E 60 PUSH1 0x04 1860 82 DUP3 1861 01 ADD 1862 81 DUP2 1863 90 SWAP1 1864 52 MSTORE 1865 60 PUSH1 0x24 1867 82 DUP3 1868 01 ADD 1869 52 MSTORE 186A 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 188B 60 PUSH1 0x44 188D 82 DUP3 188E 01 ADD 188F 52 MSTORE 1890 60 PUSH1 0x64 1892 01 ADD 1893 61 PUSH2 0x0625 1896 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @185B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1864 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1869 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @188F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 // @1892 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_1897: // Incoming jump from 0x1835, if stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[3] // { // @189A stack[-1] // @18A5 memory[0x00:0x40] // @18A6 storage[keccak256(memory[0x00:0x40])] // } 1897 5B JUMPDEST 1898 60 PUSH1 0x00 189A 81 DUP2 189B 81 DUP2 189C 52 MSTORE 189D 60 PUSH1 0x02 189F 60 PUSH1 0x20 18A1 52 MSTORE 18A2 60 PUSH1 0x40 18A4 90 SWAP1 18A5 20 SHA3 18A6 54 SLOAD 18A7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18BC 16 AND 18BD 15 ISZERO 18BE 61 PUSH2 0x1923 18C1 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @189C memory[0x00:0x20] = stack[-1] // @18A1 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x1923, if !(0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) label_18C2: // Incoming jump from 0x18C1, if not !(0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @18C4 memory[0x40:0x60] } 18C2 60 PUSH1 0x40 18C4 51 MLOAD 18C5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 18E6 81 DUP2 18E7 52 MSTORE 18E8 60 PUSH1 0x20 18EA 60 PUSH1 0x04 18EC 82 DUP3 18ED 01 ADD 18EE 52 MSTORE 18EF 60 PUSH1 0x1c 18F1 60 PUSH1 0x24 18F3 82 DUP3 18F4 01 ADD 18F5 52 MSTORE 18F6 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 1917 60 PUSH1 0x44 1919 82 DUP3 191A 01 ADD 191B 52 MSTORE 191C 60 PUSH1 0x64 191E 01 ADD 191F 61 PUSH2 0x0625 1922 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @18E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @18EE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @18F5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1c // @191B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 // @191E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0625 label_1923: // Incoming jump from 0x18C1, if !(0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @1929 stack[-2] // @192A stack[-1] // } 1923 5B JUMPDEST 1924 61 PUSH2 0x192f 1927 60 PUSH1 0x00 1929 83 DUP4 192A 83 DUP4 192B 61 PUSH2 0x1ca0 192E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1924 stack[0] = 0x192f // @1927 stack[1] = 0x00 // @1929 stack[2] = stack[-2] // @192A stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1ca0 192F 5B JUMPDEST 1930 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1945 82 DUP3 1946 16 AND 1947 60 PUSH1 0x00 1949 90 SWAP1 194A 81 DUP2 194B 52 MSTORE 194C 60 PUSH1 0x03 194E 60 PUSH1 0x20 1950 52 MSTORE 1951 60 PUSH1 0x40 1953 81 DUP2 1954 20 SHA3 1955 80 DUP1 1956 54 SLOAD 1957 60 PUSH1 0x01 1959 92 SWAP3 195A 90 SWAP1 195B 61 PUSH2 0x1965 195E 90 SWAP1 195F 84 DUP5 1960 90 SWAP1 1961 61 PUSH2 0x2638 1964 56 *JUMP 1965 5B JUMPDEST 1966 90 SWAP1 1967 91 SWAP2 1968 55 SSTORE 1969 50 POP 196A 50 POP 196B 60 PUSH1 0x00 196D 81 DUP2 196E 81 DUP2 196F 52 MSTORE 1970 60 PUSH1 0x02 1972 60 PUSH1 0x20 1974 52 MSTORE 1975 60 PUSH1 0x40 1977 80 DUP1 1978 82 DUP3 1979 20 SHA3 197A 80 DUP1 197B 54 SLOAD 197C 7F PUSH32 0xffffffffffffffffffffffff0000000000000000000000000000000000000000 199D 16 AND 199E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19B3 86 DUP7 19B4 16 AND 19B5 90 SWAP1 19B6 81 DUP2 19B7 17 OR 19B8 90 SWAP1 19B9 91 SWAP2 19BA 55 SSTORE 19BB 90 SWAP1 19BC 51 MLOAD 19BD 83 DUP4 19BE 92 SWAP3 19BF 90 SWAP1 19C0 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 19E1 90 SWAP1 19E2 82 DUP3 19E3 90 SWAP1 19E4 A4 LOG4 19E5 50 POP 19E6 50 POP 19E7 56 *JUMP label_19E8: // Incoming jump from 0x1163 // Inputs[3] // { // @19EC stack[-4] // @19ED stack[-3] // @19EE stack[-2] // } 19E8 5B JUMPDEST 19E9 61 PUSH2 0x19f3 19EC 84 DUP5 19ED 84 DUP5 19EE 84 DUP5 19EF 61 PUSH2 0x1531 19F2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @19E9 stack[0] = 0x19f3 // @19EC stack[1] = stack[-4] // @19ED stack[2] = stack[-3] // @19EE stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1531 19F3 5B JUMPDEST 19F4 61 PUSH2 0x19ff 19F7 84 DUP5 19F8 84 DUP5 19F9 84 DUP5 19FA 84 DUP5 19FB 61 PUSH2 0x1cab 19FE 56 *JUMP 19FF 5B JUMPDEST 1A00 61 PUSH2 0x1164 1A03 57 *JUMPI 1A04 60 PUSH1 0x40 1A06 51 MLOAD 1A07 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1A28 81 DUP2 1A29 52 MSTORE 1A2A 60 PUSH1 0x20 1A2C 60 PUSH1 0x04 1A2E 82 DUP3 1A2F 01 ADD 1A30 52 MSTORE 1A31 60 PUSH1 0x32 1A33 60 PUSH1 0x24 1A35 82 DUP3 1A36 01 ADD 1A37 52 MSTORE 1A38 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 1A59 60 PUSH1 0x44 1A5B 82 DUP3 1A5C 01 ADD 1A5D 52 MSTORE 1A5E 7F PUSH32 0x63656976657220696d706c656d656e7465720000000000000000000000000000 1A7F 60 PUSH1 0x64 1A81 82 DUP3 1A82 01 ADD 1A83 52 MSTORE 1A84 60 PUSH1 0x84 1A86 01 ADD 1A87 61 PUSH2 0x0625 1A8A 56 *JUMP label_1A8B: // Incoming call from 0x1176, returns to 0x1177 // Inputs[1] { @1A8E stack[-1] } 1A8B 5B JUMPDEST 1A8C 60 PUSH1 0x60 1A8E 81 DUP2 1A8F 61 PUSH2 0x1acb 1A92 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A8C stack[0] = 0x60 } // Block ends with conditional jump to 0x1acb, if stack[-1] label_1A93: // Incoming jump from 0x1A92, if not stack[-1] // Inputs[2] // { // @1A98 memory[0x40:0x60] // @1AC9 stack[-3] // } 1A93 50 POP 1A94 50 POP 1A95 60 PUSH1 0x40 1A97 80 DUP1 1A98 51 MLOAD 1A99 80 DUP1 1A9A 82 DUP3 1A9B 01 ADD 1A9C 90 SWAP1 1A9D 91 SWAP2 1A9E 52 MSTORE 1A9F 60 PUSH1 0x01 1AA1 81 DUP2 1AA2 52 MSTORE 1AA3 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 1AC4 60 PUSH1 0x20 1AC6 82 DUP3 1AC7 01 ADD 1AC8 52 MSTORE 1AC9 90 SWAP1 1ACA 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @1A9E memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1AA2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @1AC8 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x3000000000000000000000000000000000000000000000000000000000000000 // @1AC9 stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_1ACB: // Incoming jump from 0x1A92, if stack[-1] // Inputs[1] { @1ACC stack[-2] } 1ACB 5B JUMPDEST 1ACC 81 DUP2 1ACD 60 PUSH1 0x00 1ACF 5B JUMPDEST 1AD0 81 DUP2 1AD1 15 ISZERO 1AD2 61 PUSH2 0x1af5 1AD5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1ACC stack[0] = stack[-2] // @1ACD stack[1] = 0x00 // } // Block ends with conditional jump to 0x1af5, if !stack[-2] label_1AD6: // Incoming jump from 0x1AD5, if not !stack[-2] // Incoming jump from 0x1AD5, if not !stack[-2] // Inputs[1] { @1AD6 stack[-1] } 1AD6 80 DUP1 1AD7 61 PUSH2 0x1adf 1ADA 81 DUP2 1ADB 61 PUSH2 0x2761 1ADE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1AD6 stack[0] = stack[-1] // @1AD7 stack[1] = 0x1adf // @1ADA stack[2] = stack[-1] // } // Block ends with call to 0x2761, returns to 0x1ADF label_1ADF: // Incoming return from call to 0x2761 at 0x1ADE // Inputs[4] // { // @1AE0 stack[-3] // @1AE0 stack[-1] // @1AE5 stack[-2] // @1AE9 stack[-4] // } 1ADF 5B JUMPDEST 1AE0 91 SWAP2 1AE1 50 POP 1AE2 61 PUSH2 0x1aee 1AE5 90 SWAP1 1AE6 50 POP 1AE7 60 PUSH1 0x0a 1AE9 83 DUP4 1AEA 61 PUSH2 0x27c9 1AED 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1AE0 stack[-3] = stack[-1] // @1AE5 stack[-2] = 0x1aee // @1AE7 stack[-1] = 0x0a // @1AE9 stack[0] = stack[-4] // } // Block ends with call to 0x27c9, returns to 0x1AEE label_1AEE: // Incoming return from call to 0x27C9 at 0x1AED // Inputs[2] // { // @1AEF stack[-1] // @1AEF stack[-3] // } 1AEE 5B JUMPDEST 1AEF 91 SWAP2 1AF0 50 POP 1AF1 61 PUSH2 0x1acf 1AF4 56 *JUMP // Stack delta = -1 // Outputs[1] { @1AEF stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1acf label_1AF5: // Incoming jump from 0x1AD5, if !stack[-2] // Incoming jump from 0x1AD5, if !stack[-2] // Inputs[1] { @1AF8 stack[-1] } 1AF5 5B JUMPDEST 1AF6 60 PUSH1 0x00 1AF8 81 DUP2 1AF9 67 PUSH8 0xffffffffffffffff 1B02 81 DUP2 1B03 11 GT 1B04 15 ISZERO 1B05 61 PUSH2 0x1b10 1B08 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1AF6 stack[0] = 0x00 // @1AF8 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1b10, if !(stack[-1] > 0xffffffffffffffff) label_1B09: // Incoming jump from 0x1B08, if not !(stack[-1] > 0xffffffffffffffff) 1B09 61 PUSH2 0x1b10 1B0C 61 PUSH2 0x2374 1B0F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B09 stack[0] = 0x1b10 } // Block ends with unconditional jump to 0x2374 label_1B10: // Incoming jump from 0x1B08, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @1B13 memory[0x40:0x60] // @1B14 stack[-1] // } 1B10 5B JUMPDEST 1B11 60 PUSH1 0x40 1B13 51 MLOAD 1B14 90 SWAP1 1B15 80 DUP1 1B16 82 DUP3 1B17 52 MSTORE 1B18 80 DUP1 1B19 60 PUSH1 0x1f 1B1B 01 ADD 1B1C 60 PUSH1 0x1f 1B1E 19 NOT 1B1F 16 AND 1B20 60 PUSH1 0x20 1B22 01 ADD 1B23 82 DUP3 1B24 01 ADD 1B25 60 PUSH1 0x40 1B27 52 MSTORE 1B28 80 DUP1 1B29 15 ISZERO 1B2A 61 PUSH2 0x1b3a 1B2D 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1B14 stack[-1] = memory[0x40:0x60] // @1B14 stack[0] = stack[-1] // @1B17 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1B27 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x1b3a, if !stack[-1] label_1B2E: // Incoming jump from 0x1B2D, if not !stack[-1] // Inputs[6] // { // @1B30 stack[-2] // @1B32 stack[-1] // @1B34 msg.data.length // @1B36 msg.data[msg.data.length:msg.data.length + stack[-1]] // @1B3C stack[-3] // @1B3F stack[-7] // } 1B2E 60 PUSH1 0x20 1B30 82 DUP3 1B31 01 ADD 1B32 81 DUP2 1B33 80 DUP1 1B34 36 CALLDATASIZE 1B35 83 DUP4 1B36 37 CALLDATACOPY 1B37 01 ADD 1B38 90 SWAP1 1B39 50 POP 1B3A 5B JUMPDEST 1B3B 50 POP 1B3C 90 SWAP1 1B3D 50 POP 1B3E 5B JUMPDEST 1B3F 84 DUP5 1B40 15 ISZERO 1B41 61 PUSH2 0x1529 1B44 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1B36 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @1B3C stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x1529, if !stack[-7] label_1B45: // Incoming jump from 0x1B44, if not !stack[-7] // Incoming jump from 0x1B44, if not !stack[-7] // Incoming jump from 0x1B44, if not !stack[-5] // Inputs[1] { @1B4A stack[-2] } 1B45 61 PUSH2 0x1b4f 1B48 60 PUSH1 0x01 1B4A 83 DUP4 1B4B 61 PUSH2 0x274a 1B4E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B45 stack[0] = 0x1b4f // @1B48 stack[1] = 0x01 // @1B4A stack[2] = stack[-2] // } // Block ends with call to 0x274a, returns to 0x1B4F label_1B4F: // Incoming return from call to 0x274A at 0x1B4E // Inputs[3] // { // @1B50 stack[-1] // @1B50 stack[-3] // @1B57 stack[-6] // } 1B4F 5B JUMPDEST 1B50 91 SWAP2 1B51 50 POP 1B52 61 PUSH2 0x1b5c 1B55 60 PUSH1 0x0a 1B57 86 DUP7 1B58 61 PUSH2 0x27dd 1B5B 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1B50 stack[-3] = stack[-1] // @1B52 stack[-1] = 0x1b5c // @1B55 stack[0] = 0x0a // @1B57 stack[1] = stack[-6] // } // Block ends with call to 0x27dd, returns to 0x1B5C label_1B5C: // Incoming return from call to 0x27DD at 0x1B5B // Inputs[1] { @1B60 stack[-1] } 1B5C 5B JUMPDEST 1B5D 61 PUSH2 0x1b67 1B60 90 SWAP1 1B61 60 PUSH1 0x30 1B63 61 PUSH2 0x2638 1B66 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1B60 stack[0] = stack[-1] // @1B60 stack[-1] = 0x1b67 // @1B61 stack[1] = 0x30 // } // Block ends with call to 0x2638, returns to 0x1B67 label_1B67: // Incoming return from call to 0x2638 at 0x1B66 // Inputs[4] // { // @1B6A stack[-1] // @1B6B stack[-2] // @1B6C stack[-3] // @1B6E memory[stack[-2]:stack[-2] + 0x20] // } 1B67 5B JUMPDEST 1B68 60 PUSH1 0xf8 1B6A 1B SHL 1B6B 81 DUP2 1B6C 83 DUP4 1B6D 81 DUP2 1B6E 51 MLOAD 1B6F 81 DUP2 1B70 10 LT 1B71 61 PUSH2 0x1b7c 1B74 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1B6A stack[-1] = stack[-1] << 0xf8 // @1B6B stack[0] = stack[-2] // @1B6C stack[1] = stack[-3] // } // Block ends with conditional jump to 0x1b7c, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_1B75: // Incoming jump from 0x1B74, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] 1B75 61 PUSH2 0x1b7c 1B78 61 PUSH2 0x25da 1B7B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B75 stack[0] = 0x1b7c } // Block ends with unconditional jump to 0x25da label_1B7C: // Incoming jump from 0x1B74, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @1B7F stack[-1] // @1B80 stack[-2] // @1B81 stack[-3] // @1BB1 stack[-8] // } 1B7C 5B JUMPDEST 1B7D 60 PUSH1 0x20 1B7F 01 ADD 1B80 01 ADD 1B81 90 SWAP1 1B82 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1BA2 19 NOT 1BA3 16 AND 1BA4 90 SWAP1 1BA5 81 DUP2 1BA6 60 PUSH1 0x00 1BA8 1A BYTE 1BA9 90 SWAP1 1BAA 53 MSTORE8 1BAB 50 POP 1BAC 61 PUSH2 0x1bb6 1BAF 60 PUSH1 0x0a 1BB1 86 DUP7 1BB2 61 PUSH2 0x27c9 1BB5 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1BAA memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @1BAC stack[-3] = 0x1bb6 // @1BAF stack[-2] = 0x0a // @1BB1 stack[-1] = stack[-8] // } // Block ends with call to 0x27c9, returns to 0x1BB6 label_1BB6: // Incoming return from call to 0x27C9 at 0x1BB5 // Inputs[2] // { // @1BB7 stack[-1] // @1BB7 stack[-6] // } 1BB6 5B JUMPDEST 1BB7 94 SWAP5 1BB8 50 POP 1BB9 61 PUSH2 0x1b3e 1BBC 56 *JUMP // Stack delta = -1 // Outputs[1] { @1BB7 stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x1b3e label_1BBD: // Incoming call from 0x1320, returns to 0x04E0 // Inputs[1] { @1BE1 stack[-1] } 1BBD 5B JUMPDEST 1BBE 60 PUSH1 0x00 1BC0 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 1BE1 82 DUP3 1BE2 16 AND 1BE3 7F PUSH32 0x80ac58cd00000000000000000000000000000000000000000000000000000000 1C04 14 EQ 1C05 80 DUP1 1C06 61 PUSH2 0x1c50 1C09 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1BBE stack[0] = 0x00 // @1C04 stack[1] = 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x1c50, if 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_1C0A: // Incoming jump from 0x1C09, if not 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @1C2C stack[-3] } 1C0A 50 POP 1C0B 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 1C2C 82 DUP3 1C2D 16 AND 1C2E 7F PUSH32 0x5b5e139f00000000000000000000000000000000000000000000000000000000 1C4F 14 EQ 1C50 5B JUMPDEST 1C51 80 DUP1 1C52 61 PUSH2 0x04e0 1C55 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1C4F stack[-1] = 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x04e0, if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_1C56: // Incoming jump from 0x1C55, if not 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x1C55, if not stack[-1] // Inputs[1] { @1C99 stack[-3] } 1C56 50 POP 1C57 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 1C78 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 1C99 83 DUP4 1C9A 16 AND 1C9B 14 EQ 1C9C 61 PUSH2 0x04e0 1C9F 56 *JUMP // Stack delta = +0 // Outputs[1] { @1C9B stack[-1] = stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to 0x04e0 label_1CA0: // Incoming jump from 0x16A0 // Incoming jump from 0x192E // Inputs[3] // { // @1CA4 stack[-3] // @1CA5 stack[-2] // @1CA6 stack[-1] // } 1CA0 5B JUMPDEST 1CA1 61 PUSH2 0x07df 1CA4 83 DUP4 1CA5 83 DUP4 1CA6 83 DUP4 1CA7 61 PUSH2 0x1e9b 1CAA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1CA1 stack[0] = 0x07df // @1CA4 stack[1] = stack[-3] // @1CA5 stack[2] = stack[-2] // @1CA6 stack[3] = stack[-1] // } // Block ends with call to 0x1e9b, returns to 0x07DF 1CAB 5B JUMPDEST 1CAC 60 PUSH1 0x00 1CAE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CC3 84 DUP5 1CC4 16 AND 1CC5 3B EXTCODESIZE 1CC6 15 ISZERO 1CC7 61 PUSH2 0x1e90 1CCA 57 *JUMPI 1CCB 60 PUSH1 0x40 1CCD 51 MLOAD 1CCE 7F PUSH32 0x150b7a0200000000000000000000000000000000000000000000000000000000 1CEF 81 DUP2 1CF0 52 MSTORE 1CF1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D06 85 DUP6 1D07 16 AND 1D08 90 SWAP1 1D09 63 PUSH4 0x150b7a02 1D0E 90 SWAP1 1D0F 61 PUSH2 0x1d22 1D12 90 SWAP1 1D13 33 CALLER 1D14 90 SWAP1 1D15 89 DUP10 1D16 90 SWAP1 1D17 88 DUP9 1D18 90 SWAP1 1D19 88 DUP9 1D1A 90 SWAP1 1D1B 60 PUSH1 0x04 1D1D 01 ADD 1D1E 61 PUSH2 0x27f1 1D21 56 *JUMP 1D22 5B JUMPDEST 1D23 60 PUSH1 0x20 1D25 60 PUSH1 0x40 1D27 51 MLOAD 1D28 80 DUP1 1D29 83 DUP4 1D2A 03 SUB 1D2B 81 DUP2 1D2C 60 PUSH1 0x00 1D2E 87 DUP8 1D2F 5A GAS 1D30 F1 CALL 1D31 92 SWAP3 1D32 50 POP 1D33 50 POP 1D34 50 POP 1D35 80 DUP1 1D36 15 ISZERO 1D37 61 PUSH2 0x1d7b 1D3A 57 *JUMPI 1D3B 50 POP 1D3C 60 PUSH1 0x40 1D3E 80 DUP1 1D3F 51 MLOAD 1D40 60 PUSH1 0x1f 1D42 3D RETURNDATASIZE 1D43 90 SWAP1 1D44 81 DUP2 1D45 01 ADD 1D46 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 1D67 16 AND 1D68 82 DUP3 1D69 01 ADD 1D6A 90 SWAP1 1D6B 92 SWAP3 1D6C 52 MSTORE 1D6D 61 PUSH2 0x1d78 1D70 91 SWAP2 1D71 81 DUP2 1D72 01 ADD 1D73 90 SWAP1 1D74 61 PUSH2 0x283a 1D77 56 *JUMP 1D78 5B JUMPDEST 1D79 60 PUSH1 0x01 1D7B 5B JUMPDEST 1D7C 61 PUSH2 0x1e45 1D7F 57 *JUMPI 1D80 3D RETURNDATASIZE 1D81 80 DUP1 1D82 80 DUP1 1D83 15 ISZERO 1D84 61 PUSH2 0x1da9 1D87 57 *JUMPI 1D88 60 PUSH1 0x40 1D8A 51 MLOAD 1D8B 91 SWAP2 1D8C 50 POP 1D8D 60 PUSH1 0x1f 1D8F 19 NOT 1D90 60 PUSH1 0x3f 1D92 3D RETURNDATASIZE 1D93 01 ADD 1D94 16 AND 1D95 82 DUP3 1D96 01 ADD 1D97 60 PUSH1 0x40 1D99 52 MSTORE 1D9A 3D RETURNDATASIZE 1D9B 82 DUP3 1D9C 52 MSTORE 1D9D 3D RETURNDATASIZE 1D9E 60 PUSH1 0x00 1DA0 60 PUSH1 0x20 1DA2 84 DUP5 1DA3 01 ADD 1DA4 3E RETURNDATACOPY 1DA5 61 PUSH2 0x1dae 1DA8 56 *JUMP 1DA9 5B JUMPDEST 1DAA 60 PUSH1 0x60 1DAC 91 SWAP2 1DAD 50 POP 1DAE 5B JUMPDEST 1DAF 50 POP 1DB0 80 DUP1 1DB1 51 MLOAD 1DB2 61 PUSH2 0x1e3d 1DB5 57 *JUMPI 1DB6 60 PUSH1 0x40 1DB8 51 MLOAD 1DB9 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1DDA 81 DUP2 1DDB 52 MSTORE 1DDC 60 PUSH1 0x20 1DDE 60 PUSH1 0x04 1DE0 82 DUP3 1DE1 01 ADD 1DE2 52 MSTORE 1DE3 60 PUSH1 0x32 1DE5 60 PUSH1 0x24 1DE7 82 DUP3 1DE8 01 ADD 1DE9 52 MSTORE 1DEA 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 1E0B 60 PUSH1 0x44 1E0D 82 DUP3 1E0E 01 ADD 1E0F 52 MSTORE 1E10 7F PUSH32 0x63656976657220696d706c656d656e7465720000000000000000000000000000 1E31 60 PUSH1 0x64 1E33 82 DUP3 1E34 01 ADD 1E35 52 MSTORE 1E36 60 PUSH1 0x84 1E38 01 ADD 1E39 61 PUSH2 0x0625 1E3C 56 *JUMP 1E3D 5B JUMPDEST 1E3E 80 DUP1 1E3F 51 MLOAD 1E40 81 DUP2 1E41 60 PUSH1 0x20 1E43 01 ADD 1E44 FD *REVERT 1E45 5B JUMPDEST 1E46 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 1E67 16 AND 1E68 7F PUSH32 0x150b7a0200000000000000000000000000000000000000000000000000000000 1E89 14 EQ 1E8A 90 SWAP1 1E8B 50 POP 1E8C 61 PUSH2 0x1529 1E8F 56 *JUMP 1E90 5B JUMPDEST 1E91 50 POP 1E92 60 PUSH1 0x01 1E94 94 SWAP5 1E95 93 SWAP4 1E96 50 POP 1E97 50 POP 1E98 50 POP 1E99 50 POP 1E9A 56 *JUMP label_1E9B: // Incoming call from 0x1CAA, returns to 0x07DF // Inputs[1] { @1EB1 stack[-3] } 1E9B 5B JUMPDEST 1E9C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EB1 83 DUP4 1EB2 16 AND 1EB3 61 PUSH2 0x1f03 1EB6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f03, if stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff label_1EB7: // Incoming jump from 0x1EB6, if not stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[3] // { // @1EBA stack[-1] // @1EBE storage[0x08] // @1ECC memory[0x00:0x40] // } 1EB7 61 PUSH2 0x1efe 1EBA 81 DUP2 1EBB 60 PUSH1 0x08 1EBD 80 DUP1 1EBE 54 SLOAD 1EBF 60 PUSH1 0x00 1EC1 83 DUP4 1EC2 81 DUP2 1EC3 52 MSTORE 1EC4 60 PUSH1 0x09 1EC6 60 PUSH1 0x20 1EC8 52 MSTORE 1EC9 60 PUSH1 0x40 1ECB 81 DUP2 1ECC 20 SHA3 1ECD 82 DUP3 1ECE 90 SWAP1 1ECF 55 SSTORE 1ED0 60 PUSH1 0x01 1ED2 82 DUP3 1ED3 01 ADD 1ED4 83 DUP4 1ED5 55 SSTORE 1ED6 91 SWAP2 1ED7 90 SWAP1 1ED8 91 SWAP2 1ED9 52 MSTORE 1EDA 7F PUSH32 0xf3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee3 1EFB 01 ADD 1EFC 55 SSTORE 1EFD 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @1EC3 memory[0x00:0x20] = stack[-1] // @1EC8 memory[0x20:0x40] = 0x09 // @1ECF storage[keccak256(memory[0x00:0x40])] = storage[0x08] // @1ED5 storage[0x08] = storage[0x08] + 0x01 // @1ED9 memory[0x00:0x20] = 0x08 // @1EFC storage[0xf3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee3 + storage[0x08]] = stack[-1] // } // Block ends with unconditional jump to 0x1efe label_1EFE: // Incoming jump from 0x1EFD 1EFE 5B JUMPDEST 1EFF 61 PUSH2 0x1f40 1F02 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1f40 label_1F03: // Incoming jump from 0x1EB6, if stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[2] // { // @1F04 stack[-2] // @1F1B stack[-3] // } 1F03 5B JUMPDEST 1F04 81 DUP2 1F05 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F1A 16 AND 1F1B 83 DUP4 1F1C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F31 16 AND 1F32 14 EQ 1F33 61 PUSH2 0x1f40 1F36 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f40, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] label_1F37: // Incoming jump from 0x1F36, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // Inputs[2] // { // @1F3A stack[-3] // @1F3B stack[-1] // } 1F37 61 PUSH2 0x1f40 1F3A 83 DUP4 1F3B 82 DUP3 1F3C 61 PUSH2 0x1fa1 1F3F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F37 stack[0] = 0x1f40 // @1F3A stack[1] = stack[-3] // @1F3B stack[2] = stack[-1] // } // Block ends with call to 0x1fa1, returns to 0x1F40 label_1F40: // Incoming jump from 0x1F36, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // Incoming jump from 0x1F02 // Incoming return from call to 0x1FA1 at 0x1F3F // Inputs[1] { @1F56 stack[-2] } 1F40 5B JUMPDEST 1F41 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F56 82 DUP3 1F57 16 AND 1F58 61 PUSH2 0x1f64 1F5B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f64, if stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff label_1F5C: // Incoming jump from 0x1F5B, if not stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @1F5F stack[-1] } 1F5C 61 PUSH2 0x07df 1F5F 81 DUP2 1F60 61 PUSH2 0x2058 1F63 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F5C stack[0] = 0x07df // @1F5F stack[1] = stack[-1] // } // Block ends with call to 0x2058, returns to 0x07DF label_1F64: // Incoming jump from 0x1F5B, if stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[2] // { // @1F65 stack[-3] // @1F7C stack[-2] // } 1F64 5B JUMPDEST 1F65 82 DUP3 1F66 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F7B 16 AND 1F7C 82 DUP3 1F7D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F92 16 AND 1F93 14 EQ 1F94 61 PUSH2 0x07df 1F97 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07df, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] label_1F98: // Incoming jump from 0x1F97, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // Inputs[2] // { // @1F9B stack[-2] // @1F9C stack[-1] // } 1F98 61 PUSH2 0x07df 1F9B 82 DUP3 1F9C 82 DUP3 1F9D 61 PUSH2 0x2107 1FA0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F98 stack[0] = 0x07df // @1F9B stack[1] = stack[-2] // @1F9C stack[2] = stack[-1] // } // Block ends with call to 0x2107, returns to 0x07DF label_1FA1: // Incoming call from 0x1F3F, returns to 0x1F40 // Inputs[1] { @1FA9 stack[-2] } 1FA1 5B JUMPDEST 1FA2 60 PUSH1 0x00 1FA4 60 PUSH1 0x01 1FA6 61 PUSH2 0x1fae 1FA9 84 DUP5 1FAA 61 PUSH2 0x0cd5 1FAD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1FA2 stack[0] = 0x00 // @1FA4 stack[1] = 0x01 // @1FA6 stack[2] = 0x1fae // @1FA9 stack[3] = stack[-2] // } // Block ends with call to 0x0cd5, returns to 0x1FAE label_1FAE: // Incoming return from call to 0x0CD5 at 0x1FAD // Inputs[2] // { // @1FB2 stack[-2] // @1FB3 stack[-1] // } 1FAE 5B JUMPDEST 1FAF 61 PUSH2 0x1fb8 1FB2 91 SWAP2 1FB3 90 SWAP1 1FB4 61 PUSH2 0x274a 1FB7 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1FB2 stack[-2] = 0x1fb8 // @1FB3 stack[-1] = stack[-2] // @1FB3 stack[0] = stack[-1] // } // Block ends with call to 0x274a, returns to 0x1FB8 label_1FB8: // Incoming return from call to 0x274A at 0x1FB7 // Inputs[5] // { // @1FBB stack[-3] // @1FC6 memory[0x00:0x40] // @1FC7 storage[keccak256(memory[0x00:0x40])] // @1FC8 stack[-1] // @1FC9 stack[-2] // } 1FB8 5B JUMPDEST 1FB9 60 PUSH1 0x00 1FBB 83 DUP4 1FBC 81 DUP2 1FBD 52 MSTORE 1FBE 60 PUSH1 0x07 1FC0 60 PUSH1 0x20 1FC2 52 MSTORE 1FC3 60 PUSH1 0x40 1FC5 90 SWAP1 1FC6 20 SHA3 1FC7 54 SLOAD 1FC8 90 SWAP1 1FC9 91 SWAP2 1FCA 50 POP 1FCB 80 DUP1 1FCC 82 DUP3 1FCD 14 EQ 1FCE 61 PUSH2 0x2018 1FD1 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1FBD memory[0x00:0x20] = stack[-3] // @1FC2 memory[0x20:0x40] = 0x07 // @1FC8 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @1FC9 stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x2018, if stack[-1] == storage[keccak256(memory[0x00:0x40])] label_1FD2: // Incoming jump from 0x1FD1, if not stack[-1] == storage[keccak256(memory[0x00:0x40])] // Inputs[13] // { // @1FE7 stack[-4] // @1FF9 memory[0x00:0x40] // @1FFA stack[-2] // @2001 memory[0x00:0x40] // @2002 storage[keccak256(memory[0x00:0x40])] // @2003 stack[-1] // @2008 memory[0x00:0x40] // @2014 memory[0x00:0x40] // @201C stack[-3] // @202A memory[0x00:0x40] // @204E memory[0x00:0x40] // @2055 memory[0x00:0x40] // @2057 stack[-5] // } 1FD2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FE7 84 DUP5 1FE8 16 AND 1FE9 60 PUSH1 0x00 1FEB 90 SWAP1 1FEC 81 DUP2 1FED 52 MSTORE 1FEE 60 PUSH1 0x06 1FF0 60 PUSH1 0x20 1FF2 90 SWAP1 1FF3 81 DUP2 1FF4 52 MSTORE 1FF5 60 PUSH1 0x40 1FF7 80 DUP1 1FF8 83 DUP4 1FF9 20 SHA3 1FFA 85 DUP6 1FFB 84 DUP5 1FFC 52 MSTORE 1FFD 82 DUP3 1FFE 52 MSTORE 1FFF 80 DUP1 2000 83 DUP4 2001 20 SHA3 2002 54 SLOAD 2003 84 DUP5 2004 84 DUP5 2005 52 MSTORE 2006 81 DUP2 2007 84 DUP5 2008 20 SHA3 2009 81 DUP2 200A 90 SWAP1 200B 55 SSTORE 200C 83 DUP4 200D 52 MSTORE 200E 60 PUSH1 0x07 2010 90 SWAP1 2011 91 SWAP2 2012 52 MSTORE 2013 90 SWAP1 2014 20 SHA3 2015 81 DUP2 2016 90 SWAP1 2017 55 SSTORE 2018 5B JUMPDEST 2019 50 POP 201A 60 PUSH1 0x00 201C 91 SWAP2 201D 82 DUP3 201E 52 MSTORE 201F 60 PUSH1 0x07 2021 60 PUSH1 0x20 2023 90 SWAP1 2024 81 DUP2 2025 52 MSTORE 2026 60 PUSH1 0x40 2028 80 DUP1 2029 84 DUP5 202A 20 SHA3 202B 84 DUP5 202C 90 SWAP1 202D 55 SSTORE 202E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2043 90 SWAP1 2044 94 SWAP5 2045 16 AND 2046 83 DUP4 2047 52 MSTORE 2048 60 PUSH1 0x06 204A 81 DUP2 204B 52 MSTORE 204C 83 DUP4 204D 83 DUP4 204E 20 SHA3 204F 91 SWAP2 2050 83 DUP4 2051 52 MSTORE 2052 52 MSTORE 2053 90 SWAP1 2054 81 DUP2 2055 20 SHA3 2056 55 SSTORE 2057 56 *JUMP // Stack delta = -5 // Outputs[17] // { // @1FED memory[0x00:0x20] = stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // @1FF4 memory[0x20:0x40] = 0x06 // @1FFC memory[0x00:0x20] = stack[-2] // @1FFE memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2005 memory[0x00:0x20] = stack[-1] // @200B storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] // @200D memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @2012 memory[0x20:0x40] = 0x07 // @2017 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @201E memory[0x00:0x20] = stack[-3] // @2025 memory[0x20:0x40] = 0x07 // @202D storage[keccak256(memory[0x00:0x40])] = 0x00 // @2047 memory[0x00:0x20] = stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // @204B memory[0x20:0x40] = 0x06 // @2051 memory[0x00:0x20] = stack[-2] // @2052 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2056 storage[keccak256(memory[0x00:0x40])] = 0x00 // } // Block ends with unconditional jump to stack[-5] label_2058: // Incoming call from 0x1F63, returns to 0x07DF // Inputs[1] { @205B storage[0x08] } 2058 5B JUMPDEST 2059 60 PUSH1 0x08 205B 54 SLOAD 205C 60 PUSH1 0x00 205E 90 SWAP1 205F 61 PUSH2 0x206a 2062 90 SWAP1 2063 60 PUSH1 0x01 2065 90 SWAP1 2066 61 PUSH2 0x274a 2069 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @205E stack[0] = 0x00 // @2062 stack[1] = 0x206a // @2065 stack[2] = 0x01 // @2065 stack[3] = storage[0x08] // } // Block ends with call to 0x274a, returns to 0x206A label_206A: // Incoming return from call to 0x274A at 0x2069 // Inputs[6] // { // @206D stack[-3] // @2078 memory[0x00:0x40] // @2079 storage[keccak256(memory[0x00:0x40])] // @207D storage[0x08] // @207E stack[-1] // @207F stack[-2] // } 206A 5B JUMPDEST 206B 60 PUSH1 0x00 206D 83 DUP4 206E 81 DUP2 206F 52 MSTORE 2070 60 PUSH1 0x09 2072 60 PUSH1 0x20 2074 52 MSTORE 2075 60 PUSH1 0x40 2077 81 DUP2 2078 20 SHA3 2079 54 SLOAD 207A 60 PUSH1 0x08 207C 80 DUP1 207D 54 SLOAD 207E 93 SWAP4 207F 94 SWAP5 2080 50 POP 2081 90 SWAP1 2082 92 SWAP3 2083 84 DUP5 2084 90 SWAP1 2085 81 DUP2 2086 10 LT 2087 61 PUSH2 0x2092 208A 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @206B stack[0] = 0x00 // @206F memory[0x00:0x20] = stack[-3] // @2074 memory[0x20:0x40] = 0x09 // @207F stack[-2] = stack[-1] // @2081 stack[1] = 0x08 // @2082 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @2084 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x2092, if stack[-1] < storage[0x08] label_208B: // Incoming jump from 0x208A, if not stack[-1] < storage[0x08] 208B 61 PUSH2 0x2092 208E 61 PUSH2 0x25da 2091 56 *JUMP // Stack delta = +1 // Outputs[1] { @208B stack[0] = 0x2092 } // Block ends with unconditional jump to 0x25da label_2092: // Incoming jump from 0x208A, if stack[-1] < storage[0x08] // Inputs[7] // { // @2093 stack[-1] // @2093 stack[-2] // @209B memory[0x00:0x20] // @209D storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @209E stack[-3] // @20A3 stack[-4] // @20A5 storage[0x08] // } 2092 5B JUMPDEST 2093 90 SWAP1 2094 60 PUSH1 0x00 2096 52 MSTORE 2097 60 PUSH1 0x20 2099 60 PUSH1 0x00 209B 20 SHA3 209C 01 ADD 209D 54 SLOAD 209E 90 SWAP1 209F 50 POP 20A0 80 DUP1 20A1 60 PUSH1 0x08 20A3 83 DUP4 20A4 81 DUP2 20A5 54 SLOAD 20A6 81 DUP2 20A7 10 LT 20A8 61 PUSH2 0x20b3 20AB 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @2096 memory[0x00:0x20] = stack[-2] // @209E stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @20A0 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @20A1 stack[-1] = 0x08 // @20A3 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x20b3, if stack[-4] < storage[0x08] label_20AC: // Incoming jump from 0x20AB, if not stack[-4] < storage[0x08] 20AC 61 PUSH2 0x20b3 20AF 61 PUSH2 0x25da 20B2 56 *JUMP // Stack delta = +1 // Outputs[1] { @20AC stack[0] = 0x20b3 } // Block ends with unconditional jump to 0x25da label_20B3: // Incoming jump from 0x20AB, if stack[-4] < storage[0x08] // Inputs[10] // { // @20B6 stack[-2] // @20BD memory[0x00:0x20] // @20BF stack[-1] // @20C1 stack[-3] // @20C5 stack[-4] // @20D1 memory[0x00:0x40] // @20D2 stack[-5] // @20D5 stack[-7] // @20D9 memory[0x00:0x40] // @20DE storage[0x08] // } 20B3 5B JUMPDEST 20B4 60 PUSH1 0x00 20B6 91 SWAP2 20B7 82 DUP3 20B8 52 MSTORE 20B9 60 PUSH1 0x20 20BB 80 DUP1 20BC 83 DUP4 20BD 20 SHA3 20BE 90 SWAP1 20BF 91 SWAP2 20C0 01 ADD 20C1 92 SWAP3 20C2 90 SWAP1 20C3 92 SWAP3 20C4 55 SSTORE 20C5 82 DUP3 20C6 81 DUP2 20C7 52 MSTORE 20C8 60 PUSH1 0x09 20CA 90 SWAP1 20CB 91 SWAP2 20CC 52 MSTORE 20CD 60 PUSH1 0x40 20CF 80 DUP1 20D0 82 DUP3 20D1 20 SHA3 20D2 84 DUP5 20D3 90 SWAP1 20D4 55 SSTORE 20D5 85 DUP6 20D6 82 DUP3 20D7 52 MSTORE 20D8 81 DUP2 20D9 20 SHA3 20DA 55 SSTORE 20DB 60 PUSH1 0x08 20DD 80 DUP1 20DE 54 SLOAD 20DF 80 DUP1 20E0 61 PUSH2 0x20eb 20E3 57 *JUMPI // Stack delta = -1 // Outputs[9] // { // @20B8 memory[0x00:0x20] = stack[-2] // @20C4 storage[stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // @20C7 memory[0x00:0x20] = stack[-4] // @20CC memory[0x20:0x40] = 0x09 // @20D4 storage[keccak256(memory[0x00:0x40])] = stack[-5] // @20D7 memory[0x00:0x20] = stack[-7] // @20DA storage[keccak256(memory[0x00:0x40])] = 0x00 // @20DB stack[-3] = 0x08 // @20DE stack[-2] = storage[0x08] // } // Block ends with conditional jump to 0x20eb, if storage[0x08] label_20E4: // Incoming jump from 0x20E3, if not storage[0x08] 20E4 61 PUSH2 0x20eb 20E7 61 PUSH2 0x2857 20EA 56 *JUMP // Stack delta = +1 // Outputs[1] { @20E4 stack[0] = 0x20eb } // Block ends with unconditional jump to 0x2857 label_20EB: // Incoming jump from 0x20E3, if storage[0x08] // Inputs[4] // { // @20EE stack[-1] // @20F0 stack[-2] // @20FA memory[0x00:0x20] // @2106 stack[-7] // } 20EB 5B JUMPDEST 20EC 60 PUSH1 0x01 20EE 90 SWAP1 20EF 03 SUB 20F0 81 DUP2 20F1 81 DUP2 20F2 90 SWAP1 20F3 60 PUSH1 0x00 20F5 52 MSTORE 20F6 60 PUSH1 0x20 20F8 60 PUSH1 0x00 20FA 20 SHA3 20FB 01 ADD 20FC 60 PUSH1 0x00 20FE 90 SWAP1 20FF 55 SSTORE 2100 90 SWAP1 2101 55 SSTORE 2102 50 POP 2103 50 POP 2104 50 POP 2105 50 POP 2106 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @20F5 memory[0x00:0x20] = stack[-2] // @20FF storage[keccak256(memory[0x00:0x20]) + (stack[-1] - 0x01)] = 0x00 // @2101 storage[stack[-2]] = stack[-1] - 0x01 // } // Block ends with unconditional jump to stack[-7] label_2107: // Incoming call from 0x1FA0, returns to 0x07DF // Inputs[1] { @210D stack[-2] } 2107 5B JUMPDEST 2108 60 PUSH1 0x00 210A 61 PUSH2 0x2112 210D 83 DUP4 210E 61 PUSH2 0x0cd5 2111 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2108 stack[0] = 0x00 // @210A stack[1] = 0x2112 // @210D stack[2] = stack[-2] // } // Block ends with call to 0x0cd5, returns to 0x2112 label_2112: // Incoming return from call to 0x0CD5 at 0x2111 // Inputs[8] // { // @2128 stack[-1] // @2129 stack[-4] // @213B memory[0x00:0x40] // @2143 memory[0x00:0x40] // @2144 stack[-3] // @214F stack[-2] // @2151 memory[0x00:0x40] // @2157 stack[-5] // } 2112 5B JUMPDEST 2113 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2128 90 SWAP1 2129 93 SWAP4 212A 16 AND 212B 60 PUSH1 0x00 212D 90 SWAP1 212E 81 DUP2 212F 52 MSTORE 2130 60 PUSH1 0x06 2132 60 PUSH1 0x20 2134 90 SWAP1 2135 81 DUP2 2136 52 MSTORE 2137 60 PUSH1 0x40 2139 80 DUP1 213A 83 DUP4 213B 20 SHA3 213C 86 DUP7 213D 84 DUP5 213E 52 MSTORE 213F 82 DUP3 2140 52 MSTORE 2141 80 DUP1 2142 83 DUP4 2143 20 SHA3 2144 85 DUP6 2145 90 SWAP1 2146 55 SSTORE 2147 93 SWAP4 2148 82 DUP3 2149 52 MSTORE 214A 60 PUSH1 0x07 214C 90 SWAP1 214D 52 MSTORE 214E 91 SWAP2 214F 90 SWAP1 2150 91 SWAP2 2151 20 SHA3 2152 91 SWAP2 2153 90 SWAP1 2154 91 SWAP2 2155 55 SSTORE 2156 50 POP 2157 56 *JUMP // Stack delta = -5 // Outputs[8] // { // @212F memory[0x00:0x20] = stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // @2136 memory[0x20:0x40] = 0x06 // @213E memory[0x00:0x20] = stack[-1] // @2140 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2146 storage[keccak256(memory[0x00:0x40])] = stack[-3] // @2149 memory[0x00:0x20] = stack[-3] // @214D memory[0x20:0x40] = 0x07 // @2155 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_2158: // Incoming jump from 0x0C22 // Inputs[2] // { // @2159 stack[-3] // @215B storage[stack[-3]] // } 2158 5B JUMPDEST 2159 82 DUP3 215A 80 DUP1 215B 54 SLOAD 215C 61 PUSH2 0x2164 215F 90 SWAP1 2160 61 PUSH2 0x2586 2163 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2159 stack[0] = stack[-3] // @215F stack[1] = 0x2164 // @215F stack[2] = storage[stack[-3]] // } // Block ends with call to 0x2586, returns to 0x2164 label_2164: // Incoming return from call to 0x2586 at 0x2163 // Inputs[5] // { // @2165 stack[-1] // @2165 stack[-2] // @216D memory[0x00:0x20] // @2178 stack[-4] // @2179 stack[-3] // } 2164 5B JUMPDEST 2165 90 SWAP1 2166 60 PUSH1 0x00 2168 52 MSTORE 2169 60 PUSH1 0x20 216B 60 PUSH1 0x00 216D 20 SHA3 216E 90 SWAP1 216F 60 PUSH1 0x1f 2171 01 ADD 2172 60 PUSH1 0x20 2174 90 SWAP1 2175 04 DIV 2176 81 DUP2 2177 01 ADD 2178 92 SWAP3 2179 82 DUP3 217A 61 PUSH2 0x2186 217D 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2168 memory[0x00:0x20] = stack[-2] // @216E stack[-2] = keccak256(memory[0x00:0x20]) // @2178 stack[-1] = stack[-4] // @2178 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x2186, if stack[-3] label_217E: // Incoming jump from 0x217D, if not stack[-3] // Inputs[1] { @2180 stack[-5] } 217E 60 PUSH1 0x00 2180 85 DUP6 2181 55 SSTORE 2182 61 PUSH2 0x21cc 2185 56 *JUMP // Stack delta = +0 // Outputs[1] { @2181 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x21cc label_2186: // Incoming jump from 0x217D, if stack[-3] // Inputs[1] { @2187 stack[-3] } 2186 5B JUMPDEST 2187 82 DUP3 2188 60 PUSH1 0x1f 218A 10 LT 218B 61 PUSH2 0x219f 218E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x219f, if 0x1f < stack[-3] label_218F: // Incoming jump from 0x218E, if not 0x1f < stack[-3] // Inputs[4] // { // @218F stack[-1] // @2190 memory[stack[-1]:stack[-1] + 0x20] // @2195 stack[-3] // @2199 stack[-5] // } 218F 80 DUP1 2190 51 MLOAD 2191 60 PUSH1 0xff 2193 19 NOT 2194 16 AND 2195 83 DUP4 2196 80 DUP1 2197 01 ADD 2198 17 OR 2199 85 DUP6 219A 55 SSTORE 219B 61 PUSH2 0x21cc 219E 56 *JUMP // Stack delta = +0 // Outputs[1] { @219A storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x21cc label_219F: // Incoming jump from 0x218E, if 0x1f < stack[-3] // Inputs[2] // { // @21A0 stack[-3] // @21A6 stack[-5] // } 219F 5B JUMPDEST 21A0 82 DUP3 21A1 80 DUP1 21A2 01 ADD 21A3 60 PUSH1 0x01 21A5 01 ADD 21A6 85 DUP6 21A7 55 SSTORE 21A8 82 DUP3 21A9 15 ISZERO 21AA 61 PUSH2 0x21cc 21AD 57 *JUMPI // Stack delta = +0 // Outputs[1] { @21A7 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x21cc, if !stack[-3] label_21AE: // Incoming jump from 0x21AD, if not !stack[-3] // Inputs[2] // { // @21AE stack[-3] // @21AE stack[-1] // } 21AE 91 SWAP2 21AF 82 DUP3 21B0 01 ADD 21B1 5B JUMPDEST 21B2 82 DUP3 21B3 81 DUP2 21B4 11 GT 21B5 15 ISZERO 21B6 61 PUSH2 0x21cc 21B9 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @21AE stack[-3] = stack[-1] // @21B0 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x21cc, if !(stack[-1] + stack[-3] > stack[-1]) label_21BA: // Incoming jump from 0x21B9, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x21B9, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @21BA stack[-3] // @21BB memory[stack[-3]:stack[-3] + 0x20] // @21BC stack[-2] // @21BE stack[-1] // } 21BA 82 DUP3 21BB 51 MLOAD 21BC 82 DUP3 21BD 55 SSTORE 21BE 91 SWAP2 21BF 60 PUSH1 0x20 21C1 01 ADD 21C2 91 SWAP2 21C3 90 SWAP1 21C4 60 PUSH1 0x01 21C6 01 ADD 21C7 90 SWAP1 21C8 61 PUSH2 0x21b1 21CB 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @21BD storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @21C2 stack[-3] = 0x20 + stack[-3] // @21C7 stack[-2] = 0x01 + stack[-2] // @21C7 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x21b1 label_21CC: // Incoming jump from 0x21AD, if !stack[-3] // Incoming jump from 0x21B9, if !(stack[-1] > stack[-3]) // Incoming jump from 0x2185 // Incoming jump from 0x21B9, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x219E // Inputs[2] // { // @21D1 stack[-4] // @21D2 stack[-3] // } 21CC 5B JUMPDEST 21CD 50 POP 21CE 61 PUSH2 0x21d8 21D1 92 SWAP3 21D2 91 SWAP2 21D3 50 POP 21D4 61 PUSH2 0x21dc 21D7 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @21D1 stack[-4] = 0x21d8 // @21D2 stack[-3] = stack[-4] // } // Block ends with call to 0x21dc, returns to 0x21D8 label_21D8: // Incoming jump from 0x21E5, if !(stack[-2] > stack[-1]) // Incoming jump from 0x21E5, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x21DC at 0x21D7 // Inputs[2] // { // @21DA stack[-3] // @21DA stack[-2] // } 21D8 5B JUMPDEST 21D9 50 POP 21DA 90 SWAP1 21DB 56 *JUMP // Stack delta = -2 // Outputs[1] { @21DA stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_21DC: // Incoming call from 0x21D7, returns to 0x21D8 // Inputs[2] // { // @21DE stack[-1] // @21DF stack[-2] // } 21DC 5B JUMPDEST 21DD 5B JUMPDEST 21DE 80 DUP1 21DF 82 DUP3 21E0 11 GT 21E1 15 ISZERO 21E2 61 PUSH2 0x21d8 21E5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x21d8, if !(stack[-2] > stack[-1]) label_21E6: // Incoming jump from 0x21E5, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x21E5, if not !(stack[-2] > stack[-1]) // Inputs[1] { @21E8 stack[-1] } 21E6 60 PUSH1 0x00 21E8 81 DUP2 21E9 55 SSTORE 21EA 60 PUSH1 0x01 21EC 01 ADD 21ED 61 PUSH2 0x21dd 21F0 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @21E9 storage[stack[-1]] = 0x00 // @21EC stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x21dd label_21F1: // Incoming call from 0x223B, returns to 0x223C // Inputs[1] { @2213 stack[-1] } 21F1 5B JUMPDEST 21F2 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 2213 81 DUP2 2214 16 AND 2215 81 DUP2 2216 14 EQ 2217 61 PUSH2 0x0ab3 221A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ab3, if stack[-1] == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_221B: // Incoming jump from 0x221A, if not stack[-1] == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @221E memory[0x00:0x00] } 221B 60 PUSH1 0x00 221D 80 DUP1 221E FD *REVERT // Stack delta = +0 // Outputs[1] { @221E revert(memory[0x00:0x00]); } // Block terminates label_221F: // Incoming call from 0x01AA, returns to 0x01AB // Inputs[2] // { // @2224 stack[-1] // @2225 stack[-2] // } 221F 5B JUMPDEST 2220 60 PUSH1 0x00 2222 60 PUSH1 0x20 2224 82 DUP3 2225 84 DUP5 2226 03 SUB 2227 12 SLT 2228 15 ISZERO 2229 61 PUSH2 0x2231 222C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2220 stack[0] = 0x00 } // Block ends with conditional jump to 0x2231, if !(stack[-2] - stack[-1] i< 0x20) label_222D: // Incoming jump from 0x222C, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2230 memory[0x00:0x00] } 222D 60 PUSH1 0x00 222F 80 DUP1 2230 FD *REVERT // Stack delta = +0 // Outputs[1] { @2230 revert(memory[0x00:0x00]); } // Block terminates label_2231: // Incoming jump from 0x222C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2232 stack[-2] // @2233 msg.data[stack[-2]:stack[-2] + 0x20] // } 2231 5B JUMPDEST 2232 81 DUP2 2233 35 CALLDATALOAD 2234 61 PUSH2 0x223c 2237 81 DUP2 2238 61 PUSH2 0x21f1 223B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2233 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2234 stack[1] = 0x223c // @2237 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x21f1, returns to 0x223C label_223C: // Incoming return from call to 0x21F1 at 0x223B // Incoming return from call to 0x22E5 at 0x249A // Incoming return from call to 0x226F at 0x22CB // Inputs[3] // { // @223D stack[-1] // @223D stack[-5] // @223E stack[-4] // } 223C 5B JUMPDEST 223D 93 SWAP4 223E 92 SWAP3 223F 50 POP 2240 50 POP 2241 50 POP 2242 56 *JUMP // Stack delta = -4 // Outputs[1] { @223D stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2243: // Incoming call from 0x2661, returns to 0x2662 // Incoming call from 0x2286, returns to 0x2287 // Inputs[1] { @2247 stack[-3] } 2243 5B JUMPDEST 2244 60 PUSH1 0x00 2246 5B JUMPDEST 2247 83 DUP4 2248 81 DUP2 2249 10 LT 224A 15 ISZERO 224B 61 PUSH2 0x225e 224E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2244 stack[0] = 0x00 } // Block ends with conditional jump to 0x225e, if !(0x00 < stack[-3]) label_224F: // Incoming jump from 0x224E, if not !(0x00 < stack[-3]) // Incoming jump from 0x224E, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @224F stack[-2] // @2250 stack[-1] // @2252 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2253 stack[-3] // } 224F 81 DUP2 2250 81 DUP2 2251 01 ADD 2252 51 MLOAD 2253 83 DUP4 2254 82 DUP3 2255 01 ADD 2256 52 MSTORE 2257 60 PUSH1 0x20 2259 01 ADD 225A 61 PUSH2 0x2246 225D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2256 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2259 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2246 label_225E: // Incoming jump from 0x224E, if !(0x00 < stack[-3]) // Incoming jump from 0x224E, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @225F stack[-4] // @2260 stack[-1] // } 225E 5B JUMPDEST 225F 83 DUP4 2260 81 DUP2 2261 11 GT 2262 15 ISZERO 2263 61 PUSH2 0x1164 2266 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1164, if !(stack[-1] > stack[-4]) label_2267: // Incoming jump from 0x2266, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @226B stack[-4] // @226C stack[-3] // @226E stack[-5] // } 2267 50 POP 2268 50 POP 2269 60 PUSH1 0x00 226B 91 SWAP2 226C 01 ADD 226D 52 MSTORE 226E 56 *JUMP // Stack delta = -5 // Outputs[1] { @226D memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_226F: // Incoming call from 0x22CB, returns to 0x223C // Inputs[3] // { // @2272 stack[-1] // @2273 memory[stack[-1]:stack[-1] + 0x20] // @2275 stack[-2] // } 226F 5B JUMPDEST 2270 60 PUSH1 0x00 2272 81 DUP2 2273 51 MLOAD 2274 80 DUP1 2275 84 DUP5 2276 52 MSTORE 2277 61 PUSH2 0x2287 227A 81 DUP2 227B 60 PUSH1 0x20 227D 86 DUP7 227E 01 ADD 227F 60 PUSH1 0x20 2281 86 DUP7 2282 01 ADD 2283 61 PUSH2 0x2243 2286 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @2270 stack[0] = 0x00 // @2273 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @2276 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2277 stack[2] = 0x2287 // @227A stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @227E stack[4] = stack[-2] + 0x20 // @2282 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x2243, returns to 0x2287 label_2287: // Incoming return from call to 0x2243 at 0x2286 // Inputs[4] // { // @228A stack[-1] // @22AD stack[-4] // @22AE stack[-2] // @22B4 stack[-5] // } 2287 5B JUMPDEST 2288 60 PUSH1 0x1f 228A 01 ADD 228B 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 22AC 16 AND 22AD 92 SWAP3 22AE 90 SWAP1 22AF 92 SWAP3 22B0 01 ADD 22B1 60 PUSH1 0x20 22B3 01 ADD 22B4 92 SWAP3 22B5 91 SWAP2 22B6 50 POP 22B7 50 POP 22B8 56 *JUMP // Stack delta = -4 // Outputs[1] { @22B4 stack[-5] = 0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_22B9: // Incoming jump from 0x01E6 // Inputs[2] // { // @22BC stack[-1] // @22C7 stack[-2] // } 22B9 5B JUMPDEST 22BA 60 PUSH1 0x20 22BC 81 DUP2 22BD 52 MSTORE 22BE 60 PUSH1 0x00 22C0 61 PUSH2 0x223c 22C3 60 PUSH1 0x20 22C5 83 DUP4 22C6 01 ADD 22C7 84 DUP5 22C8 61 PUSH2 0x226f 22CB 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @22BD memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @22BE stack[0] = 0x00 // @22C0 stack[1] = 0x223c // @22C6 stack[2] = stack[-1] + 0x20 // @22C7 stack[3] = stack[-2] // } // Block ends with call to 0x226f, returns to 0x223C label_22CC: // Incoming call from 0x02A7, returns to 0x02A8 // Incoming call from 0x035C, returns to 0x035D // Incoming call from 0x0201, returns to 0x0202 // Incoming call from 0x0459, returns to 0x045A // Incoming call from 0x031C, returns to 0x031D // Incoming call from 0x03F9, returns to 0x03FA // Inputs[2] // { // @22D1 stack[-1] // @22D2 stack[-2] // } 22CC 5B JUMPDEST 22CD 60 PUSH1 0x00 22CF 60 PUSH1 0x20 22D1 82 DUP3 22D2 84 DUP5 22D3 03 SUB 22D4 12 SLT 22D5 15 ISZERO 22D6 61 PUSH2 0x22de 22D9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22CD stack[0] = 0x00 } // Block ends with conditional jump to 0x22de, if !(stack[-2] - stack[-1] i< 0x20) label_22DA: // Incoming jump from 0x22D9, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @22DD memory[0x00:0x00] } 22DA 60 PUSH1 0x00 22DC 80 DUP1 22DD FD *REVERT // Stack delta = +0 // Outputs[1] { @22DD revert(memory[0x00:0x00]); } // Block terminates label_22DE: // Incoming jump from 0x22D9, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @22E0 msg.data[stack[-2]:stack[-2] + 0x20] // @22E0 stack[-2] // @22E1 stack[-4] // @22E2 stack[-3] // } 22DE 5B JUMPDEST 22DF 50 POP 22E0 35 CALLDATALOAD 22E1 91 SWAP2 22E2 90 SWAP1 22E3 50 POP 22E4 56 *JUMP // Stack delta = -3 // Outputs[1] { @22E1 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_22E5: // Incoming call from 0x24F5, returns to 0x24F6 // Incoming call from 0x249A, returns to 0x223C // Incoming call from 0x2355, returns to 0x2356 // Incoming call from 0x256E, returns to 0x256F // Incoming call from 0x257C, returns to 0x257D // Incoming call from 0x24B6, returns to 0x24B7 // Incoming call from 0x2363, returns to 0x2364 // Incoming call from 0x2503, returns to 0x2504 // Incoming call from 0x2329, returns to 0x232A // Inputs[2] // { // @22E6 stack[-1] // @22E7 msg.data[stack[-1]:stack[-1] + 0x20] // } 22E5 5B JUMPDEST 22E6 80 DUP1 22E7 35 CALLDATALOAD 22E8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 22FD 81 DUP2 22FE 16 AND 22FF 81 DUP2 2300 14 EQ 2301 61 PUSH2 0x2309 2304 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22E7 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x2309, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff label_2305: // Incoming jump from 0x2304, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @2308 memory[0x00:0x00] } 2305 60 PUSH1 0x00 2307 80 DUP1 2308 FD *REVERT // Stack delta = +0 // Outputs[1] { @2308 revert(memory[0x00:0x00]); } // Block terminates label_2309: // Incoming jump from 0x2304, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[3] // { // @230A stack[-3] // @230A stack[-1] // @230B stack[-2] // } 2309 5B JUMPDEST 230A 91 SWAP2 230B 90 SWAP1 230C 50 POP 230D 56 *JUMP // Stack delta = -2 // Outputs[1] { @230A stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_230E: // Incoming call from 0x0246, returns to 0x0247 // Incoming call from 0x02C7, returns to 0x02C8 // Inputs[2] // { // @2314 stack[-1] // @2315 stack[-2] // } 230E 5B JUMPDEST 230F 60 PUSH1 0x00 2311 80 DUP1 2312 60 PUSH1 0x40 2314 83 DUP4 2315 85 DUP6 2316 03 SUB 2317 12 SLT 2318 15 ISZERO 2319 61 PUSH2 0x2321 231C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @230F stack[0] = 0x00 // @2311 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2321, if !(stack[-2] - stack[-1] i< 0x40) label_231D: // Incoming jump from 0x231C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2320 memory[0x00:0x00] } 231D 60 PUSH1 0x00 231F 80 DUP1 2320 FD *REVERT // Stack delta = +0 // Outputs[1] { @2320 revert(memory[0x00:0x00]); } // Block terminates label_2321: // Incoming jump from 0x231C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2325 stack[-3] } 2321 5B JUMPDEST 2322 61 PUSH2 0x232a 2325 83 DUP4 2326 61 PUSH2 0x22e5 2329 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2322 stack[0] = 0x232a // @2325 stack[1] = stack[-3] // } // Block ends with call to 0x22e5, returns to 0x232A label_232A: // Incoming return from call to 0x22E5 at 0x2329 // Inputs[5] // { // @232B stack[-6] // @232B stack[-1] // @232E stack[-4] // @2332 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @2333 stack[-5] // } 232A 5B JUMPDEST 232B 94 SWAP5 232C 60 PUSH1 0x20 232E 93 SWAP4 232F 90 SWAP1 2330 93 SWAP4 2331 01 ADD 2332 35 CALLDATALOAD 2333 93 SWAP4 2334 50 POP 2335 50 POP 2336 50 POP 2337 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @232B stack[-6] = stack[-1] // @2333 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_2338: // Incoming call from 0x02FC, returns to 0x02FD // Incoming call from 0x0287, returns to 0x0288 // Inputs[2] // { // @2340 stack[-1] // @2341 stack[-2] // } 2338 5B JUMPDEST 2339 60 PUSH1 0x00 233B 80 DUP1 233C 60 PUSH1 0x00 233E 60 PUSH1 0x60 2340 84 DUP5 2341 86 DUP7 2342 03 SUB 2343 12 SLT 2344 15 ISZERO 2345 61 PUSH2 0x234d 2348 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2339 stack[0] = 0x00 // @233B stack[1] = 0x00 // @233C stack[2] = 0x00 // } // Block ends with conditional jump to 0x234d, if !(stack[-2] - stack[-1] i< 0x60) label_2349: // Incoming jump from 0x2348, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @234C memory[0x00:0x00] } 2349 60 PUSH1 0x00 234B 80 DUP1 234C FD *REVERT // Stack delta = +0 // Outputs[1] { @234C revert(memory[0x00:0x00]); } // Block terminates label_234D: // Incoming jump from 0x2348, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2351 stack[-4] } 234D 5B JUMPDEST 234E 61 PUSH2 0x2356 2351 84 DUP5 2352 61 PUSH2 0x22e5 2355 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @234E stack[0] = 0x2356 // @2351 stack[1] = stack[-4] // } // Block ends with call to 0x22e5, returns to 0x2356 label_2356: // Incoming return from call to 0x22E5 at 0x2355 // Inputs[3] // { // @2357 stack[-1] // @2357 stack[-4] // @235E stack[-5] // } 2356 5B JUMPDEST 2357 92 SWAP3 2358 50 POP 2359 61 PUSH2 0x2364 235C 60 PUSH1 0x20 235E 85 DUP6 235F 01 ADD 2360 61 PUSH2 0x22e5 2363 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2357 stack[-4] = stack[-1] // @2359 stack[-1] = 0x2364 // @235F stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x22e5, returns to 0x2364 label_2364: // Incoming return from call to 0x22E5 at 0x2363 // Inputs[8] // { // @2365 stack[-3] // @2365 stack[-1] // @2369 stack[-5] // @236B msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @236C stack[-2] // @2370 stack[-6] // @2372 stack[-7] // @2372 stack[-4] // } 2364 5B JUMPDEST 2365 91 SWAP2 2366 50 POP 2367 60 PUSH1 0x40 2369 84 DUP5 236A 01 ADD 236B 35 CALLDATALOAD 236C 90 SWAP1 236D 50 POP 236E 92 SWAP3 236F 50 POP 2370 92 SWAP3 2371 50 POP 2372 92 SWAP3 2373 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @236E stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2370 stack[-6] = stack[-1] // @2372 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_2374: // Incoming jump from 0x1B0F // Incoming jump from 0x23BD // Incoming jump from 0x2403 // Inputs[1] { @23A2 memory[0x00:0x24] } 2374 5B JUMPDEST 2375 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 2396 60 PUSH1 0x00 2398 52 MSTORE 2399 60 PUSH1 0x41 239B 60 PUSH1 0x04 239D 52 MSTORE 239E 60 PUSH1 0x24 23A0 60 PUSH1 0x00 23A2 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2398 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @239D memory[0x04:0x24] = 0x41 // @23A2 revert(memory[0x00:0x24]); // } // Block terminates label_23A3: // Incoming call from 0x247F, returns to 0x1529 // Incoming call from 0x2546, returns to 0x2547 // Inputs[1] { @23B0 stack[-2] } 23A3 5B JUMPDEST 23A4 60 PUSH1 0x00 23A6 67 PUSH8 0xffffffffffffffff 23AF 80 DUP1 23B0 84 DUP5 23B1 11 GT 23B2 15 ISZERO 23B3 61 PUSH2 0x23be 23B6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @23A4 stack[0] = 0x00 // @23A6 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x23be, if !(stack[-2] > 0xffffffffffffffff) label_23B7: // Incoming jump from 0x23B6, if not !(stack[-2] > 0xffffffffffffffff) 23B7 61 PUSH2 0x23be 23BA 61 PUSH2 0x2374 23BD 56 *JUMP // Stack delta = +1 // Outputs[1] { @23B7 stack[0] = 0x23be } // Block ends with unconditional jump to 0x2374 label_23BE: // Incoming jump from 0x23B6, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @23C1 memory[0x40:0x60] // @23C4 stack[-4] // @23F1 stack[-1] // } 23BE 5B JUMPDEST 23BF 60 PUSH1 0x40 23C1 51 MLOAD 23C2 60 PUSH1 0x1f 23C4 85 DUP6 23C5 01 ADD 23C6 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 23E7 90 SWAP1 23E8 81 DUP2 23E9 16 AND 23EA 60 PUSH1 0x3f 23EC 01 ADD 23ED 16 AND 23EE 81 DUP2 23EF 01 ADD 23F0 90 SWAP1 23F1 82 DUP3 23F2 82 DUP3 23F3 11 GT 23F4 81 DUP2 23F5 83 DUP4 23F6 10 LT 23F7 17 OR 23F8 15 ISZERO 23F9 61 PUSH2 0x2404 23FC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @23F0 stack[0] = memory[0x40:0x60] + (0x3f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-4] + 0x1f) & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) // @23F0 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x2404, if !((memory[0x40:0x60] + (0x3f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-4] + 0x1f) & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-4] + 0x1f) & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > stack[-1])) label_23FD: // Incoming jump from 0x23FC, if not !((memory[0x40:0x60] + (0x3f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-4] + 0x1f) & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-4] + 0x1f) & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > stack[-1])) 23FD 61 PUSH2 0x2404 2400 61 PUSH2 0x2374 2403 56 *JUMP // Stack delta = +1 // Outputs[1] { @23FD stack[0] = 0x2404 } // Block ends with unconditional jump to 0x2374 label_2404: // Incoming jump from 0x23FC, if !((memory[0x40:0x60] + (0x3f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-4] + 0x1f) & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-4] + 0x1f) & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > stack[-1])) // Inputs[6] // { // @2405 stack[-2] // @2409 stack[-1] // @240A stack[-4] // @240C stack[-6] // @240F stack[-7] // @2411 stack[-5] // } 2404 5B JUMPDEST 2405 81 DUP2 2406 60 PUSH1 0x40 2408 52 MSTORE 2409 80 DUP1 240A 93 SWAP4 240B 50 POP 240C 85 DUP6 240D 81 DUP2 240E 52 MSTORE 240F 86 DUP7 2410 86 DUP7 2411 86 DUP7 2412 01 ADD 2413 11 GT 2414 15 ISZERO 2415 61 PUSH2 0x241d 2418 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2408 memory[0x40:0x60] = stack[-2] // @240A stack[-4] = stack[-1] // @240E memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x241d, if !(stack[-5] + stack[-6] > stack[-7]) label_2419: // Incoming jump from 0x2418, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @241C memory[0x00:0x00] } 2419 60 PUSH1 0x00 241B 80 DUP1 241C FD *REVERT // Stack delta = +0 // Outputs[1] { @241C revert(memory[0x00:0x00]); } // Block terminates label_241D: // Incoming jump from 0x2418, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @241E stack[-6] // @241F stack[-5] // @2422 stack[-1] // @2424 msg.data[stack[-5]:stack[-5] + stack[-6]] // @2431 stack[-8] // @2431 stack[-4] // @2432 stack[-7] // } 241D 5B JUMPDEST 241E 85 DUP6 241F 85 DUP6 2420 60 PUSH1 0x20 2422 83 DUP4 2423 01 ADD 2424 37 CALLDATACOPY 2425 60 PUSH1 0x00 2427 60 PUSH1 0x20 2429 87 DUP8 242A 83 DUP4 242B 01 ADD 242C 01 ADD 242D 52 MSTORE 242E 50 POP 242F 50 POP 2430 50 POP 2431 93 SWAP4 2432 92 SWAP3 2433 50 POP 2434 50 POP 2435 50 POP 2436 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @2424 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @242D memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @2431 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_2437: // Incoming call from 0x033C, returns to 0x033D // Inputs[2] // { // @243C stack[-1] // @243D stack[-2] // } 2437 5B JUMPDEST 2438 60 PUSH1 0x00 243A 60 PUSH1 0x20 243C 82 DUP3 243D 84 DUP5 243E 03 SUB 243F 12 SLT 2440 15 ISZERO 2441 61 PUSH2 0x2449 2444 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2438 stack[0] = 0x00 } // Block ends with conditional jump to 0x2449, if !(stack[-2] - stack[-1] i< 0x20) label_2445: // Incoming jump from 0x2444, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2448 memory[0x00:0x00] } 2445 60 PUSH1 0x00 2447 80 DUP1 2448 FD *REVERT // Stack delta = +0 // Outputs[1] { @2448 revert(memory[0x00:0x00]); } // Block terminates label_2449: // Incoming jump from 0x2444, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @244A stack[-2] // @244B msg.data[stack[-2]:stack[-2] + 0x20] // } 2449 5B JUMPDEST 244A 81 DUP2 244B 35 CALLDATALOAD 244C 67 PUSH8 0xffffffffffffffff 2455 81 DUP2 2456 11 GT 2457 15 ISZERO 2458 61 PUSH2 0x2460 245B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @244B stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2460, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_245C: // Incoming jump from 0x245B, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @245F memory[0x00:0x00] } 245C 60 PUSH1 0x00 245E 80 DUP1 245F FD *REVERT // Stack delta = +0 // Outputs[1] { @245F revert(memory[0x00:0x00]); } // Block terminates label_2460: // Incoming jump from 0x245B, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2461 stack[-3] // @2462 stack[-1] // @2467 stack[-4] // } 2460 5B JUMPDEST 2461 82 DUP3 2462 01 ADD 2463 60 PUSH1 0x1f 2465 81 DUP2 2466 01 ADD 2467 84 DUP5 2468 13 SGT 2469 61 PUSH2 0x2471 246C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2462 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x2471, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_246D: // Incoming jump from 0x246C, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @2470 memory[0x00:0x00] } 246D 60 PUSH1 0x00 246F 80 DUP1 2470 FD *REVERT // Stack delta = +0 // Outputs[1] { @2470 revert(memory[0x00:0x00]); } // Block terminates label_2471: // Incoming jump from 0x246C, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @2475 stack[-4] // @2476 stack[-1] // @2477 msg.data[stack[-1]:stack[-1] + 0x20] // } 2471 5B JUMPDEST 2472 61 PUSH2 0x1529 2475 84 DUP5 2476 82 DUP3 2477 35 CALLDATALOAD 2478 60 PUSH1 0x20 247A 84 DUP5 247B 01 ADD 247C 61 PUSH2 0x23a3 247F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2472 stack[0] = 0x1529 // @2475 stack[1] = stack[-4] // @2477 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @247B stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x23a3, returns to 0x1529 label_2480: // Incoming call from 0x037C, returns to 0x037D // Incoming call from 0x04CF, returns to 0x04D0 // Inputs[2] // { // @2485 stack[-1] // @2486 stack[-2] // } 2480 5B JUMPDEST 2481 60 PUSH1 0x00 2483 60 PUSH1 0x20 2485 82 DUP3 2486 84 DUP5 2487 03 SUB 2488 12 SLT 2489 15 ISZERO 248A 61 PUSH2 0x2492 248D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2481 stack[0] = 0x00 } // Block ends with conditional jump to 0x2492, if !(stack[-2] - stack[-1] i< 0x20) label_248E: // Incoming jump from 0x248D, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2491 memory[0x00:0x00] } 248E 60 PUSH1 0x00 2490 80 DUP1 2491 FD *REVERT // Stack delta = +0 // Outputs[1] { @2491 revert(memory[0x00:0x00]); } // Block terminates label_2492: // Incoming jump from 0x248D, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2496 stack[-2] } 2492 5B JUMPDEST 2493 61 PUSH2 0x223c 2496 82 DUP3 2497 61 PUSH2 0x22e5 249A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2493 stack[0] = 0x223c // @2496 stack[1] = stack[-2] // } // Block ends with call to 0x22e5, returns to 0x223C label_249B: // Incoming call from 0x0419, returns to 0x041A // Inputs[2] // { // @24A1 stack[-1] // @24A2 stack[-2] // } 249B 5B JUMPDEST 249C 60 PUSH1 0x00 249E 80 DUP1 249F 60 PUSH1 0x40 24A1 83 DUP4 24A2 85 DUP6 24A3 03 SUB 24A4 12 SLT 24A5 15 ISZERO 24A6 61 PUSH2 0x24ae 24A9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @249C stack[0] = 0x00 // @249E stack[1] = 0x00 // } // Block ends with conditional jump to 0x24ae, if !(stack[-2] - stack[-1] i< 0x40) label_24AA: // Incoming jump from 0x24A9, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @24AD memory[0x00:0x00] } 24AA 60 PUSH1 0x00 24AC 80 DUP1 24AD FD *REVERT // Stack delta = +0 // Outputs[1] { @24AD revert(memory[0x00:0x00]); } // Block terminates label_24AE: // Incoming jump from 0x24A9, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @24B2 stack[-3] } 24AE 5B JUMPDEST 24AF 61 PUSH2 0x24b7 24B2 83 DUP4 24B3 61 PUSH2 0x22e5 24B6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @24AF stack[0] = 0x24b7 // @24B2 stack[1] = stack[-3] // } // Block ends with call to 0x22e5, returns to 0x24B7 label_24B7: // Incoming return from call to 0x22E5 at 0x24B6 // Inputs[4] // { // @24B8 stack[-1] // @24B8 stack[-3] // @24BC stack[-4] // @24BE msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 24B7 5B JUMPDEST 24B8 91 SWAP2 24B9 50 POP 24BA 60 PUSH1 0x20 24BC 83 DUP4 24BD 01 ADD 24BE 35 CALLDATALOAD 24BF 80 DUP1 24C0 15 ISZERO 24C1 15 ISZERO 24C2 81 DUP2 24C3 14 EQ 24C4 61 PUSH2 0x24cc 24C7 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @24B8 stack[-3] = stack[-1] // @24BE stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x24cc, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_24C8: // Incoming jump from 0x24C7, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[1] { @24CB memory[0x00:0x00] } 24C8 60 PUSH1 0x00 24CA 80 DUP1 24CB FD *REVERT // Stack delta = +0 // Outputs[1] { @24CB revert(memory[0x00:0x00]); } // Block terminates label_24CC: // Incoming jump from 0x24C7, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @24CD stack[-1] // @24CE stack[-2] // @24D1 stack[-5] // @24D3 stack[-3] // @24D3 stack[-6] // @24D4 stack[-4] // } 24CC 5B JUMPDEST 24CD 80 DUP1 24CE 91 SWAP2 24CF 50 POP 24D0 50 POP 24D1 92 SWAP3 24D2 50 POP 24D3 92 SWAP3 24D4 90 SWAP1 24D5 50 POP 24D6 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @24D1 stack[-5] = stack[-1] // @24D3 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_24D7: // Incoming call from 0x0439, returns to 0x043A // Inputs[2] // { // @24E0 stack[-1] // @24E1 stack[-2] // } 24D7 5B JUMPDEST 24D8 60 PUSH1 0x00 24DA 80 DUP1 24DB 60 PUSH1 0x00 24DD 80 DUP1 24DE 60 PUSH1 0x80 24E0 85 DUP6 24E1 87 DUP8 24E2 03 SUB 24E3 12 SLT 24E4 15 ISZERO 24E5 61 PUSH2 0x24ed 24E8 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @24D8 stack[0] = 0x00 // @24DA stack[1] = 0x00 // @24DB stack[2] = 0x00 // @24DD stack[3] = 0x00 // } // Block ends with conditional jump to 0x24ed, if !(stack[-2] - stack[-1] i< 0x80) label_24E9: // Incoming jump from 0x24E8, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @24EC memory[0x00:0x00] } 24E9 60 PUSH1 0x00 24EB 80 DUP1 24EC FD *REVERT // Stack delta = +0 // Outputs[1] { @24EC revert(memory[0x00:0x00]); } // Block terminates label_24ED: // Incoming jump from 0x24E8, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @24F1 stack[-5] } 24ED 5B JUMPDEST 24EE 61 PUSH2 0x24f6 24F1 85 DUP6 24F2 61 PUSH2 0x22e5 24F5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @24EE stack[0] = 0x24f6 // @24F1 stack[1] = stack[-5] // } // Block ends with call to 0x22e5, returns to 0x24F6 label_24F6: // Incoming return from call to 0x22E5 at 0x24F5 // Inputs[3] // { // @24F7 stack[-5] // @24F7 stack[-1] // @24FE stack[-6] // } 24F6 5B JUMPDEST 24F7 93 SWAP4 24F8 50 POP 24F9 61 PUSH2 0x2504 24FC 60 PUSH1 0x20 24FE 86 DUP7 24FF 01 ADD 2500 61 PUSH2 0x22e5 2503 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @24F7 stack[-5] = stack[-1] // @24F9 stack[-1] = 0x2504 // @24FF stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x22e5, returns to 0x2504 label_2504: // Incoming return from call to 0x22E5 at 0x2503 // Inputs[6] // { // @2505 stack[-1] // @2505 stack[-4] // @2509 stack[-6] // @250B msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @250C stack[-3] // @2512 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 2504 5B JUMPDEST 2505 92 SWAP3 2506 50 POP 2507 60 PUSH1 0x40 2509 85 DUP6 250A 01 ADD 250B 35 CALLDATALOAD 250C 91 SWAP2 250D 50 POP 250E 60 PUSH1 0x60 2510 85 DUP6 2511 01 ADD 2512 35 CALLDATALOAD 2513 67 PUSH8 0xffffffffffffffff 251C 81 DUP2 251D 11 GT 251E 15 ISZERO 251F 61 PUSH2 0x2527 2522 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2505 stack[-4] = stack[-1] // @250C stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2512 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x2527, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_2523: // Incoming jump from 0x2522, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2526 memory[0x00:0x00] } 2523 60 PUSH1 0x00 2525 80 DUP1 2526 FD *REVERT // Stack delta = +0 // Outputs[1] { @2526 revert(memory[0x00:0x00]); } // Block terminates label_2527: // Incoming jump from 0x2522, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2528 stack[-6] // @2529 stack[-1] // @252E stack[-7] // } 2527 5B JUMPDEST 2528 85 DUP6 2529 01 ADD 252A 60 PUSH1 0x1f 252C 81 DUP2 252D 01 ADD 252E 87 DUP8 252F 13 SGT 2530 61 PUSH2 0x2538 2533 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2529 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x2538, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_2534: // Incoming jump from 0x2533, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @2537 memory[0x00:0x00] } 2534 60 PUSH1 0x00 2536 80 DUP1 2537 FD *REVERT // Stack delta = +0 // Outputs[1] { @2537 revert(memory[0x00:0x00]); } // Block terminates label_2538: // Incoming jump from 0x2533, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @253C stack[-7] // @253D stack[-1] // @253E msg.data[stack[-1]:stack[-1] + 0x20] // } 2538 5B JUMPDEST 2539 61 PUSH2 0x2547 253C 87 DUP8 253D 82 DUP3 253E 35 CALLDATALOAD 253F 60 PUSH1 0x20 2541 84 DUP5 2542 01 ADD 2543 61 PUSH2 0x23a3 2546 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2539 stack[0] = 0x2547 // @253C stack[1] = stack[-7] // @253E stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2542 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x23a3, returns to 0x2547 label_2547: // Incoming return from call to 0x23A3 at 0x2546 // Inputs[8] // { // @2548 stack[-1] // @2548 stack[-3] // @254B stack[-6] // @254C stack[-9] // @254D stack[-5] // @254E stack[-8] // @2550 stack[-4] // @2550 stack[-7] // } 2547 5B JUMPDEST 2548 91 SWAP2 2549 50 POP 254A 50 POP 254B 92 SWAP3 254C 95 SWAP6 254D 91 SWAP2 254E 94 SWAP5 254F 50 POP 2550 92 SWAP3 2551 50 POP 2552 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @254B stack[-6] = stack[-1] // @254C stack[-9] = stack[-6] // @254E stack[-8] = stack[-5] // @2550 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_2553: // Incoming call from 0x0479, returns to 0x047A // Inputs[2] // { // @2559 stack[-1] // @255A stack[-2] // } 2553 5B JUMPDEST 2554 60 PUSH1 0x00 2556 80 DUP1 2557 60 PUSH1 0x40 2559 83 DUP4 255A 85 DUP6 255B 03 SUB 255C 12 SLT 255D 15 ISZERO 255E 61 PUSH2 0x2566 2561 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2554 stack[0] = 0x00 // @2556 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2566, if !(stack[-2] - stack[-1] i< 0x40) label_2562: // Incoming jump from 0x2561, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2565 memory[0x00:0x00] } 2562 60 PUSH1 0x00 2564 80 DUP1 2565 FD *REVERT // Stack delta = +0 // Outputs[1] { @2565 revert(memory[0x00:0x00]); } // Block terminates label_2566: // Incoming jump from 0x2561, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @256A stack[-3] } 2566 5B JUMPDEST 2567 61 PUSH2 0x256f 256A 83 DUP4 256B 61 PUSH2 0x22e5 256E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2567 stack[0] = 0x256f // @256A stack[1] = stack[-3] // } // Block ends with call to 0x22e5, returns to 0x256F label_256F: // Incoming return from call to 0x22E5 at 0x256E // Inputs[3] // { // @2570 stack[-1] // @2570 stack[-3] // @2577 stack[-4] // } 256F 5B JUMPDEST 2570 91 SWAP2 2571 50 POP 2572 61 PUSH2 0x257d 2575 60 PUSH1 0x20 2577 84 DUP5 2578 01 ADD 2579 61 PUSH2 0x22e5 257C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2570 stack[-3] = stack[-1] // @2572 stack[-1] = 0x257d // @2578 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x22e5, returns to 0x257D label_257D: // Incoming return from call to 0x22E5 at 0x257C // Inputs[6] // { // @257E stack[-2] // @257E stack[-1] // @2580 stack[-5] // @2582 stack[-3] // @2582 stack[-6] // @2583 stack[-4] // } 257D 5B JUMPDEST 257E 90 SWAP1 257F 50 POP 2580 92 SWAP3 2581 50 POP 2582 92 SWAP3 2583 90 SWAP1 2584 50 POP 2585 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2580 stack[-5] = stack[-1] // @2582 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2586: // Incoming call from 0x04F4, returns to 0x04F5 // Incoming call from 0x2163, returns to 0x2164 // Incoming call from 0x0520, returns to 0x0521 // Incoming call from 0x0E4D, returns to 0x04F5 // Incoming call from 0x0DB1, returns to 0x04F5 // Inputs[1] { @2589 stack[-1] } 2586 5B JUMPDEST 2587 60 PUSH1 0x01 2589 81 DUP2 258A 81 DUP2 258B 1C SHR 258C 90 SWAP1 258D 82 DUP3 258E 16 AND 258F 80 DUP1 2590 61 PUSH2 0x259a 2593 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @258C stack[0] = stack[-1] >> 0x01 // @258E stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x259a, if stack[-1] & 0x01 label_2594: // Incoming jump from 0x2593, if not stack[-1] & 0x01 // Inputs[2] // { // @2596 stack[-2] // @259F stack[-1] // } 2594 60 PUSH1 0x7f 2596 82 DUP3 2597 16 AND 2598 91 SWAP2 2599 50 POP 259A 5B JUMPDEST 259B 60 PUSH1 0x20 259D 82 DUP3 259E 10 LT 259F 81 DUP2 25A0 14 EQ 25A1 15 ISZERO 25A2 61 PUSH2 0x25d4 25A5 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2598 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x25d4, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_25A6: // Incoming jump from 0x25A5, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x25A5, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @25D3 memory[0x00:0x24] } 25A6 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 25C7 60 PUSH1 0x00 25C9 52 MSTORE 25CA 60 PUSH1 0x22 25CC 60 PUSH1 0x04 25CE 52 MSTORE 25CF 60 PUSH1 0x24 25D1 60 PUSH1 0x00 25D3 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @25C9 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @25CE memory[0x04:0x24] = 0x22 // @25D3 revert(memory[0x00:0x24]); // } // Block terminates label_25D4: // Incoming jump from 0x25A5, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x25A5, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @25D6 stack[-4] // @25D6 stack[-2] // @25D7 stack[-3] // } 25D4 5B JUMPDEST 25D5 50 POP 25D6 91 SWAP2 25D7 90 SWAP1 25D8 50 POP 25D9 56 *JUMP // Stack delta = -3 // Outputs[1] { @25D6 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_25DA: // Incoming jump from 0x0B7C // Incoming jump from 0x1B7B // Incoming jump from 0x2091 // Incoming jump from 0x20B2 // Inputs[1] { @2608 memory[0x00:0x24] } 25DA 5B JUMPDEST 25DB 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 25FC 60 PUSH1 0x00 25FE 52 MSTORE 25FF 60 PUSH1 0x32 2601 60 PUSH1 0x04 2603 52 MSTORE 2604 60 PUSH1 0x24 2606 60 PUSH1 0x00 2608 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @25FE memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @2603 memory[0x04:0x24] = 0x32 // @2608 revert(memory[0x00:0x24]); // } // Block terminates label_2609: // Incoming jump from 0x264A // Incoming jump from 0x2792 // Incoming jump from 0x275B // Inputs[1] { @2637 memory[0x00:0x24] } 2609 5B JUMPDEST 260A 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 262B 60 PUSH1 0x00 262D 52 MSTORE 262E 60 PUSH1 0x11 2630 60 PUSH1 0x04 2632 52 MSTORE 2633 60 PUSH1 0x24 2635 60 PUSH1 0x00 2637 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @262D memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @2632 memory[0x04:0x24] = 0x11 // @2637 revert(memory[0x00:0x24]); // } // Block terminates label_2638: // Incoming call from 0x1B66, returns to 0x1B67 // Incoming call from 0x0F36, returns to 0x0F37 // Inputs[2] // { // @263B stack[-2] // @263D stack[-1] // } 2638 5B JUMPDEST 2639 60 PUSH1 0x00 263B 82 DUP3 263C 19 NOT 263D 82 DUP3 263E 11 GT 263F 15 ISZERO 2640 61 PUSH2 0x264b 2643 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2639 stack[0] = 0x00 } // Block ends with conditional jump to 0x264b, if !(stack[-1] > ~stack[-2]) label_2644: // Incoming jump from 0x2643, if not !(stack[-1] > ~stack[-2]) 2644 61 PUSH2 0x264b 2647 61 PUSH2 0x2609 264A 56 *JUMP // Stack delta = +1 // Outputs[1] { @2644 stack[0] = 0x264b } // Block ends with unconditional jump to 0x2609 label_264B: // Incoming jump from 0x2643, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @264D stack[-3] // @264D stack[-2] // @264E stack[-4] // } 264B 5B JUMPDEST 264C 50 POP 264D 01 ADD 264E 90 SWAP1 264F 56 *JUMP // Stack delta = -3 // Outputs[1] { @264E stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_2650: // Incoming call from 0x2740, returns to 0x2741 // Inputs[3] // { // @2653 stack[-1] // @2654 memory[stack[-1]:stack[-1] + 0x20] // @2659 stack[-2] // } 2650 5B JUMPDEST 2651 60 PUSH1 0x00 2653 81 DUP2 2654 51 MLOAD 2655 61 PUSH2 0x2662 2658 81 DUP2 2659 85 DUP6 265A 60 PUSH1 0x20 265C 86 DUP7 265D 01 ADD 265E 61 PUSH2 0x2243 2661 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2651 stack[0] = 0x00 // @2654 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @2655 stack[2] = 0x2662 // @2658 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @2659 stack[4] = stack[-2] // @265D stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x2243, returns to 0x2662 label_2662: // Incoming return from call to 0x2243 at 0x2661 // Inputs[4] // { // @2663 stack[-1] // @2663 stack[-4] // @2664 stack[-2] // @2667 stack[-5] // } 2662 5B JUMPDEST 2663 92 SWAP3 2664 90 SWAP1 2665 92 SWAP3 2666 01 ADD 2667 92 SWAP3 2668 91 SWAP2 2669 50 POP 266A 50 POP 266B 56 *JUMP // Stack delta = -4 // Outputs[1] { @2667 stack[-5] = stack[-1] + stack[-4] } // Block ends with unconditional jump to stack[-5] label_266C: // Incoming call from 0x1187, returns to 0x1188 // Inputs[2] // { // @2670 stack[-3] // @2671 storage[stack[-3]] // } 266C 5B JUMPDEST 266D 60 PUSH1 0x00 266F 80 DUP1 2670 84 DUP5 2671 54 SLOAD 2672 81 DUP2 2673 60 PUSH1 0x01 2675 82 DUP3 2676 81 DUP2 2677 1C SHR 2678 91 SWAP2 2679 50 POP 267A 80 DUP1 267B 83 DUP4 267C 16 AND 267D 80 DUP1 267E 61 PUSH2 0x2688 2681 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @266D stack[0] = 0x00 // @266F stack[1] = 0x00 // @2671 stack[2] = storage[stack[-3]] // @2673 stack[4] = 0x01 // @2678 stack[3] = storage[stack[-3]] >> 0x01 // @267C stack[5] = storage[stack[-3]] & 0x01 // } // Block ends with conditional jump to 0x2688, if storage[stack[-3]] & 0x01 label_2682: // Incoming jump from 0x2681, if not storage[stack[-3]] & 0x01 // Inputs[2] // { // @2684 stack[-3] // @268E stack[-1] // } 2682 60 PUSH1 0x7f 2684 83 DUP4 2685 16 AND 2686 92 SWAP3 2687 50 POP 2688 5B JUMPDEST 2689 60 PUSH1 0x20 268B 80 DUP1 268C 84 DUP5 268D 10 LT 268E 82 DUP3 268F 14 EQ 2690 15 ISZERO 2691 61 PUSH2 0x26c1 2694 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @2686 stack[-3] = stack[-3] & 0x7f // @2689 stack[0] = 0x20 // } // Block ends with conditional jump to 0x26c1, if !(stack[-1] == (stack[-3] & 0x7f < 0x20)) label_2695: // Incoming jump from 0x2694, if not !(stack[-1] == (stack[-3] & 0x7f < 0x20)) // Incoming jump from 0x2694, if not !(stack[-1] == (stack[-3] < 0x20)) // Inputs[2] // { // @26B6 stack[-6] // @26C0 memory[stack[-6]:stack[-6] + 0x24] // } 2695 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 26B6 86 DUP7 26B7 52 MSTORE 26B8 60 PUSH1 0x22 26BA 60 PUSH1 0x04 26BC 52 MSTORE 26BD 60 PUSH1 0x24 26BF 86 DUP7 26C0 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @26B7 memory[stack[-6]:stack[-6] + 0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @26BC memory[0x04:0x24] = 0x22 // @26C0 revert(memory[stack[-6]:stack[-6] + 0x24]); // } // Block terminates label_26C1: // Incoming jump from 0x2694, if !(stack[-1] == (stack[-3] & 0x7f < 0x20)) // Incoming jump from 0x2694, if !(stack[-1] == (stack[-3] < 0x20)) // Inputs[1] { @26C2 stack[-2] } 26C1 5B JUMPDEST 26C2 81 DUP2 26C3 80 DUP1 26C4 15 ISZERO 26C5 61 PUSH2 0x26d5 26C8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26C2 stack[0] = stack[-2] } // Block ends with conditional jump to 0x26d5, if !stack[-2] label_26C9: // Incoming jump from 0x26C8, if not !stack[-2] // Inputs[1] { @26CB stack[-1] } 26C9 60 PUSH1 0x01 26CB 81 DUP2 26CC 14 EQ 26CD 61 PUSH2 0x2704 26D0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2704, if stack[-1] == 0x01 label_26D1: // Incoming jump from 0x26D0, if not stack[-1] == 0x01 26D1 61 PUSH2 0x2731 26D4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2731 label_26D5: // Incoming jump from 0x26C8, if !stack[-2] // Inputs[4] // { // @26F7 stack[-6] // @26F9 stack[-9] // @26FB stack[-5] // @26FE stack[-7] // } 26D5 5B JUMPDEST 26D6 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 26F7 86 DUP7 26F8 16 AND 26F9 89 DUP10 26FA 52 MSTORE 26FB 84 DUP5 26FC 89 DUP10 26FD 01 ADD 26FE 96 SWAP7 26FF 50 POP 2700 61 PUSH2 0x2731 2703 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @26FA memory[stack[-9]:stack[-9] + 0x20] = stack[-6] & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 // @26FE stack[-7] = stack[-9] + stack[-5] // } // Block ends with unconditional jump to 0x2731 label_2704: // Incoming jump from 0x26D0, if stack[-1] == 0x01 // Inputs[3] // { // @2707 stack[-11] // @270D memory[0x00:0x20] // @2711 stack[-5] // } 2704 5B JUMPDEST 2705 60 PUSH1 0x00 2707 8B DUP12 2708 81 DUP2 2709 52 MSTORE 270A 60 PUSH1 0x20 270C 90 SWAP1 270D 20 SHA3 270E 60 PUSH1 0x00 2710 5B JUMPDEST 2711 86 DUP7 2712 81 DUP2 2713 10 LT 2714 15 ISZERO 2715 61 PUSH2 0x2729 2718 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2709 memory[0x00:0x20] = stack[-11] // @270D stack[0] = keccak256(memory[0x00:0x20]) // @270E stack[1] = 0x00 // } // Block ends with conditional jump to 0x2729, if !(0x00 < stack[-5]) label_2719: // Incoming jump from 0x2718, if not !(0x00 < stack[-5]) // Incoming jump from 0x2718, if not !(stack[-1] < stack[-7]) // Inputs[6] // { // @2719 stack[-2] // @271A storage[stack[-2]] // @271B stack[-11] // @271C stack[-1] // @2720 stack[-6] // @2723 stack[-4] // } 2719 81 DUP2 271A 54 SLOAD 271B 8B DUP12 271C 82 DUP3 271D 01 ADD 271E 52 MSTORE 271F 90 SWAP1 2720 85 DUP6 2721 01 ADD 2722 90 SWAP1 2723 83 DUP4 2724 01 ADD 2725 61 PUSH2 0x2710 2728 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @271E memory[stack[-1] + stack[-11]:stack[-1] + stack[-11] + 0x20] = storage[stack[-2]] // @2722 stack[-2] = stack[-6] + stack[-2] // @2724 stack[-1] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x2710 label_2729: // Incoming jump from 0x2718, if !(0x00 < stack[-5]) // Incoming jump from 0x2718, if !(stack[-1] < stack[-7]) // Inputs[3] // { // @272C stack[-7] // @272D stack[-11] // @272F stack[-9] // } 2729 5B JUMPDEST 272A 50 POP 272B 50 POP 272C 84 DUP5 272D 89 DUP10 272E 01 ADD 272F 96 SWAP7 2730 50 POP // Stack delta = -2 // Outputs[1] { @272F stack[-9] = stack[-11] + stack[-7] } // Block continues label_2731: // Incoming jump from 0x2730 // Incoming jump from 0x2703 // Incoming jump from 0x26D4 // Inputs[2] // { // @273B stack[-7] // @273C stack[-10] // } 2731 5B JUMPDEST 2732 50 POP 2733 50 POP 2734 50 POP 2735 50 POP 2736 50 POP 2737 50 POP 2738 61 PUSH2 0x2741 273B 81 DUP2 273C 85 DUP6 273D 61 PUSH2 0x2650 2740 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @2738 stack[-6] = 0x2741 // @273B stack[-5] = stack[-7] // @273C stack[-4] = stack[-10] // } // Block ends with call to 0x2650, returns to 0x2741 label_2741: // Incoming return from call to 0x2650 at 0x2740 // Inputs[3] // { // @2742 stack[-1] // @2742 stack[-7] // @2743 stack[-6] // } 2741 5B JUMPDEST 2742 95 SWAP6 2743 94 SWAP5 2744 50 POP 2745 50 POP 2746 50 POP 2747 50 POP 2748 50 POP 2749 56 *JUMP // Stack delta = -6 // Outputs[1] { @2742 stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] label_274A: // Incoming call from 0x1B4E, returns to 0x1B4F // Incoming call from 0x2069, returns to 0x206A // Incoming call from 0x1FB7, returns to 0x1FB8 // Inputs[2] // { // @274D stack[-2] // @274E stack[-1] // } 274A 5B JUMPDEST 274B 60 PUSH1 0x00 274D 82 DUP3 274E 82 DUP3 274F 10 LT 2750 15 ISZERO 2751 61 PUSH2 0x275c 2754 57 *JUMPI // Stack delta = +1 // Outputs[1] { @274B stack[0] = 0x00 } // Block ends with conditional jump to 0x275c, if !(stack[-1] < stack[-2]) label_2755: // Incoming jump from 0x2754, if not !(stack[-1] < stack[-2]) 2755 61 PUSH2 0x275c 2758 61 PUSH2 0x2609 275B 56 *JUMP // Stack delta = +1 // Outputs[1] { @2755 stack[0] = 0x275c } // Block ends with unconditional jump to 0x2609 label_275C: // Incoming jump from 0x2754, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @275E stack[-3] // @275E stack[-2] // @275F stack[-4] // } 275C 5B JUMPDEST 275D 50 POP 275E 03 SUB 275F 90 SWAP1 2760 56 *JUMP // Stack delta = -3 // Outputs[1] { @275F stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_2761: // Incoming call from 0x1ADE, returns to 0x1ADF // Inputs[1] { @2785 stack[-1] } 2761 5B JUMPDEST 2762 60 PUSH1 0x00 2764 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2785 82 DUP3 2786 14 EQ 2787 15 ISZERO 2788 61 PUSH2 0x2793 278B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2762 stack[0] = 0x00 } // Block ends with conditional jump to 0x2793, if !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) label_278C: // Incoming jump from 0x278B, if not !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) 278C 61 PUSH2 0x2793 278F 61 PUSH2 0x2609 2792 56 *JUMP // Stack delta = +1 // Outputs[1] { @278C stack[0] = 0x2793 } // Block ends with unconditional jump to 0x2609 label_2793: // Incoming jump from 0x278B, if !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // Inputs[2] // { // @2797 stack[-2] // @2798 stack[-3] // } 2793 5B JUMPDEST 2794 50 POP 2795 60 PUSH1 0x01 2797 01 ADD 2798 90 SWAP1 2799 56 *JUMP // Stack delta = -2 // Outputs[1] { @2798 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_279A: // Incoming jump from 0x27EB // Incoming jump from 0x27D7 // Inputs[1] { @27C8 memory[0x00:0x24] } 279A 5B JUMPDEST 279B 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 27BC 60 PUSH1 0x00 27BE 52 MSTORE 27BF 60 PUSH1 0x12 27C1 60 PUSH1 0x04 27C3 52 MSTORE 27C4 60 PUSH1 0x24 27C6 60 PUSH1 0x00 27C8 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @27BE memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @27C3 memory[0x04:0x24] = 0x12 // @27C8 revert(memory[0x00:0x24]); // } // Block terminates label_27C9: // Incoming call from 0x1AED, returns to 0x1AEE // Incoming call from 0x1BB5, returns to 0x1BB6 // Inputs[1] { @27CC stack[-2] } 27C9 5B JUMPDEST 27CA 60 PUSH1 0x00 27CC 82 DUP3 27CD 61 PUSH2 0x27d8 27D0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @27CA stack[0] = 0x00 } // Block ends with conditional jump to 0x27d8, if stack[-2] label_27D1: // Incoming jump from 0x27D0, if not stack[-2] 27D1 61 PUSH2 0x27d8 27D4 61 PUSH2 0x279a 27D7 56 *JUMP // Stack delta = +1 // Outputs[1] { @27D1 stack[0] = 0x27d8 } // Block ends with unconditional jump to 0x279a label_27D8: // Incoming jump from 0x27D0, if stack[-2] // Inputs[3] // { // @27DA stack[-2] // @27DA stack[-3] // @27DB stack[-4] // } 27D8 5B JUMPDEST 27D9 50 POP 27DA 04 DIV 27DB 90 SWAP1 27DC 56 *JUMP // Stack delta = -3 // Outputs[1] { @27DB stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_27DD: // Incoming call from 0x1B5B, returns to 0x1B5C // Inputs[1] { @27E0 stack[-2] } 27DD 5B JUMPDEST 27DE 60 PUSH1 0x00 27E0 82 DUP3 27E1 61 PUSH2 0x27ec 27E4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @27DE stack[0] = 0x00 } // Block ends with conditional jump to 0x27ec, if stack[-2] label_27E5: // Incoming jump from 0x27E4, if not stack[-2] 27E5 61 PUSH2 0x27ec 27E8 61 PUSH2 0x279a 27EB 56 *JUMP // Stack delta = +1 // Outputs[1] { @27E5 stack[0] = 0x27ec } // Block ends with unconditional jump to 0x279a label_27EC: // Incoming jump from 0x27E4, if stack[-2] // Inputs[3] // { // @27EE stack[-3] // @27EE stack[-2] // @27EF stack[-4] // } 27EC 5B JUMPDEST 27ED 50 POP 27EE 06 MOD 27EF 90 SWAP1 27F0 56 *JUMP // Stack delta = -3 // Outputs[1] { @27EF stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] 27F1 5B JUMPDEST 27F2 60 PUSH1 0x00 27F4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2809 80 DUP1 280A 87 DUP8 280B 16 AND 280C 83 DUP4 280D 52 MSTORE 280E 80 DUP1 280F 86 DUP7 2810 16 AND 2811 60 PUSH1 0x20 2813 84 DUP5 2814 01 ADD 2815 52 MSTORE 2816 50 POP 2817 83 DUP4 2818 60 PUSH1 0x40 281A 83 DUP4 281B 01 ADD 281C 52 MSTORE 281D 60 PUSH1 0x80 281F 60 PUSH1 0x60 2821 83 DUP4 2822 01 ADD 2823 52 MSTORE 2824 61 PUSH2 0x2830 2827 60 PUSH1 0x80 2829 83 DUP4 282A 01 ADD 282B 84 DUP5 282C 61 PUSH2 0x226f 282F 56 *JUMP 2830 5B JUMPDEST 2831 96 SWAP7 2832 95 SWAP6 2833 50 POP 2834 50 POP 2835 50 POP 2836 50 POP 2837 50 POP 2838 50 POP 2839 56 *JUMP 283A 5B JUMPDEST 283B 60 PUSH1 0x00 283D 60 PUSH1 0x20 283F 82 DUP3 2840 84 DUP5 2841 03 SUB 2842 12 SLT 2843 15 ISZERO 2844 61 PUSH2 0x284c 2847 57 *JUMPI 2848 60 PUSH1 0x00 284A 80 DUP1 284B FD *REVERT 284C 5B JUMPDEST 284D 81 DUP2 284E 51 MLOAD 284F 61 PUSH2 0x223c 2852 81 DUP2 2853 61 PUSH2 0x21f1 2856 56 *JUMP label_2857: // Incoming jump from 0x20EA // Inputs[1] { @2885 memory[0x00:0x24] } 2857 5B JUMPDEST 2858 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 2879 60 PUSH1 0x00 287B 52 MSTORE 287C 60 PUSH1 0x31 287E 60 PUSH1 0x04 2880 52 MSTORE 2881 60 PUSH1 0x24 2883 60 PUSH1 0x00 2885 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @287B memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @2880 memory[0x04:0x24] = 0x31 // @2885 revert(memory[0x00:0x24]); // } // Block terminates 2886 FE *ASSERT 2887 A2 LOG2 2888 64 PUSH5 0x6970667358 288E 22 22 288F 12 SLT 2890 20 SHA3 2891 84 DUP5 2892 0F 0F 2893 15 ISZERO 2894 53 MSTORE8 2895 69 PUSH10 0x83d432f5ea9b15260ce1 28A0 B4 B4 28A1 03 SUB 28A2 0C 0C 28A3 3B EXTCODESIZE 28A4 49 49 28A5 F5 CREATE2 28A6 20 SHA3 28A7 7B PUSH28 0x9b562de2df7f411c4964736f6c634300080a0033