Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x015f 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x015f, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x01ffc9a7 0026 14 EQ 0027 61 PUSH2 0x0164 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0164, if 0x01ffc9a7 == msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x01ffc9a7 == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0x06fdde03 0031 14 EQ 0032 61 PUSH2 0x018c 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x018c, if 0x06fdde03 == stack[-1] label_0036: // Incoming jump from 0x0035, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0x081812fc 003C 14 EQ 003D 61 PUSH2 0x01a1 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a1, if 0x081812fc == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0x081812fc == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0x095ea7b3 0047 14 EQ 0048 61 PUSH2 0x01c1 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c1, if 0x095ea7b3 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0x23b872dd 0052 14 EQ 0053 61 PUSH2 0x01d6 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d6, if 0x23b872dd == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0x23b872dd == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0x2a55205a 005D 14 EQ 005E 61 PUSH2 0x01e9 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e9, if 0x2a55205a == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0x2a55205a == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0x40c10f19 0068 14 EQ 0069 61 PUSH2 0x021b 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x021b, if 0x40c10f19 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0x40c10f19 == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0x414661c5 0073 14 EQ 0074 61 PUSH2 0x022e 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x022e, if 0x414661c5 == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0x414661c5 == stack[-1] // Inputs[1] { @0078 stack[-1] } 0078 80 DUP1 0079 63 PUSH4 0x42842e0e 007E 14 EQ 007F 61 PUSH2 0x0241 0082 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0241, if 0x42842e0e == stack[-1] label_0083: // Incoming jump from 0x0082, if not 0x42842e0e == stack[-1] // Inputs[1] { @0083 stack[-1] } 0083 80 DUP1 0084 63 PUSH4 0x45541621 0089 14 EQ 008A 61 PUSH2 0x0254 008D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0254, if 0x45541621 == stack[-1] label_008E: // Incoming jump from 0x008D, if not 0x45541621 == stack[-1] // Inputs[1] { @008E stack[-1] } 008E 80 DUP1 008F 63 PUSH4 0x6352211e 0094 14 EQ 0095 61 PUSH2 0x0267 0098 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0267, if 0x6352211e == stack[-1] label_0099: // Incoming jump from 0x0098, if not 0x6352211e == stack[-1] // Inputs[1] { @0099 stack[-1] } 0099 80 DUP1 009A 63 PUSH4 0x6cc247e0 009F 14 EQ 00A0 61 PUSH2 0x027a 00A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027a, if 0x6cc247e0 == stack[-1] label_00A4: // Incoming jump from 0x00A3, if not 0x6cc247e0 == stack[-1] // Inputs[1] { @00A4 stack[-1] } 00A4 80 DUP1 00A5 63 PUSH4 0x70a08231 00AA 14 EQ 00AB 61 PUSH2 0x028d 00AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x028d, if 0x70a08231 == stack[-1] label_00AF: // Incoming jump from 0x00AE, if not 0x70a08231 == stack[-1] // Inputs[1] { @00AF stack[-1] } 00AF 80 DUP1 00B0 63 PUSH4 0x715018a6 00B5 14 EQ 00B6 61 PUSH2 0x02ae 00B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ae, if 0x715018a6 == stack[-1] label_00BA: // Incoming jump from 0x00B9, if not 0x715018a6 == stack[-1] // Inputs[1] { @00BA stack[-1] } 00BA 80 DUP1 00BB 63 PUSH4 0x889a3f19 00C0 14 EQ 00C1 61 PUSH2 0x02b6 00C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b6, if 0x889a3f19 == stack[-1] label_00C5: // Incoming jump from 0x00C4, if not 0x889a3f19 == stack[-1] // Inputs[1] { @00C5 stack[-1] } 00C5 80 DUP1 00C6 63 PUSH4 0x8cffd16a 00CB 14 EQ 00CC 61 PUSH2 0x02be 00CF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02be, if 0x8cffd16a == stack[-1] label_00D0: // Incoming jump from 0x00CF, if not 0x8cffd16a == stack[-1] // Inputs[1] { @00D0 stack[-1] } 00D0 80 DUP1 00D1 63 PUSH4 0x8da5cb5b 00D6 14 EQ 00D7 61 PUSH2 0x02d1 00DA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d1, if 0x8da5cb5b == stack[-1] label_00DB: // Incoming jump from 0x00DA, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00DB stack[-1] } 00DB 80 DUP1 00DC 63 PUSH4 0x95d89b41 00E1 14 EQ 00E2 61 PUSH2 0x02d9 00E5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d9, if 0x95d89b41 == stack[-1] label_00E6: // Incoming jump from 0x00E5, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00E6 stack[-1] } 00E6 80 DUP1 00E7 63 PUSH4 0x9a6a9670 00EC 14 EQ 00ED 61 PUSH2 0x02e1 00F0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e1, if 0x9a6a9670 == stack[-1] label_00F1: // Incoming jump from 0x00F0, if not 0x9a6a9670 == stack[-1] // Inputs[1] { @00F1 stack[-1] } 00F1 80 DUP1 00F2 63 PUSH4 0xa22cb465 00F7 14 EQ 00F8 61 PUSH2 0x0313 00FB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0313, if 0xa22cb465 == stack[-1] label_00FC: // Incoming jump from 0x00FB, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00FC stack[-1] } 00FC 80 DUP1 00FD 63 PUSH4 0xb88d4fde 0102 14 EQ 0103 61 PUSH2 0x0326 0106 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0326, if 0xb88d4fde == stack[-1] label_0107: // Incoming jump from 0x0106, if not 0xb88d4fde == stack[-1] // Inputs[1] { @0107 stack[-1] } 0107 80 DUP1 0108 63 PUSH4 0xc87b56dd 010D 14 EQ 010E 61 PUSH2 0x0339 0111 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0339, if 0xc87b56dd == stack[-1] label_0112: // Incoming jump from 0x0111, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0112 stack[-1] } 0112 80 DUP1 0113 63 PUSH4 0xcad96cca 0118 14 EQ 0119 61 PUSH2 0x034c 011C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x034c, if 0xcad96cca == stack[-1] label_011D: // Incoming jump from 0x011C, if not 0xcad96cca == stack[-1] // Inputs[1] { @011D stack[-1] } 011D 80 DUP1 011E 63 PUSH4 0xcd3a8e27 0123 14 EQ 0124 61 PUSH2 0x036c 0127 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036c, if 0xcd3a8e27 == stack[-1] label_0128: // Incoming jump from 0x0127, if not 0xcd3a8e27 == stack[-1] // Inputs[1] { @0128 stack[-1] } 0128 80 DUP1 0129 63 PUSH4 0xcd7c0326 012E 14 EQ 012F 61 PUSH2 0x037f 0132 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037f, if 0xcd7c0326 == stack[-1] label_0133: // Incoming jump from 0x0132, if not 0xcd7c0326 == stack[-1] // Inputs[1] { @0133 stack[-1] } 0133 80 DUP1 0134 63 PUSH4 0xe985e9c5 0139 14 EQ 013A 61 PUSH2 0x0392 013D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0392, if 0xe985e9c5 == stack[-1] label_013E: // Incoming jump from 0x013D, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @013E stack[-1] } 013E 80 DUP1 013F 63 PUSH4 0xea3a8248 0144 14 EQ 0145 61 PUSH2 0x03a5 0148 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a5, if 0xea3a8248 == stack[-1] label_0149: // Incoming jump from 0x0148, if not 0xea3a8248 == stack[-1] // Inputs[1] { @0149 stack[-1] } 0149 80 DUP1 014A 63 PUSH4 0xed00c02d 014F 14 EQ 0150 61 PUSH2 0x03b8 0153 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b8, if 0xed00c02d == stack[-1] label_0154: // Incoming jump from 0x0153, if not 0xed00c02d == stack[-1] // Inputs[1] { @0154 stack[-1] } 0154 80 DUP1 0155 63 PUSH4 0xf2fde38b 015A 14 EQ 015B 61 PUSH2 0x03cb 015E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03cb, if 0xf2fde38b == stack[-1] label_015F: // Incoming jump from 0x015E, if not 0xf2fde38b == stack[-1] // Incoming jump from 0x0019, if msg.data.length < 0x04 // Inputs[1] { @0163 memory[0x00:0x00] } 015F 5B JUMPDEST 0160 60 PUSH1 0x00 0162 80 DUP1 0163 FD *REVERT // Stack delta = +0 // Outputs[1] { @0163 revert(memory[0x00:0x00]); } // Block terminates label_0164: // Incoming jump from 0x002A, if 0x01ffc9a7 == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @016B msg.data.length } 0164 5B JUMPDEST 0165 61 PUSH2 0x0177 0168 61 PUSH2 0x0172 016B 36 CALLDATASIZE 016C 60 PUSH1 0x04 016E 61 PUSH2 0x1795 0171 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0165 stack[0] = 0x0177 // @0168 stack[1] = 0x0172 // @016B stack[2] = msg.data.length // @016C stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1795 0172 5B JUMPDEST 0173 61 PUSH2 0x03de 0176 56 *JUMP 0177 5B JUMPDEST 0178 60 PUSH1 0x40 017A 51 MLOAD 017B 90 SWAP1 017C 15 ISZERO 017D 15 ISZERO 017E 81 DUP2 017F 52 MSTORE 0180 60 PUSH1 0x20 0182 01 ADD label_0183: // Incoming jump from 0x0312 // Incoming return from call to 0x1AA7 at 0x036B // Incoming jump from 0x021A // Incoming return from call to 0x1836 at 0x01C0 // Inputs[3] // { // @0186 memory[0x40:0x60] // @0188 stack[-1] // @018B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0183 5B JUMPDEST 0184 60 PUSH1 0x40 0186 51 MLOAD 0187 80 DUP1 0188 91 SWAP2 0189 03 SUB 018A 90 SWAP1 018B F3 *RETURN // Stack delta = -1 // Outputs[1] { @018B return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_018C: // Incoming jump from 0x0035, if 0x06fdde03 == stack[-1] 018C 5B JUMPDEST 018D 61 PUSH2 0x0194 0190 61 PUSH2 0x0431 0193 56 *JUMP // Stack delta = +1 // Outputs[1] { @018D stack[0] = 0x0194 } // Block ends with call to 0x0431, returns to 0x0194 label_0194: // Incoming return from call to 0x0992 at 0x02BD // Incoming return from call to 0x09FF at 0x02E0 // Incoming return from call to 0x0262 at 0x0261 // Incoming return from call to 0x0431 at 0x0193 // Incoming return from call to 0x0347 at 0x0346 // Inputs[2] // { // @0197 memory[0x40:0x60] // @019B stack[-1] // } 0194 5B JUMPDEST 0195 60 PUSH1 0x40 0197 51 MLOAD 0198 61 PUSH2 0x0183 019B 91 SWAP2 019C 90 SWAP1 019D 61 PUSH2 0x180a 01A0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @019B stack[-1] = 0x0183 // @019C stack[1] = memory[0x40:0x60] // @019C stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x180a label_01A1: // Incoming jump from 0x0040, if 0x081812fc == stack[-1] // Inputs[1] { @01A8 msg.data.length } 01A1 5B JUMPDEST 01A2 61 PUSH2 0x01b4 01A5 61 PUSH2 0x01af 01A8 36 CALLDATASIZE 01A9 60 PUSH1 0x04 01AB 61 PUSH2 0x181d 01AE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01A2 stack[0] = 0x01b4 // @01A5 stack[1] = 0x01af // @01A8 stack[2] = msg.data.length // @01A9 stack[3] = 0x04 // } // Block ends with call to 0x181d, returns to 0x01AF label_01AF: // Incoming return from call to 0x181D at 0x01AE 01AF 5B JUMPDEST 01B0 61 PUSH2 0x04c3 01B3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04c3 label_01B4: // Incoming return from call to 0x01AF at 0x01AE // Incoming jump from 0x037E // Incoming return from call to 0x09F0 at 0x02D8 // Incoming jump from 0x0391 // Incoming return from call to 0x0275 at 0x0274 // Inputs[2] // { // @01B7 memory[0x40:0x60] // @01BB stack[-1] // } 01B4 5B JUMPDEST 01B5 60 PUSH1 0x40 01B7 51 MLOAD 01B8 61 PUSH2 0x0183 01BB 91 SWAP2 01BC 90 SWAP1 01BD 61 PUSH2 0x1836 01C0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01BB stack[-1] = 0x0183 // @01BC stack[1] = memory[0x40:0x60] // @01BC stack[0] = stack[-1] // } // Block ends with call to 0x1836, returns to 0x0183 label_01C1: // Incoming jump from 0x004B, if 0x095ea7b3 == stack[-1] // Inputs[1] { @01C8 msg.data.length } 01C1 5B JUMPDEST 01C2 61 PUSH2 0x01d4 01C5 61 PUSH2 0x01cf 01C8 36 CALLDATASIZE 01C9 60 PUSH1 0x04 01CB 61 PUSH2 0x185f 01CE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01C2 stack[0] = 0x01d4 // @01C5 stack[1] = 0x01cf // @01C8 stack[2] = msg.data.length // @01C9 stack[3] = 0x04 // } // Block ends with call to 0x185f, returns to 0x01CF label_01CF: // Incoming return from call to 0x185F at 0x01CE 01CF 5B JUMPDEST 01D0 61 PUSH2 0x0550 01D3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0550 label_01D4: // Incoming return from call to 0x0321 at 0x0320 // Incoming return from call to 0x03C6 at 0x03C5 // Incoming return from call to 0x01CF at 0x01CE // Incoming return from call to 0x0229 at 0x0228 // Incoming return from call to 0x0957 at 0x02B5 01D4 5B JUMPDEST 01D5 00 *STOP // Stack delta = +0 // Outputs[1] { @01D5 stop(); } // Block terminates label_01D6: // Incoming jump from 0x0056, if 0x23b872dd == stack[-1] // Inputs[1] { @01DD msg.data.length } 01D6 5B JUMPDEST 01D7 61 PUSH2 0x01d4 01DA 61 PUSH2 0x01e4 01DD 36 CALLDATASIZE 01DE 60 PUSH1 0x04 01E0 61 PUSH2 0x188b 01E3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01D7 stack[0] = 0x01d4 // @01DA stack[1] = 0x01e4 // @01DD stack[2] = msg.data.length // @01DE stack[3] = 0x04 // } // Block ends with call to 0x188b, returns to 0x01E4 label_01E4: // Incoming return from call to 0x188B at 0x01E3 01E4 5B JUMPDEST 01E5 61 PUSH2 0x0661 01E8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0661 label_01E9: // Incoming jump from 0x0061, if 0x2a55205a == stack[-1] // Inputs[1] { @01F0 msg.data.length } 01E9 5B JUMPDEST 01EA 61 PUSH2 0x01fc 01ED 61 PUSH2 0x01f7 01F0 36 CALLDATASIZE 01F1 60 PUSH1 0x04 01F3 61 PUSH2 0x18cc 01F6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01EA stack[0] = 0x01fc // @01ED stack[1] = 0x01f7 // @01F0 stack[2] = msg.data.length // @01F1 stack[3] = 0x04 // } // Block ends with call to 0x18cc, returns to 0x01F7 label_01F7: // Incoming return from call to 0x18CC at 0x01F6 01F7 5B JUMPDEST 01F8 61 PUSH2 0x0692 01FB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0692 label_01FC: // Incoming return from call to 0x01F7 at 0x01F6 // Inputs[3] // { // @0200 memory[0x40:0x60] // @020A stack[-2] // @0212 stack[-1] // } 01FC 5B JUMPDEST 01FD 60 PUSH1 0x40 01FF 80 DUP1 0200 51 MLOAD 0201 60 PUSH1 0x01 0203 60 PUSH1 0x01 0205 60 PUSH1 0xa0 0207 1B SHL 0208 03 SUB 0209 90 SWAP1 020A 93 SWAP4 020B 16 AND 020C 83 DUP4 020D 52 MSTORE 020E 60 PUSH1 0x20 0210 83 DUP4 0211 01 ADD 0212 91 SWAP2 0213 90 SWAP1 0214 91 SWAP2 0215 52 MSTORE 0216 01 ADD 0217 61 PUSH2 0x0183 021A 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @020D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0215 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @0216 stack[-2] = 0x40 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0183 label_021B: // Incoming jump from 0x006C, if 0x40c10f19 == stack[-1] // Inputs[1] { @0222 msg.data.length } 021B 5B JUMPDEST 021C 61 PUSH2 0x01d4 021F 61 PUSH2 0x0229 0222 36 CALLDATASIZE 0223 60 PUSH1 0x04 0225 61 PUSH2 0x185f 0228 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @021C stack[0] = 0x01d4 // @021F stack[1] = 0x0229 // @0222 stack[2] = msg.data.length // @0223 stack[3] = 0x04 // } // Block ends with call to 0x185f, returns to 0x0229 label_0229: // Incoming return from call to 0x185F at 0x0228 0229 5B JUMPDEST 022A 61 PUSH2 0x06dc 022D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06dc label_022E: // Incoming jump from 0x0077, if 0x414661c5 == stack[-1] // Inputs[1] { @0235 msg.data.length } 022E 5B JUMPDEST 022F 61 PUSH2 0x01d4 0232 61 PUSH2 0x023c 0235 36 CALLDATASIZE 0236 60 PUSH1 0x04 0238 61 PUSH2 0x181d 023B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @022F stack[0] = 0x01d4 // @0232 stack[1] = 0x023c // @0235 stack[2] = msg.data.length // @0236 stack[3] = 0x04 // } // Block ends with call to 0x181d, returns to 0x023C label_023C: // Incoming return from call to 0x181D at 0x023B 023C 5B JUMPDEST 023D 61 PUSH2 0x0719 0240 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0719 label_0241: // Incoming jump from 0x0082, if 0x42842e0e == stack[-1] // Inputs[1] { @0248 msg.data.length } 0241 5B JUMPDEST 0242 61 PUSH2 0x01d4 0245 61 PUSH2 0x024f 0248 36 CALLDATASIZE 0249 60 PUSH1 0x04 024B 61 PUSH2 0x188b 024E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0242 stack[0] = 0x01d4 // @0245 stack[1] = 0x024f // @0248 stack[2] = msg.data.length // @0249 stack[3] = 0x04 // } // Block ends with call to 0x188b, returns to 0x024F label_024F: // Incoming return from call to 0x188B at 0x024E 024F 5B JUMPDEST 0250 61 PUSH2 0x0762 0253 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0762 label_0254: // Incoming jump from 0x008D, if 0x45541621 == stack[-1] // Inputs[1] { @025B msg.data.length } 0254 5B JUMPDEST 0255 61 PUSH2 0x0194 0258 61 PUSH2 0x0262 025B 36 CALLDATASIZE 025C 60 PUSH1 0x04 025E 61 PUSH2 0x181d 0261 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0255 stack[0] = 0x0194 // @0258 stack[1] = 0x0262 // @025B stack[2] = msg.data.length // @025C stack[3] = 0x04 // } // Block ends with call to 0x181d, returns to 0x0262 label_0262: // Incoming return from call to 0x181D at 0x0261 0262 5B JUMPDEST 0263 61 PUSH2 0x077d 0266 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x077d label_0267: // Incoming jump from 0x0098, if 0x6352211e == stack[-1] // Inputs[1] { @026E msg.data.length } 0267 5B JUMPDEST 0268 61 PUSH2 0x01b4 026B 61 PUSH2 0x0275 026E 36 CALLDATASIZE 026F 60 PUSH1 0x04 0271 61 PUSH2 0x181d 0274 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0268 stack[0] = 0x01b4 // @026B stack[1] = 0x0275 // @026E stack[2] = msg.data.length // @026F stack[3] = 0x04 // } // Block ends with call to 0x181d, returns to 0x0275 label_0275: // Incoming return from call to 0x181D at 0x0274 0275 5B JUMPDEST 0276 61 PUSH2 0x0817 0279 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0817 label_027A: // Incoming jump from 0x00A3, if 0x6cc247e0 == stack[-1] // Inputs[1] { @0281 msg.data.length } 027A 5B JUMPDEST 027B 61 PUSH2 0x01d4 027E 61 PUSH2 0x0288 0281 36 CALLDATASIZE 0282 60 PUSH1 0x04 0284 61 PUSH2 0x1979 0287 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @027B stack[0] = 0x01d4 // @027E stack[1] = 0x0288 // @0281 stack[2] = msg.data.length // @0282 stack[3] = 0x04 // } // Block ends with call to 0x1979, returns to 0x0288 label_0288: // Incoming return from call to 0x1979 at 0x0287 0288 5B JUMPDEST 0289 61 PUSH2 0x088e 028C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x088e label_028D: // Incoming jump from 0x00AE, if 0x70a08231 == stack[-1] // Inputs[1] { @0294 msg.data.length } 028D 5B JUMPDEST 028E 61 PUSH2 0x02a0 0291 61 PUSH2 0x029b 0294 36 CALLDATASIZE 0295 60 PUSH1 0x04 0297 61 PUSH2 0x19c1 029A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @028E stack[0] = 0x02a0 // @0291 stack[1] = 0x029b // @0294 stack[2] = msg.data.length // @0295 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x19c1 029B 5B JUMPDEST 029C 61 PUSH2 0x08d0 029F 56 *JUMP 02A0 5B JUMPDEST 02A1 60 PUSH1 0x40 02A3 51 MLOAD 02A4 90 SWAP1 02A5 81 DUP2 02A6 52 MSTORE 02A7 60 PUSH1 0x20 02A9 01 ADD 02AA 61 PUSH2 0x0183 02AD 56 *JUMP label_02AE: // Incoming jump from 0x00B9, if 0x715018a6 == stack[-1] 02AE 5B JUMPDEST 02AF 61 PUSH2 0x01d4 02B2 61 PUSH2 0x0957 02B5 56 *JUMP // Stack delta = +1 // Outputs[1] { @02AF stack[0] = 0x01d4 } // Block ends with call to 0x0957, returns to 0x01D4 label_02B6: // Incoming jump from 0x00C4, if 0x889a3f19 == stack[-1] 02B6 5B JUMPDEST 02B7 61 PUSH2 0x0194 02BA 61 PUSH2 0x0992 02BD 56 *JUMP // Stack delta = +1 // Outputs[1] { @02B7 stack[0] = 0x0194 } // Block ends with call to 0x0992, returns to 0x0194 label_02BE: // Incoming jump from 0x00CF, if 0x8cffd16a == stack[-1] // Inputs[1] { @02C5 msg.data.length } 02BE 5B JUMPDEST 02BF 61 PUSH2 0x01d4 02C2 61 PUSH2 0x02cc 02C5 36 CALLDATASIZE 02C6 60 PUSH1 0x04 02C8 61 PUSH2 0x19c1 02CB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02BF stack[0] = 0x01d4 // @02C2 stack[1] = 0x02cc // @02C5 stack[2] = msg.data.length // @02C6 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x19c1 02CC 5B JUMPDEST 02CD 61 PUSH2 0x099f 02D0 56 *JUMP label_02D1: // Incoming jump from 0x00DA, if 0x8da5cb5b == stack[-1] 02D1 5B JUMPDEST 02D2 61 PUSH2 0x01b4 02D5 61 PUSH2 0x09f0 02D8 56 *JUMP // Stack delta = +1 // Outputs[1] { @02D2 stack[0] = 0x01b4 } // Block ends with call to 0x09f0, returns to 0x01B4 label_02D9: // Incoming jump from 0x00E5, if 0x95d89b41 == stack[-1] 02D9 5B JUMPDEST 02DA 61 PUSH2 0x0194 02DD 61 PUSH2 0x09ff 02E0 56 *JUMP // Stack delta = +1 // Outputs[1] { @02DA stack[0] = 0x0194 } // Block ends with call to 0x09ff, returns to 0x0194 label_02E1: // Incoming jump from 0x00F0, if 0x9a6a9670 == stack[-1] // Inputs[1] { @02E4 storage[0x06] } 02E1 5B JUMPDEST 02E2 60 PUSH1 0x06 02E4 54 SLOAD 02E5 61 PUSH2 0x02fb 02E8 90 SWAP1 02E9 60 PUSH1 0x01 02EB 60 PUSH1 0xa0 02ED 1B SHL 02EE 90 SWAP1 02EF 04 DIV 02F0 60 PUSH1 0x01 02F2 60 PUSH1 0x01 02F4 60 PUSH1 0x60 02F6 1B SHL 02F7 03 SUB 02F8 16 AND 02F9 81 DUP2 02FA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02E8 stack[0] = 0x02fb // @02F8 stack[1] = (0x01 << 0x60) - 0x01 & storage[0x06] / (0x01 << 0xa0) // } // Block ends with unconditional jump to 0x02fb label_02FB: // Incoming jump from 0x02FA // Inputs[2] // { // @02FE memory[0x40:0x60] // @0308 stack[-1] // } 02FB 5B JUMPDEST 02FC 60 PUSH1 0x40 02FE 51 MLOAD 02FF 60 PUSH1 0x01 0301 60 PUSH1 0x01 0303 60 PUSH1 0x60 0305 1B SHL 0306 03 SUB 0307 90 SWAP1 0308 91 SWAP2 0309 16 AND 030A 81 DUP2 030B 52 MSTORE 030C 60 PUSH1 0x20 030E 01 ADD 030F 61 PUSH2 0x0183 0312 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @030B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0x60) - 0x01 // @030E stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0183 label_0313: // Incoming jump from 0x00FB, if 0xa22cb465 == stack[-1] // Inputs[1] { @031A msg.data.length } 0313 5B JUMPDEST 0314 61 PUSH2 0x01d4 0317 61 PUSH2 0x0321 031A 36 CALLDATASIZE 031B 60 PUSH1 0x04 031D 61 PUSH2 0x19de 0320 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0314 stack[0] = 0x01d4 // @0317 stack[1] = 0x0321 // @031A stack[2] = msg.data.length // @031B stack[3] = 0x04 // } // Block ends with call to 0x19de, returns to 0x0321 label_0321: // Incoming return from call to 0x19DE at 0x0320 0321 5B JUMPDEST 0322 61 PUSH2 0x0a0e 0325 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a0e label_0326: // Incoming jump from 0x0106, if 0xb88d4fde == stack[-1] // Inputs[1] { @032D msg.data.length } 0326 5B JUMPDEST 0327 61 PUSH2 0x01d4 032A 61 PUSH2 0x0334 032D 36 CALLDATASIZE 032E 60 PUSH1 0x04 0330 61 PUSH2 0x1a3c 0333 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0327 stack[0] = 0x01d4 // @032A stack[1] = 0x0334 // @032D stack[2] = msg.data.length // @032E stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1a3c 0334 5B JUMPDEST 0335 61 PUSH2 0x0acf 0338 56 *JUMP label_0339: // Incoming jump from 0x0111, if 0xc87b56dd == stack[-1] // Inputs[1] { @0340 msg.data.length } 0339 5B JUMPDEST 033A 61 PUSH2 0x0194 033D 61 PUSH2 0x0347 0340 36 CALLDATASIZE 0341 60 PUSH1 0x04 0343 61 PUSH2 0x181d 0346 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @033A stack[0] = 0x0194 // @033D stack[1] = 0x0347 // @0340 stack[2] = msg.data.length // @0341 stack[3] = 0x04 // } // Block ends with call to 0x181d, returns to 0x0347 label_0347: // Incoming return from call to 0x181D at 0x0346 0347 5B JUMPDEST 0348 61 PUSH2 0x0b07 034B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b07 label_034C: // Incoming jump from 0x011C, if 0xcad96cca == stack[-1] // Inputs[1] { @0353 msg.data.length } 034C 5B JUMPDEST 034D 61 PUSH2 0x035f 0350 61 PUSH2 0x035a 0353 36 CALLDATASIZE 0354 60 PUSH1 0x04 0356 61 PUSH2 0x181d 0359 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @034D stack[0] = 0x035f // @0350 stack[1] = 0x035a // @0353 stack[2] = msg.data.length // @0354 stack[3] = 0x04 // } // Block ends with call to 0x181d, returns to 0x035A label_035A: // Incoming return from call to 0x181D at 0x0359 035A 5B JUMPDEST 035B 61 PUSH2 0x0c32 035E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c32 label_035F: // Incoming return from call to 0x035A at 0x0359 // Inputs[2] // { // @0362 memory[0x40:0x60] // @0366 stack[-1] // } 035F 5B JUMPDEST 0360 60 PUSH1 0x40 0362 51 MLOAD 0363 61 PUSH2 0x0183 0366 91 SWAP2 0367 90 SWAP1 0368 61 PUSH2 0x1aa7 036B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0366 stack[-1] = 0x0183 // @0367 stack[1] = memory[0x40:0x60] // @0367 stack[0] = stack[-1] // } // Block ends with call to 0x1aa7, returns to 0x0183 label_036C: // Incoming jump from 0x0127, if 0xcd3a8e27 == stack[-1] // Inputs[1] { @036F storage[0x07] } 036C 5B JUMPDEST 036D 60 PUSH1 0x07 036F 54 SLOAD 0370 61 PUSH2 0x01b4 0373 90 SWAP1 0374 60 PUSH1 0x01 0376 60 PUSH1 0x01 0378 60 PUSH1 0xa0 037A 1B SHL 037B 03 SUB 037C 16 AND 037D 81 DUP2 037E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0373 stack[0] = 0x01b4 // @037C stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x07] // } // Block ends with unconditional jump to 0x01b4 label_037F: // Incoming jump from 0x0132, if 0xcd7c0326 == stack[-1] // Inputs[1] { @0382 storage[0x08] } 037F 5B JUMPDEST 0380 60 PUSH1 0x08 0382 54 SLOAD 0383 61 PUSH2 0x01b4 0386 90 SWAP1 0387 60 PUSH1 0x01 0389 60 PUSH1 0x01 038B 60 PUSH1 0xa0 038D 1B SHL 038E 03 SUB 038F 16 AND 0390 81 DUP2 0391 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0386 stack[0] = 0x01b4 // @038F stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x08] // } // Block ends with unconditional jump to 0x01b4 label_0392: // Incoming jump from 0x013D, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0399 msg.data.length } 0392 5B JUMPDEST 0393 61 PUSH2 0x0177 0396 61 PUSH2 0x03a0 0399 36 CALLDATASIZE 039A 60 PUSH1 0x04 039C 61 PUSH2 0x1b08 039F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0393 stack[0] = 0x0177 // @0396 stack[1] = 0x03a0 // @0399 stack[2] = msg.data.length // @039A stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1b08 03A0 5B JUMPDEST 03A1 61 PUSH2 0x0cf9 03A4 56 *JUMP label_03A5: // Incoming jump from 0x0148, if 0xea3a8248 == stack[-1] // Inputs[1] { @03AC msg.data.length } 03A5 5B JUMPDEST 03A6 61 PUSH2 0x01d4 03A9 61 PUSH2 0x03b3 03AC 36 CALLDATASIZE 03AD 60 PUSH1 0x04 03AF 61 PUSH2 0x1b36 03B2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03A6 stack[0] = 0x01d4 // @03A9 stack[1] = 0x03b3 // @03AC stack[2] = msg.data.length // @03AD stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1b36 03B3 5B JUMPDEST 03B4 61 PUSH2 0x0dcd 03B7 56 *JUMP label_03B8: // Incoming jump from 0x0153, if 0xed00c02d == stack[-1] // Inputs[1] { @03BF msg.data.length } 03B8 5B JUMPDEST 03B9 61 PUSH2 0x01d4 03BC 61 PUSH2 0x03c6 03BF 36 CALLDATASIZE 03C0 60 PUSH1 0x04 03C2 61 PUSH2 0x1b7c 03C5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03B9 stack[0] = 0x01d4 // @03BC stack[1] = 0x03c6 // @03BF stack[2] = msg.data.length // @03C0 stack[3] = 0x04 // } // Block ends with call to 0x1b7c, returns to 0x03C6 label_03C6: // Incoming return from call to 0x1B7C at 0x03C5 03C6 5B JUMPDEST 03C7 61 PUSH2 0x0e1b 03CA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e1b label_03CB: // Incoming jump from 0x015E, if 0xf2fde38b == stack[-1] // Inputs[1] { @03D2 msg.data.length } 03CB 5B JUMPDEST 03CC 61 PUSH2 0x01d4 03CF 61 PUSH2 0x03d9 03D2 36 CALLDATASIZE 03D3 60 PUSH1 0x04 03D5 61 PUSH2 0x19c1 03D8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03CC stack[0] = 0x01d4 // @03CF stack[1] = 0x03d9 // @03D2 stack[2] = msg.data.length // @03D3 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x19c1 03D9 5B JUMPDEST 03DA 61 PUSH2 0x0e72 03DD 56 *JUMP 03DE 5B JUMPDEST 03DF 60 PUSH1 0x00 03E1 60 PUSH1 0x01 03E3 60 PUSH1 0x01 03E5 60 PUSH1 0xe0 03E7 1B SHL 03E8 03 SUB 03E9 19 NOT 03EA 82 DUP3 03EB 16 AND 03EC 63 PUSH4 0x656cb665 03F1 60 PUSH1 0xe1 03F3 1B SHL 03F4 14 EQ 03F5 15 ISZERO 03F6 61 PUSH2 0x0401 03F9 57 *JUMPI 03FA 50 POP 03FB 60 PUSH1 0x01 03FD 91 SWAP2 03FE 90 SWAP1 03FF 50 POP 0400 56 *JUMP 0401 5B JUMPDEST 0402 60 PUSH1 0x01 0404 60 PUSH1 0x01 0406 60 PUSH1 0xe0 0408 1B SHL 0409 03 SUB 040A 19 NOT 040B 82 DUP3 040C 16 AND 040D 63 PUSH4 0x152a902d 0412 60 PUSH1 0xe1 0414 1B SHL 0415 14 EQ 0416 15 ISZERO 0417 61 PUSH2 0x0422 041A 57 *JUMPI 041B 50 POP 041C 60 PUSH1 0x01 041E 91 SWAP2 041F 90 SWAP1 0420 50 POP 0421 56 *JUMP 0422 5B JUMPDEST 0423 61 PUSH2 0x042b 0426 82 DUP3 0427 61 PUSH2 0x0f0f 042A 56 *JUMP label_042B: // Incoming jump from 0x0834, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @042C stack[-4] // @042C stack[-1] // @042D stack[-3] // } 042B 5B JUMPDEST 042C 92 SWAP3 042D 91 SWAP2 042E 50 POP 042F 50 POP 0430 56 *JUMP // Stack delta = -3 // Outputs[1] { @042C stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0431: // Incoming call from 0x0193, returns to 0x0194 // Inputs[1] { @0437 storage[0x00] } 0431 5B JUMPDEST 0432 60 PUSH1 0x60 0434 60 PUSH1 0x00 0436 80 DUP1 0437 54 SLOAD 0438 61 PUSH2 0x0440 043B 90 SWAP1 043C 61 PUSH2 0x1ba5 043F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0432 stack[0] = 0x60 // @0434 stack[1] = 0x00 // @043B stack[2] = 0x0440 // @043B stack[3] = storage[0x00] // } // Block ends with call to 0x1ba5, returns to 0x0440 label_0440: // Incoming return from call to 0x1BA5 at 0x0A0D // Incoming return from call to 0x1BA5 at 0x043F // Incoming return from call to 0x1BA5 at 0x15AE // Inputs[4] // { // @0441 stack[-1] // @0450 memory[0x40:0x60] // @0458 stack[-2] // @0463 storage[stack[-2]] // } 0440 5B JUMPDEST 0441 80 DUP1 0442 60 PUSH1 0x1f 0444 01 ADD 0445 60 PUSH1 0x20 0447 80 DUP1 0448 91 SWAP2 0449 04 DIV 044A 02 MUL 044B 60 PUSH1 0x20 044D 01 ADD 044E 60 PUSH1 0x40 0450 51 MLOAD 0451 90 SWAP1 0452 81 DUP2 0453 01 ADD 0454 60 PUSH1 0x40 0456 52 MSTORE 0457 80 DUP1 0458 92 SWAP3 0459 91 SWAP2 045A 90 SWAP1 045B 81 DUP2 045C 81 DUP2 045D 52 MSTORE 045E 60 PUSH1 0x20 0460 01 ADD 0461 82 DUP3 0462 80 DUP1 0463 54 SLOAD 0464 61 PUSH2 0x046c 0467 90 SWAP1 0468 61 PUSH2 0x1ba5 046B 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0456 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0458 stack[-2] = memory[0x40:0x60] // @0459 stack[-1] = stack[-2] // @045A stack[0] = stack[-1] // @045D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0460 stack[1] = 0x20 + memory[0x40:0x60] // @0461 stack[2] = stack[-2] // @0467 stack[4] = storage[stack[-2]] // @0467 stack[3] = 0x046c // } // Block ends with call to 0x1ba5, returns to 0x046C label_046C: // Incoming return from call to 0x1BA5 at 0x046B // Inputs[1] { @046D stack[-1] } 046C 5B JUMPDEST 046D 80 DUP1 046E 15 ISZERO 046F 61 PUSH2 0x04b9 0472 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b9, if !stack[-1] label_0473: // Incoming jump from 0x0472, if not !stack[-1] // Inputs[1] { @0473 stack[-1] } 0473 80 DUP1 0474 60 PUSH1 0x1f 0476 10 LT 0477 61 PUSH2 0x048e 047A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048e, if 0x1f < stack[-1] label_047B: // Incoming jump from 0x047A, if not 0x1f < stack[-1] // Inputs[4] // { // @047F stack[-2] // @0480 storage[stack[-2]] // @0483 stack[-3] // @0485 stack[-1] // } 047B 61 PUSH2 0x0100 047E 80 DUP1 047F 83 DUP4 0480 54 SLOAD 0481 04 DIV 0482 02 MUL 0483 83 DUP4 0484 52 MSTORE 0485 91 SWAP2 0486 60 PUSH1 0x20 0488 01 ADD 0489 91 SWAP2 048A 61 PUSH2 0x04b9 048D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0484 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0489 stack[-1] = stack[-1] // @0489 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x04b9 label_048E: // Incoming jump from 0x047A, if 0x1f < stack[-1] // Inputs[5] // { // @048F stack[-3] // @0490 stack[-1] // @0492 stack[-2] // @049A memory[0x00:0x20] // @049E storage[keccak256(memory[0x00:0x20])] // } 048E 5B JUMPDEST 048F 82 DUP3 0490 01 ADD 0491 91 SWAP2 0492 90 SWAP1 0493 60 PUSH1 0x00 0495 52 MSTORE 0496 60 PUSH1 0x20 0498 60 PUSH1 0x00 049A 20 SHA3 049B 90 SWAP1 049C 5B JUMPDEST 049D 81 DUP2 049E 54 SLOAD 049F 81 DUP2 04A0 52 MSTORE 04A1 90 SWAP1 04A2 60 PUSH1 0x01 04A4 01 ADD 04A5 90 SWAP1 04A6 60 PUSH1 0x20 04A8 01 ADD 04A9 80 DUP1 04AA 83 DUP4 04AB 11 GT 04AC 61 PUSH2 0x049c 04AF 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0491 stack[-3] = stack[-3] + stack[-1] // @0495 memory[0x00:0x20] = stack[-2] // @04A0 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @04A5 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @04A8 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x049c, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_04B0: // Incoming jump from 0x04AF, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x04AF, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @04B0 stack[-3] // @04B1 stack[-1] // } 04B0 82 DUP3 04B1 90 SWAP1 04B2 03 SUB 04B3 60 PUSH1 0x1f 04B5 16 AND 04B6 82 DUP3 04B7 01 ADD 04B8 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @04B8 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @04B8 stack[-1] = stack[-3] // } // Block continues label_04B9: // Incoming jump from 0x048D // Incoming jump from 0x0472, if !stack[-1] // Incoming jump from 0x04B8 // Inputs[3] // { // @04BF stack[-6] // @04BF stack[-7] // @04C1 stack[-8] // } 04B9 5B JUMPDEST 04BA 50 POP 04BB 50 POP 04BC 50 POP 04BD 50 POP 04BE 50 POP 04BF 90 SWAP1 04C0 50 POP 04C1 90 SWAP1 04C2 56 *JUMP // Stack delta = -7 // Outputs[1] { @04C1 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_04C3: // Incoming jump from 0x01B3 // Incoming call from 0x1090, returns to 0x1091 // Inputs[1] { @04C9 stack[-1] } 04C3 5B JUMPDEST 04C4 60 PUSH1 0x00 04C6 61 PUSH2 0x04ce 04C9 82 DUP3 04CA 61 PUSH2 0x0f5f 04CD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @04C4 stack[0] = 0x00 // @04C6 stack[1] = 0x04ce // @04C9 stack[2] = stack[-1] // } // Block ends with call to 0x0f5f, returns to 0x04CE label_04CE: // Incoming return from call to 0x0F5F at 0x04CD // Inputs[1] { @04D2 stack[-1] } 04CE 5B JUMPDEST 04CF 61 PUSH2 0x0534 04D2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0534, if stack[-1] label_04D3: // Incoming jump from 0x04D2, if not stack[-1] // Inputs[1] { @04D5 memory[0x40:0x60] } 04D3 60 PUSH1 0x40 04D5 51 MLOAD 04D6 62 PUSH3 0x461bcd 04DA 60 PUSH1 0xe5 04DC 1B SHL 04DD 81 DUP2 04DE 52 MSTORE 04DF 60 PUSH1 0x20 04E1 60 PUSH1 0x04 04E3 82 DUP3 04E4 01 ADD 04E5 52 MSTORE 04E6 60 PUSH1 0x2c 04E8 60 PUSH1 0x24 04EA 82 DUP3 04EB 01 ADD 04EC 52 MSTORE 04ED 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 050E 60 PUSH1 0x44 0510 82 DUP3 0511 01 ADD 0512 52 MSTORE 0513 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 0520 60 PUSH1 0xa1 0522 1B SHL 0523 60 PUSH1 0x64 0525 82 DUP3 0526 01 ADD 0527 52 MSTORE 0528 60 PUSH1 0x84 052A 01 ADD // Stack delta = +1 // Outputs[6] // { // @04DE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @04E5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @04EC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @0512 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 // @0527 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @052A stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_052B: // Incoming return from call to 0x1C8A at 0x0E49 // Incoming jump from 0x088D // Incoming return from call to 0x1BDA at 0x0686 // Incoming jump from 0x128F // Incoming jump from 0x0A62 // Incoming jump from 0x1188 // Incoming return from call to 0x1C8A at 0x0747 // Incoming return from call to 0x1D50 at 0x1572 // Incoming return from call to 0x1D50 at 0x13DE // Incoming jump from 0x1126 // Incoming jump from 0x144D // Incoming jump from 0x1055 // Incoming jump from 0x052A // Incoming return from call to 0x1BDA at 0x0AF4 // Incoming return from call to 0x1C8A at 0x0985 // Incoming jump from 0x05C8 // Incoming return from call to 0x1C8A at 0x070A // Incoming return from call to 0x1C8A at 0x08BC // Incoming jump from 0x12E4 // Incoming jump from 0x0B50 // Incoming jump from 0x0651 // Inputs[3] // { // @052E memory[0x40:0x60] // @0530 stack[-1] // @0533 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 052B 5B JUMPDEST 052C 60 PUSH1 0x40 052E 51 MLOAD 052F 80 DUP1 0530 91 SWAP2 0531 03 SUB 0532 90 SWAP1 0533 FD *REVERT // Stack delta = -1 // Outputs[1] { @0533 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0534: // Incoming jump from 0x04D2, if stack[-1] // Inputs[4] // { // @0538 stack[-2] // @0543 memory[0x00:0x40] // @0544 storage[keccak256(memory[0x00:0x40])] // @054E stack[-3] // } 0534 5B JUMPDEST 0535 50 POP 0536 60 PUSH1 0x00 0538 90 SWAP1 0539 81 DUP2 053A 52 MSTORE 053B 60 PUSH1 0x04 053D 60 PUSH1 0x20 053F 52 MSTORE 0540 60 PUSH1 0x40 0542 90 SWAP1 0543 20 SHA3 0544 54 SLOAD 0545 60 PUSH1 0x01 0547 60 PUSH1 0x01 0549 60 PUSH1 0xa0 054B 1B SHL 054C 03 SUB 054D 16 AND 054E 90 SWAP1 054F 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @053A memory[0x00:0x20] = stack[-2] // @053F memory[0x20:0x40] = 0x04 // @054E stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0550: // Incoming jump from 0x01D3 // Inputs[1] { @0556 stack[-1] } 0550 5B JUMPDEST 0551 60 PUSH1 0x00 0553 61 PUSH2 0x055b 0556 82 DUP3 0557 61 PUSH2 0x0817 055A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0551 stack[0] = 0x00 // @0553 stack[1] = 0x055b // @0556 stack[2] = stack[-1] // } // Block ends with call to 0x0817, returns to 0x055B label_055B: // Incoming return from call to 0x0817 at 0x055A // Inputs[3] // { // @055C stack[-2] // @055C stack[-1] // @0568 stack[-4] // } 055B 5B JUMPDEST 055C 90 SWAP1 055D 50 POP 055E 80 DUP1 055F 60 PUSH1 0x01 0561 60 PUSH1 0x01 0563 60 PUSH1 0xa0 0565 1B SHL 0566 03 SUB 0567 16 AND 0568 83 DUP4 0569 60 PUSH1 0x01 056B 60 PUSH1 0x01 056D 60 PUSH1 0xa0 056F 1B SHL 0570 03 SUB 0571 16 AND 0572 14 EQ 0573 15 ISZERO 0574 61 PUSH2 0x05c9 0577 57 *JUMPI // Stack delta = -1 // Outputs[1] { @055C stack[-2] = stack[-1] } // Block ends with conditional jump to 0x05c9, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0578: // Incoming jump from 0x0577, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @057A memory[0x40:0x60] } 0578 60 PUSH1 0x40 057A 51 MLOAD 057B 62 PUSH3 0x461bcd 057F 60 PUSH1 0xe5 0581 1B SHL 0582 81 DUP2 0583 52 MSTORE 0584 60 PUSH1 0x20 0586 60 PUSH1 0x04 0588 82 DUP3 0589 01 ADD 058A 52 MSTORE 058B 60 PUSH1 0x21 058D 60 PUSH1 0x24 058F 82 DUP3 0590 01 ADD 0591 52 MSTORE 0592 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 05B3 60 PUSH1 0x44 05B5 82 DUP3 05B6 01 ADD 05B7 52 MSTORE 05B8 60 PUSH1 0x39 05BA 60 PUSH1 0xf9 05BC 1B SHL 05BD 60 PUSH1 0x64 05BF 82 DUP3 05C0 01 ADD 05C1 52 MSTORE 05C2 60 PUSH1 0x84 05C4 01 ADD 05C5 61 PUSH2 0x052b 05C8 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0583 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @058A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0591 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @05B7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 // @05C1 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x39 << 0xf9 // @05C4 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x052b label_05C9: // Incoming jump from 0x0577, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @05CA msg.sender // @05D3 stack[-1] // } 05C9 5B JUMPDEST 05CA 33 CALLER 05CB 60 PUSH1 0x01 05CD 60 PUSH1 0x01 05CF 60 PUSH1 0xa0 05D1 1B SHL 05D2 03 SUB 05D3 82 DUP3 05D4 16 AND 05D5 14 EQ 05D6 80 DUP1 05D7 61 PUSH2 0x05e5 05DA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05D5 stack[0] = stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender } // Block ends with conditional jump to 0x05e5, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_05DB: // Incoming jump from 0x05DA, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @05DF stack[-2] // @05E0 msg.sender // } 05DB 50 POP 05DC 61 PUSH2 0x05e5 05DF 81 DUP2 05E0 33 CALLER 05E1 61 PUSH2 0x0cf9 05E4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05DC stack[-1] = 0x05e5 // @05DF stack[0] = stack[-2] // @05E0 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x0cf9 label_05E5: // Incoming jump from 0x05DA, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @05E9 stack[-1] } 05E5 5B JUMPDEST 05E6 61 PUSH2 0x0652 05E9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0652, if stack[-1] label_05EA: // Incoming jump from 0x05E9, if not stack[-1] // Inputs[1] { @05EC memory[0x40:0x60] } 05EA 60 PUSH1 0x40 05EC 51 MLOAD 05ED 62 PUSH3 0x461bcd 05F1 60 PUSH1 0xe5 05F3 1B SHL 05F4 81 DUP2 05F5 52 MSTORE 05F6 60 PUSH1 0x20 05F8 60 PUSH1 0x04 05FA 82 DUP3 05FB 01 ADD 05FC 52 MSTORE 05FD 60 PUSH1 0x38 05FF 60 PUSH1 0x24 0601 82 DUP3 0602 01 ADD 0603 52 MSTORE 0604 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 0625 60 PUSH1 0x44 0627 82 DUP3 0628 01 ADD 0629 52 MSTORE 062A 77 PUSH24 0x1b995c881b9bdc88185c1c1c9bdd995908199bdc88185b1b 0643 60 PUSH1 0x42 0645 1B SHL 0646 60 PUSH1 0x64 0648 82 DUP3 0649 01 ADD 064A 52 MSTORE 064B 60 PUSH1 0x84 064D 01 ADD 064E 61 PUSH2 0x052b 0651 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @05F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05FC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0603 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x38 // @0629 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 // @064A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x1b995c881b9bdc88185c1c1c9bdd995908199bdc88185b1b << 0x42 // @064D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x052b label_0652: // Incoming jump from 0x05E9, if stack[-1] // Inputs[2] // { // @0656 stack[-3] // @0657 stack[-2] // } 0652 5B JUMPDEST 0653 61 PUSH2 0x065c 0656 83 DUP4 0657 83 DUP4 0658 61 PUSH2 0x0f7c 065B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0653 stack[0] = 0x065c // @0656 stack[1] = stack[-3] // @0657 stack[2] = stack[-2] // } // Block ends with call to 0x0f7c, returns to 0x065C label_065C: // Incoming return from call to 0x0F7C at 0x065B // Incoming return from call to 0x10AC at 0x0691 // Inputs[1] { @0660 stack[-4] } 065C 5B JUMPDEST 065D 50 POP 065E 50 POP 065F 50 POP 0660 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0661: // Incoming jump from 0x01E8 // Inputs[2] // { // @0665 msg.sender // @0666 stack[-1] // } 0661 5B JUMPDEST 0662 61 PUSH2 0x066b 0665 33 CALLER 0666 82 DUP3 0667 61 PUSH2 0x0fea 066A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0662 stack[0] = 0x066b // @0665 stack[1] = msg.sender // @0666 stack[2] = stack[-1] // } // Block ends with call to 0x0fea, returns to 0x066B label_066B: // Incoming return from call to 0x0FEA at 0x066A // Inputs[1] { @066F stack[-1] } 066B 5B JUMPDEST 066C 61 PUSH2 0x0687 066F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0687, if stack[-1] label_0670: // Incoming jump from 0x066F, if not stack[-1] // Inputs[1] { @0672 memory[0x40:0x60] } 0670 60 PUSH1 0x40 0672 51 MLOAD 0673 62 PUSH3 0x461bcd 0677 60 PUSH1 0xe5 0679 1B SHL 067A 81 DUP2 067B 52 MSTORE 067C 60 PUSH1 0x04 067E 01 ADD 067F 61 PUSH2 0x052b 0682 90 SWAP1 0683 61 PUSH2 0x1bda 0686 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @067B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0682 stack[0] = 0x052b // @0682 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1bda, returns to 0x052B label_0687: // Incoming jump from 0x066F, if stack[-1] // Inputs[3] // { // @068B stack[-3] // @068C stack[-2] // @068D stack[-1] // } 0687 5B JUMPDEST 0688 61 PUSH2 0x065c 068B 83 DUP4 068C 83 DUP4 068D 83 DUP4 068E 61 PUSH2 0x10ac 0691 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0688 stack[0] = 0x065c // @068B stack[1] = stack[-3] // @068C stack[2] = stack[-2] // @068D stack[3] = stack[-1] // } // Block ends with call to 0x10ac, returns to 0x065C label_0692: // Incoming jump from 0x01FB // Inputs[3] // { // @0695 storage[0x07] // @0698 storage[0x06] // @06C2 stack[-1] // } 0692 5B JUMPDEST 0693 60 PUSH1 0x07 0695 54 SLOAD 0696 60 PUSH1 0x06 0698 54 SLOAD 0699 60 PUSH1 0x00 069B 91 SWAP2 069C 82 DUP3 069D 91 SWAP2 069E 60 PUSH1 0x01 06A0 60 PUSH1 0x01 06A2 60 PUSH1 0xa0 06A4 1B SHL 06A5 03 SUB 06A6 90 SWAP1 06A7 91 SWAP2 06A8 16 AND 06A9 90 SWAP1 06AA 61 PUSH2 0x2710 06AD 90 SWAP1 06AE 61 PUSH2 0x06c7 06B1 90 SWAP1 06B2 60 PUSH1 0x01 06B4 60 PUSH1 0xa0 06B6 1B SHL 06B7 90 SWAP1 06B8 04 DIV 06B9 60 PUSH1 0x01 06BB 60 PUSH1 0x01 06BD 60 PUSH1 0x60 06BF 1B SHL 06C0 03 SUB 06C1 16 AND 06C2 86 DUP7 06C3 61 PUSH2 0x1c41 06C6 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @069B stack[0] = 0x00 // @069D stack[1] = 0x00 // @06A9 stack[2] = storage[0x07] & (0x01 << 0xa0) - 0x01 // @06AD stack[3] = 0x2710 // @06B1 stack[4] = 0x06c7 // @06C1 stack[5] = (0x01 << 0x60) - 0x01 & storage[0x06] / (0x01 << 0xa0) // @06C2 stack[6] = stack[-1] // } // Block ends with call to 0x1c41, returns to 0x06C7 label_06C7: // Incoming return from call to 0x1C41 at 0x06C6 // Inputs[2] // { // @06CB stack[-2] // @06CC stack[-1] // } 06C7 5B JUMPDEST 06C8 61 PUSH2 0x06d1 06CB 91 SWAP2 06CC 90 SWAP1 06CD 61 PUSH2 0x1c76 06D0 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @06CB stack[-2] = 0x06d1 // @06CC stack[-1] = stack[-2] // @06CC stack[0] = stack[-1] // } // Block ends with call to 0x1c76, returns to 0x06D1 label_06D1: // Incoming return from call to 0x1C76 at 0x06D0 // Inputs[7] // { // @06D2 stack[-1] // @06D2 stack[-3] // @06D4 stack[-2] // @06D4 stack[-4] // @06D6 stack[-6] // @06D8 stack[-7] // @06D9 stack[-5] // } 06D1 5B JUMPDEST 06D2 91 SWAP2 06D3 50 POP 06D4 91 SWAP2 06D5 50 POP 06D6 92 SWAP3 06D7 50 POP 06D8 92 SWAP3 06D9 90 SWAP1 06DA 50 POP 06DB 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @06D6 stack[-6] = stack[-1] // @06D8 stack[-7] = stack[-2] // } // Block ends with unconditional jump to stack[-7] label_06DC: // Incoming jump from 0x022D // Inputs[1] { @06DD msg.sender } 06DC 5B JUMPDEST 06DD 33 CALLER 06DE 61 PUSH2 0x06e5 06E1 61 PUSH2 0x09f0 06E4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06DD stack[0] = msg.sender // @06DE stack[1] = 0x06e5 // } // Block ends with call to 0x09f0, returns to 0x06E5 label_06E5: // Incoming return from call to 0x09F0 at 0x06E4 // Inputs[2] // { // @06EE stack[-1] // @06EF stack[-2] // } 06E5 5B JUMPDEST 06E6 60 PUSH1 0x01 06E8 60 PUSH1 0x01 06EA 60 PUSH1 0xa0 06EC 1B SHL 06ED 03 SUB 06EE 16 AND 06EF 14 EQ 06F0 61 PUSH2 0x070b 06F3 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x070b, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_06F4: // Incoming jump from 0x06F3, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @06F6 memory[0x40:0x60] } 06F4 60 PUSH1 0x40 06F6 51 MLOAD 06F7 62 PUSH3 0x461bcd 06FB 60 PUSH1 0xe5 06FD 1B SHL 06FE 81 DUP2 06FF 52 MSTORE 0700 60 PUSH1 0x04 0702 01 ADD 0703 61 PUSH2 0x052b 0706 90 SWAP1 0707 61 PUSH2 0x1c8a 070A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @06FF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0706 stack[0] = 0x052b // @0706 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1c8a, returns to 0x052B label_070B: // Incoming jump from 0x06F3, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[2] // { // @070F stack[-2] // @0710 stack[-1] // } 070B 5B JUMPDEST 070C 61 PUSH2 0x0715 070F 82 DUP3 0710 82 DUP3 0711 61 PUSH2 0x123a 0714 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @070C stack[0] = 0x0715 // @070F stack[1] = stack[-2] // @0710 stack[2] = stack[-1] // } // Block ends with call to 0x123a, returns to 0x0715 label_0715: // Incoming return from call to 0x123A at 0x0714 // Inputs[1] { @0718 stack[-3] } 0715 5B JUMPDEST 0716 50 POP 0717 50 POP 0718 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0719: // Incoming jump from 0x0240 // Inputs[1] { @071A msg.sender } 0719 5B JUMPDEST 071A 33 CALLER 071B 61 PUSH2 0x0722 071E 61 PUSH2 0x09f0 0721 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @071A stack[0] = msg.sender // @071B stack[1] = 0x0722 // } // Block ends with call to 0x09f0, returns to 0x0722 label_0722: // Incoming return from call to 0x09F0 at 0x0721 // Inputs[2] // { // @072B stack[-1] // @072C stack[-2] // } 0722 5B JUMPDEST 0723 60 PUSH1 0x01 0725 60 PUSH1 0x01 0727 60 PUSH1 0xa0 0729 1B SHL 072A 03 SUB 072B 16 AND 072C 14 EQ 072D 61 PUSH2 0x0748 0730 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0748, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_0731: // Incoming jump from 0x0730, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @0733 memory[0x40:0x60] } 0731 60 PUSH1 0x40 0733 51 MLOAD 0734 62 PUSH3 0x461bcd 0738 60 PUSH1 0xe5 073A 1B SHL 073B 81 DUP2 073C 52 MSTORE 073D 60 PUSH1 0x04 073F 01 ADD 0740 61 PUSH2 0x052b 0743 90 SWAP1 0744 61 PUSH2 0x1c8a 0747 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @073C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0743 stack[0] = 0x052b // @0743 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1c8a, returns to 0x052B label_0748: // Incoming jump from 0x0730, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[2] // { // @074B stack[-1] // @0756 memory[0x00:0x40] // } 0748 5B JUMPDEST 0749 60 PUSH1 0x00 074B 81 DUP2 074C 81 DUP2 074D 52 MSTORE 074E 60 PUSH1 0x0a 0750 60 PUSH1 0x20 0752 52 MSTORE 0753 60 PUSH1 0x40 0755 81 DUP2 0756 20 SHA3 0757 61 PUSH2 0x075f 075A 91 SWAP2 075B 61 PUSH2 0x16ac 075E 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @074D memory[0x00:0x20] = stack[-1] // @0752 memory[0x20:0x40] = 0x0a // @0756 stack[1] = keccak256(memory[0x00:0x40]) // @075A stack[0] = 0x075f // @075A stack[2] = 0x00 // } // Block ends with call to 0x16ac, returns to 0x075F label_075F: // Incoming return from call to 0x16AC at 0x075E // Incoming return from call to 0x176A at 0x16E5 // Incoming jump from 0x185A, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x1790, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0761 stack[-2] } 075F 5B JUMPDEST 0760 50 POP 0761 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0762: // Incoming jump from 0x0253 // Inputs[4] // { // @0766 stack[-3] // @0767 stack[-2] // @0768 stack[-1] // @076B memory[0x40:0x60] // } 0762 5B JUMPDEST 0763 61 PUSH2 0x065c 0766 83 DUP4 0767 83 DUP4 0768 83 DUP4 0769 60 PUSH1 0x40 076B 51 MLOAD 076C 80 DUP1 076D 60 PUSH1 0x20 076F 01 ADD 0770 60 PUSH1 0x40 0772 52 MSTORE 0773 80 DUP1 0774 60 PUSH1 0x00 0776 81 DUP2 0777 52 MSTORE 0778 50 POP 0779 61 PUSH2 0x0acf 077C 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0763 stack[0] = 0x065c // @0766 stack[1] = stack[-3] // @0767 stack[2] = stack[-2] // @0768 stack[3] = stack[-1] // @076B stack[4] = memory[0x40:0x60] // @0772 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0777 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x0acf label_077D: // Incoming jump from 0x0266 // Inputs[3] // { // @0785 stack[-1] // @078B memory[0x00:0x40] // @078D storage[keccak256(memory[0x00:0x40])] // } 077D 5B JUMPDEST 077E 60 PUSH1 0x0a 0780 60 PUSH1 0x20 0782 52 MSTORE 0783 60 PUSH1 0x00 0785 90 SWAP1 0786 81 DUP2 0787 52 MSTORE 0788 60 PUSH1 0x40 078A 90 SWAP1 078B 20 SHA3 078C 80 DUP1 078D 54 SLOAD 078E 61 PUSH2 0x0796 0791 90 SWAP1 0792 61 PUSH2 0x1ba5 0795 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @0782 memory[0x20:0x40] = 0x0a // @0787 memory[0x00:0x20] = stack[-1] // @078B stack[-1] = keccak256(memory[0x00:0x40]) // @0791 stack[1] = storage[keccak256(memory[0x00:0x40])] // @0791 stack[0] = 0x0796 // } // Block ends with call to 0x1ba5, returns to 0x0796 label_0796: // Incoming return from call to 0x1BA5 at 0x0795 // Incoming return from call to 0x1BA5 at 0x099E // Inputs[4] // { // @0797 stack[-1] // @07A6 memory[0x40:0x60] // @07AE stack[-2] // @07B9 storage[stack[-2]] // } 0796 5B JUMPDEST 0797 80 DUP1 0798 60 PUSH1 0x1f 079A 01 ADD 079B 60 PUSH1 0x20 079D 80 DUP1 079E 91 SWAP2 079F 04 DIV 07A0 02 MUL 07A1 60 PUSH1 0x20 07A3 01 ADD 07A4 60 PUSH1 0x40 07A6 51 MLOAD 07A7 90 SWAP1 07A8 81 DUP2 07A9 01 ADD 07AA 60 PUSH1 0x40 07AC 52 MSTORE 07AD 80 DUP1 07AE 92 SWAP3 07AF 91 SWAP2 07B0 90 SWAP1 07B1 81 DUP2 07B2 81 DUP2 07B3 52 MSTORE 07B4 60 PUSH1 0x20 07B6 01 ADD 07B7 82 DUP3 07B8 80 DUP1 07B9 54 SLOAD 07BA 61 PUSH2 0x07c2 07BD 90 SWAP1 07BE 61 PUSH2 0x1ba5 07C1 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @07AC memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @07AE stack[-2] = memory[0x40:0x60] // @07AF stack[-1] = stack[-2] // @07B0 stack[0] = stack[-1] // @07B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @07B6 stack[1] = 0x20 + memory[0x40:0x60] // @07B7 stack[2] = stack[-2] // @07BD stack[4] = storage[stack[-2]] // @07BD stack[3] = 0x07c2 // } // Block ends with call to 0x1ba5, returns to 0x07C2 label_07C2: // Incoming return from call to 0x1BA5 at 0x07C1 // Inputs[1] { @07C3 stack[-1] } 07C2 5B JUMPDEST 07C3 80 DUP1 07C4 15 ISZERO 07C5 61 PUSH2 0x080f 07C8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x080f, if !stack[-1] label_07C9: // Incoming jump from 0x07C8, if not !stack[-1] // Inputs[1] { @07C9 stack[-1] } 07C9 80 DUP1 07CA 60 PUSH1 0x1f 07CC 10 LT 07CD 61 PUSH2 0x07e4 07D0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07e4, if 0x1f < stack[-1] label_07D1: // Incoming jump from 0x07D0, if not 0x1f < stack[-1] // Inputs[4] // { // @07D5 stack[-2] // @07D6 storage[stack[-2]] // @07D9 stack[-3] // @07DB stack[-1] // } 07D1 61 PUSH2 0x0100 07D4 80 DUP1 07D5 83 DUP4 07D6 54 SLOAD 07D7 04 DIV 07D8 02 MUL 07D9 83 DUP4 07DA 52 MSTORE 07DB 91 SWAP2 07DC 60 PUSH1 0x20 07DE 01 ADD 07DF 91 SWAP2 07E0 61 PUSH2 0x080f 07E3 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @07DA memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @07DF stack[-1] = stack[-1] // @07DF stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x080f label_07E4: // Incoming jump from 0x07D0, if 0x1f < stack[-1] // Inputs[5] // { // @07E5 stack[-3] // @07E6 stack[-1] // @07E8 stack[-2] // @07F0 memory[0x00:0x20] // @07F4 storage[keccak256(memory[0x00:0x20])] // } 07E4 5B JUMPDEST 07E5 82 DUP3 07E6 01 ADD 07E7 91 SWAP2 07E8 90 SWAP1 07E9 60 PUSH1 0x00 07EB 52 MSTORE 07EC 60 PUSH1 0x20 07EE 60 PUSH1 0x00 07F0 20 SHA3 07F1 90 SWAP1 07F2 5B JUMPDEST 07F3 81 DUP2 07F4 54 SLOAD 07F5 81 DUP2 07F6 52 MSTORE 07F7 90 SWAP1 07F8 60 PUSH1 0x01 07FA 01 ADD 07FB 90 SWAP1 07FC 60 PUSH1 0x20 07FE 01 ADD 07FF 80 DUP1 0800 83 DUP4 0801 11 GT 0802 61 PUSH2 0x07f2 0805 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @07E7 stack[-3] = stack[-3] + stack[-1] // @07EB memory[0x00:0x20] = stack[-2] // @07F6 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @07FB stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @07FE stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x07f2, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0806: // Incoming jump from 0x0805, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0805, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0806 stack[-3] // @0807 stack[-1] // } 0806 82 DUP3 0807 90 SWAP1 0808 03 SUB 0809 60 PUSH1 0x1f 080B 16 AND 080C 82 DUP3 080D 01 ADD 080E 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @080E stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @080E stack[-1] = stack[-3] // } // Block continues label_080F: // Incoming jump from 0x07C8, if !stack[-1] // Incoming jump from 0x07E3 // Incoming jump from 0x080E // Inputs[1] { @0815 stack[-7] } 080F 5B JUMPDEST 0810 50 POP 0811 50 POP 0812 50 POP 0813 50 POP 0814 50 POP 0815 81 DUP2 0816 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0817: // Incoming call from 0x0FB0, returns to 0x0FB1 // Incoming call from 0x055A, returns to 0x055B // Incoming jump from 0x0279 // Incoming call from 0x1060, returns to 0x1061 // Incoming call from 0x10BE, returns to 0x10BF // Inputs[3] // { // @081A stack[-1] // @0825 memory[0x00:0x40] // @0826 storage[keccak256(memory[0x00:0x40])] // } 0817 5B JUMPDEST 0818 60 PUSH1 0x00 081A 81 DUP2 081B 81 DUP2 081C 52 MSTORE 081D 60 PUSH1 0x02 081F 60 PUSH1 0x20 0821 52 MSTORE 0822 60 PUSH1 0x40 0824 81 DUP2 0825 20 SHA3 0826 54 SLOAD 0827 60 PUSH1 0x01 0829 60 PUSH1 0x01 082B 60 PUSH1 0xa0 082D 1B SHL 082E 03 SUB 082F 16 AND 0830 80 DUP1 0831 61 PUSH2 0x042b 0834 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0818 stack[0] = 0x00 // @081C memory[0x00:0x20] = stack[-1] // @0821 memory[0x20:0x40] = 0x02 // @082F stack[1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x042b, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_0835: // Incoming jump from 0x0834, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0837 memory[0x40:0x60] } 0835 60 PUSH1 0x40 0837 51 MLOAD 0838 62 PUSH3 0x461bcd 083C 60 PUSH1 0xe5 083E 1B SHL 083F 81 DUP2 0840 52 MSTORE 0841 60 PUSH1 0x20 0843 60 PUSH1 0x04 0845 82 DUP3 0846 01 ADD 0847 52 MSTORE 0848 60 PUSH1 0x29 084A 60 PUSH1 0x24 084C 82 DUP3 084D 01 ADD 084E 52 MSTORE 084F 7F PUSH32 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 0870 60 PUSH1 0x44 0872 82 DUP3 0873 01 ADD 0874 52 MSTORE 0875 68 PUSH9 0x32b73a103a37b5b2b7 087F 60 PUSH1 0xb9 0881 1B SHL 0882 60 PUSH1 0x64 0884 82 DUP3 0885 01 ADD 0886 52 MSTORE 0887 60 PUSH1 0x84 0889 01 ADD 088A 61 PUSH2 0x052b 088D 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0840 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0847 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @084E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0874 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 // @0886 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x32b73a103a37b5b2b7 << 0xb9 // @0889 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x052b label_088E: // Incoming jump from 0x028C // Inputs[1] { @088F msg.sender } 088E 5B JUMPDEST 088F 33 CALLER 0890 61 PUSH2 0x0897 0893 61 PUSH2 0x09f0 0896 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @088F stack[0] = msg.sender // @0890 stack[1] = 0x0897 // } // Block ends with call to 0x09f0, returns to 0x0897 label_0897: // Incoming return from call to 0x09F0 at 0x0896 // Inputs[2] // { // @08A0 stack[-1] // @08A1 stack[-2] // } 0897 5B JUMPDEST 0898 60 PUSH1 0x01 089A 60 PUSH1 0x01 089C 60 PUSH1 0xa0 089E 1B SHL 089F 03 SUB 08A0 16 AND 08A1 14 EQ 08A2 61 PUSH2 0x08bd 08A5 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x08bd, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_08A6: // Incoming jump from 0x08A5, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @08A8 memory[0x40:0x60] } 08A6 60 PUSH1 0x40 08A8 51 MLOAD 08A9 62 PUSH3 0x461bcd 08AD 60 PUSH1 0xe5 08AF 1B SHL 08B0 81 DUP2 08B1 52 MSTORE 08B2 60 PUSH1 0x04 08B4 01 ADD 08B5 61 PUSH2 0x052b 08B8 90 SWAP1 08B9 61 PUSH2 0x1c8a 08BC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @08B1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08B8 stack[0] = 0x052b // @08B8 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1c8a, returns to 0x052B label_08BD: // Incoming jump from 0x08A5, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[2] // { // @08BE stack[-1] // @08BF memory[stack[-1]:stack[-1] + 0x20] // } 08BD 5B JUMPDEST 08BE 80 DUP1 08BF 51 MLOAD 08C0 61 PUSH2 0x0715 08C3 90 SWAP1 08C4 60 PUSH1 0x09 08C6 90 SWAP1 08C7 60 PUSH1 0x20 08C9 84 DUP5 08CA 01 ADD 08CB 90 SWAP1 08CC 61 PUSH2 0x16e6 08CF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08C3 stack[0] = 0x0715 // @08C6 stack[1] = 0x09 // @08CB stack[2] = stack[-1] + 0x20 // @08CB stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x16e6 08D0 5B JUMPDEST 08D1 60 PUSH1 0x00 08D3 60 PUSH1 0x01 08D5 60 PUSH1 0x01 08D7 60 PUSH1 0xa0 08D9 1B SHL 08DA 03 SUB 08DB 82 DUP3 08DC 16 AND 08DD 61 PUSH2 0x093b 08E0 57 *JUMPI 08E1 60 PUSH1 0x40 08E3 51 MLOAD 08E4 62 PUSH3 0x461bcd 08E8 60 PUSH1 0xe5 08EA 1B SHL 08EB 81 DUP2 08EC 52 MSTORE 08ED 60 PUSH1 0x20 08EF 60 PUSH1 0x04 08F1 82 DUP3 08F2 01 ADD 08F3 52 MSTORE 08F4 60 PUSH1 0x2a 08F6 60 PUSH1 0x24 08F8 82 DUP3 08F9 01 ADD 08FA 52 MSTORE 08FB 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 091C 60 PUSH1 0x44 091E 82 DUP3 091F 01 ADD 0920 52 MSTORE 0921 69 PUSH10 0x726f2061646472657373 092C 60 PUSH1 0xb0 092E 1B SHL 092F 60 PUSH1 0x64 0931 82 DUP3 0932 01 ADD 0933 52 MSTORE 0934 60 PUSH1 0x84 0936 01 ADD 0937 61 PUSH2 0x052b 093A 56 *JUMP 093B 5B JUMPDEST 093C 50 POP 093D 60 PUSH1 0x01 093F 60 PUSH1 0x01 0941 60 PUSH1 0xa0 0943 1B SHL 0944 03 SUB 0945 16 AND 0946 60 PUSH1 0x00 0948 90 SWAP1 0949 81 DUP2 094A 52 MSTORE 094B 60 PUSH1 0x03 094D 60 PUSH1 0x20 094F 52 MSTORE 0950 60 PUSH1 0x40 0952 90 SWAP1 0953 20 SHA3 0954 54 SLOAD 0955 90 SWAP1 0956 56 *JUMP label_0957: // Incoming call from 0x02B5, returns to 0x01D4 // Inputs[1] { @0958 msg.sender } 0957 5B JUMPDEST 0958 33 CALLER 0959 61 PUSH2 0x0960 095C 61 PUSH2 0x09f0 095F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0958 stack[0] = msg.sender // @0959 stack[1] = 0x0960 // } // Block ends with call to 0x09f0, returns to 0x0960 label_0960: // Incoming return from call to 0x09F0 at 0x095F // Inputs[2] // { // @0969 stack[-1] // @096A stack[-2] // } 0960 5B JUMPDEST 0961 60 PUSH1 0x01 0963 60 PUSH1 0x01 0965 60 PUSH1 0xa0 0967 1B SHL 0968 03 SUB 0969 16 AND 096A 14 EQ 096B 61 PUSH2 0x0986 096E 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0986, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_096F: // Incoming jump from 0x096E, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @0971 memory[0x40:0x60] } 096F 60 PUSH1 0x40 0971 51 MLOAD 0972 62 PUSH3 0x461bcd 0976 60 PUSH1 0xe5 0978 1B SHL 0979 81 DUP2 097A 52 MSTORE 097B 60 PUSH1 0x04 097D 01 ADD 097E 61 PUSH2 0x052b 0981 90 SWAP1 0982 61 PUSH2 0x1c8a 0985 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @097A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0981 stack[0] = 0x052b // @0981 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1c8a, returns to 0x052B label_0986: // Incoming jump from 0x096E, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 0986 5B JUMPDEST 0987 61 PUSH2 0x0990 098A 60 PUSH1 0x00 098C 61 PUSH2 0x135a 098F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0987 stack[0] = 0x0990 // @098A stack[1] = 0x00 // } // Block ends with call to 0x135a, returns to 0x0990 label_0990: // Incoming return from call to 0x135A at 0x098F // Inputs[1] { @0991 stack[-1] } 0990 5B JUMPDEST 0991 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0992: // Incoming call from 0x02BD, returns to 0x0194 // Inputs[1] { @0996 storage[0x09] } 0992 5B JUMPDEST 0993 60 PUSH1 0x09 0995 80 DUP1 0996 54 SLOAD 0997 61 PUSH2 0x0796 099A 90 SWAP1 099B 61 PUSH2 0x1ba5 099E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0993 stack[0] = 0x09 // @099A stack[1] = 0x0796 // @099A stack[2] = storage[0x09] // } // Block ends with call to 0x1ba5, returns to 0x0796 099F 5B JUMPDEST 09A0 33 CALLER 09A1 61 PUSH2 0x09a8 09A4 61 PUSH2 0x09f0 09A7 56 *JUMP 09A8 5B JUMPDEST 09A9 60 PUSH1 0x01 09AB 60 PUSH1 0x01 09AD 60 PUSH1 0xa0 09AF 1B SHL 09B0 03 SUB 09B1 16 AND 09B2 14 EQ 09B3 61 PUSH2 0x09ce 09B6 57 *JUMPI 09B7 60 PUSH1 0x40 09B9 51 MLOAD 09BA 62 PUSH3 0x461bcd 09BE 60 PUSH1 0xe5 09C0 1B SHL 09C1 81 DUP2 09C2 52 MSTORE 09C3 60 PUSH1 0x04 09C5 01 ADD 09C6 61 PUSH2 0x052b 09C9 90 SWAP1 09CA 61 PUSH2 0x1c8a 09CD 56 *JUMP 09CE 5B JUMPDEST 09CF 60 PUSH1 0x07 09D1 80 DUP1 09D2 54 SLOAD 09D3 60 PUSH1 0x01 09D5 60 PUSH1 0x01 09D7 60 PUSH1 0xa0 09D9 1B SHL 09DA 03 SUB 09DB 19 NOT 09DC 16 AND 09DD 60 PUSH1 0x01 09DF 60 PUSH1 0x01 09E1 60 PUSH1 0xa0 09E3 1B SHL 09E4 03 SUB 09E5 92 SWAP3 09E6 90 SWAP1 09E7 92 SWAP3 09E8 16 AND 09E9 91 SWAP2 09EA 90 SWAP1 09EB 91 SWAP2 09EC 17 OR 09ED 90 SWAP1 09EE 55 SSTORE 09EF 56 *JUMP label_09F0: // Incoming call from 0x095F, returns to 0x0960 // Incoming call from 0x06E4, returns to 0x06E5 // Incoming call from 0x02D8, returns to 0x01B4 // Incoming call from 0x0721, returns to 0x0722 // Incoming call from 0x0E23, returns to 0x0E24 // Incoming call from 0x0896, returns to 0x0897 // Inputs[2] // { // @09F3 storage[0x06] // @09FD stack[-1] // } 09F0 5B JUMPDEST 09F1 60 PUSH1 0x06 09F3 54 SLOAD 09F4 60 PUSH1 0x01 09F6 60 PUSH1 0x01 09F8 60 PUSH1 0xa0 09FA 1B SHL 09FB 03 SUB 09FC 16 AND 09FD 90 SWAP1 09FE 56 *JUMP // Stack delta = +0 // Outputs[1] { @09FD stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x06] } // Block ends with unconditional jump to stack[-1] label_09FF: // Incoming call from 0x02E0, returns to 0x0194 // Inputs[1] { @0A05 storage[0x01] } 09FF 5B JUMPDEST 0A00 60 PUSH1 0x60 0A02 60 PUSH1 0x01 0A04 80 DUP1 0A05 54 SLOAD 0A06 61 PUSH2 0x0440 0A09 90 SWAP1 0A0A 61 PUSH2 0x1ba5 0A0D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A00 stack[0] = 0x60 // @0A02 stack[1] = 0x01 // @0A09 stack[2] = 0x0440 // @0A09 stack[3] = storage[0x01] // } // Block ends with call to 0x1ba5, returns to 0x0440 label_0A0E: // Incoming jump from 0x0325 // Inputs[2] // { // @0A17 stack[-2] // @0A19 msg.sender // } 0A0E 5B JUMPDEST 0A0F 60 PUSH1 0x01 0A11 60 PUSH1 0x01 0A13 60 PUSH1 0xa0 0A15 1B SHL 0A16 03 SUB 0A17 82 DUP3 0A18 16 AND 0A19 33 CALLER 0A1A 14 EQ 0A1B 15 ISZERO 0A1C 61 PUSH2 0x0a63 0A1F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a63, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) label_0A20: // Incoming jump from 0x0A1F, if not !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[1] { @0A22 memory[0x40:0x60] } 0A20 60 PUSH1 0x40 0A22 51 MLOAD 0A23 62 PUSH3 0x461bcd 0A27 60 PUSH1 0xe5 0A29 1B SHL 0A2A 81 DUP2 0A2B 52 MSTORE 0A2C 60 PUSH1 0x20 0A2E 60 PUSH1 0x04 0A30 82 DUP3 0A31 01 ADD 0A32 52 MSTORE 0A33 60 PUSH1 0x19 0A35 60 PUSH1 0x24 0A37 82 DUP3 0A38 01 ADD 0A39 52 MSTORE 0A3A 78 PUSH25 0x22a9219b99189d1030b8383937bb32903a379031b0b63632b9 0A54 60 PUSH1 0x39 0A56 1B SHL 0A57 60 PUSH1 0x44 0A59 82 DUP3 0A5A 01 ADD 0A5B 52 MSTORE 0A5C 60 PUSH1 0x64 0A5E 01 ADD 0A5F 61 PUSH2 0x052b 0A62 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A2B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A32 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A39 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @0A5B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x22a9219b99189d1030b8383937bb32903a379031b0b63632b9 << 0x39 // @0A5E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x052b label_0A63: // Incoming jump from 0x0A1F, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[10] // { // @0A64 msg.sender // @0A75 memory[0x00:0x40] // @0A7E stack[-2] // @0A89 memory[0x00:0x40] // @0A8B storage[keccak256(memory[0x00:0x40])] // @0A90 stack[-1] // @0A9A memory[0x40:0x60] // @0AC6 memory[0x40:0x60] // @0ACB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0ACE stack[-3] // } 0A63 5B JUMPDEST 0A64 33 CALLER 0A65 60 PUSH1 0x00 0A67 81 DUP2 0A68 81 DUP2 0A69 52 MSTORE 0A6A 60 PUSH1 0x05 0A6C 60 PUSH1 0x20 0A6E 90 SWAP1 0A6F 81 DUP2 0A70 52 MSTORE 0A71 60 PUSH1 0x40 0A73 80 DUP1 0A74 83 DUP4 0A75 20 SHA3 0A76 60 PUSH1 0x01 0A78 60 PUSH1 0x01 0A7A 60 PUSH1 0xa0 0A7C 1B SHL 0A7D 03 SUB 0A7E 87 DUP8 0A7F 16 AND 0A80 80 DUP1 0A81 85 DUP6 0A82 52 MSTORE 0A83 90 SWAP1 0A84 83 DUP4 0A85 52 MSTORE 0A86 92 SWAP3 0A87 81 DUP2 0A88 90 SWAP1 0A89 20 SHA3 0A8A 80 DUP1 0A8B 54 SLOAD 0A8C 60 PUSH1 0xff 0A8E 19 NOT 0A8F 16 AND 0A90 86 DUP7 0A91 15 ISZERO 0A92 15 ISZERO 0A93 90 SWAP1 0A94 81 DUP2 0A95 17 OR 0A96 90 SWAP1 0A97 91 SWAP2 0A98 55 SSTORE 0A99 90 SWAP1 0A9A 51 MLOAD 0A9B 90 SWAP1 0A9C 81 DUP2 0A9D 52 MSTORE 0A9E 91 SWAP2 0A9F 92 SWAP3 0AA0 91 SWAP2 0AA1 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0AC2 91 SWAP2 0AC3 01 ADD 0AC4 60 PUSH1 0x40 0AC6 51 MLOAD 0AC7 80 DUP1 0AC8 91 SWAP2 0AC9 03 SUB 0ACA 90 SWAP1 0ACB A3 LOG3 0ACC 50 POP 0ACD 50 POP 0ACE 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0A69 memory[0x00:0x20] = msg.sender // @0A70 memory[0x20:0x40] = 0x05 // @0A82 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0A85 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0A98 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0A9D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0ACB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-3] label_0ACF: // Incoming jump from 0x077C // Inputs[2] // { // @0AD3 msg.sender // @0AD4 stack[-2] // } 0ACF 5B JUMPDEST 0AD0 61 PUSH2 0x0ad9 0AD3 33 CALLER 0AD4 83 DUP4 0AD5 61 PUSH2 0x0fea 0AD8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AD0 stack[0] = 0x0ad9 // @0AD3 stack[1] = msg.sender // @0AD4 stack[2] = stack[-2] // } // Block ends with call to 0x0fea, returns to 0x0AD9 label_0AD9: // Incoming return from call to 0x0FEA at 0x0AD8 // Inputs[1] { @0ADD stack[-1] } 0AD9 5B JUMPDEST 0ADA 61 PUSH2 0x0af5 0ADD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0af5, if stack[-1] label_0ADE: // Incoming jump from 0x0ADD, if not stack[-1] // Inputs[1] { @0AE0 memory[0x40:0x60] } 0ADE 60 PUSH1 0x40 0AE0 51 MLOAD 0AE1 62 PUSH3 0x461bcd 0AE5 60 PUSH1 0xe5 0AE7 1B SHL 0AE8 81 DUP2 0AE9 52 MSTORE 0AEA 60 PUSH1 0x04 0AEC 01 ADD 0AED 61 PUSH2 0x052b 0AF0 90 SWAP1 0AF1 61 PUSH2 0x1bda 0AF4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0AE9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AF0 stack[0] = 0x052b // @0AF0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1bda, returns to 0x052B label_0AF5: // Incoming jump from 0x0ADD, if stack[-1] // Inputs[4] // { // @0AF9 stack[-4] // @0AFA stack[-3] // @0AFB stack[-2] // @0AFC stack[-1] // } 0AF5 5B JUMPDEST 0AF6 61 PUSH2 0x0b01 0AF9 84 DUP5 0AFA 84 DUP5 0AFB 84 DUP5 0AFC 84 DUP5 0AFD 61 PUSH2 0x13ac 0B00 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0AF6 stack[0] = 0x0b01 // @0AF9 stack[1] = stack[-4] // @0AFA stack[2] = stack[-3] // @0AFB stack[3] = stack[-2] // @0AFC stack[4] = stack[-1] // } // Block ends with call to 0x13ac, returns to 0x0B01 label_0B01: // Incoming jump from 0x13C7, if stack[-1] // Incoming jump from 0x17D5, if !(stack[-1] > stack[-4]) // Incoming return from call to 0x13AC at 0x0B00 // Inputs[1] { @0B06 stack[-5] } 0B01 5B JUMPDEST 0B02 50 POP 0B03 50 POP 0B04 50 POP 0B05 50 POP 0B06 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0B07: // Incoming jump from 0x034B // Inputs[1] { @0B0D stack[-1] } 0B07 5B JUMPDEST 0B08 60 PUSH1 0x60 0B0A 61 PUSH2 0x0b12 0B0D 82 DUP3 0B0E 61 PUSH2 0x0f5f 0B11 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B08 stack[0] = 0x60 // @0B0A stack[1] = 0x0b12 // @0B0D stack[2] = stack[-1] // } // Block ends with call to 0x0f5f, returns to 0x0B12 label_0B12: // Incoming return from call to 0x0F5F at 0x0B11 // Inputs[1] { @0B16 stack[-1] } 0B12 5B JUMPDEST 0B13 61 PUSH2 0x0b51 0B16 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b51, if stack[-1] label_0B17: // Incoming jump from 0x0B16, if not stack[-1] // Inputs[1] { @0B19 memory[0x40:0x60] } 0B17 60 PUSH1 0x40 0B19 51 MLOAD 0B1A 62 PUSH3 0x461bcd 0B1E 60 PUSH1 0xe5 0B20 1B SHL 0B21 81 DUP2 0B22 52 MSTORE 0B23 60 PUSH1 0x20 0B25 60 PUSH1 0x04 0B27 82 DUP3 0B28 01 ADD 0B29 52 MSTORE 0B2A 60 PUSH1 0x10 0B2C 60 PUSH1 0x24 0B2E 82 DUP3 0B2F 01 ADD 0B30 52 MSTORE 0B31 6F PUSH16 0x1d1bdad95b881b5d5cdd08195e1a5cdd 0B42 60 PUSH1 0x82 0B44 1B SHL 0B45 60 PUSH1 0x44 0B47 82 DUP3 0B48 01 ADD 0B49 52 MSTORE 0B4A 60 PUSH1 0x64 0B4C 01 ADD 0B4D 61 PUSH2 0x052b 0B50 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0B22 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B29 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B30 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @0B49 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1d1bdad95b881b5d5cdd08195e1a5cdd << 0x82 // @0B4C stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x052b label_0B51: // Incoming jump from 0x0B16, if stack[-1] // Inputs[3] // { // @0B54 stack[-2] // @0B5F memory[0x00:0x40] // @0B61 storage[keccak256(memory[0x00:0x40])] // } 0B51 5B JUMPDEST 0B52 60 PUSH1 0x00 0B54 82 DUP3 0B55 81 DUP2 0B56 52 MSTORE 0B57 60 PUSH1 0x0a 0B59 60 PUSH1 0x20 0B5B 52 MSTORE 0B5C 60 PUSH1 0x40 0B5E 81 DUP2 0B5F 20 SHA3 0B60 80 DUP1 0B61 54 SLOAD 0B62 61 PUSH2 0x0b6a 0B65 90 SWAP1 0B66 61 PUSH2 0x1ba5 0B69 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0B52 stack[0] = 0x00 // @0B56 memory[0x00:0x20] = stack[-2] // @0B5B memory[0x20:0x40] = 0x0a // @0B5F stack[1] = keccak256(memory[0x00:0x40]) // @0B65 stack[2] = 0x0b6a // @0B65 stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1ba5, returns to 0x0B6A label_0B6A: // Incoming return from call to 0x1BA5 at 0x0B69 // Inputs[4] // { // @0B6B stack[-1] // @0B7A memory[0x40:0x60] // @0B82 stack[-2] // @0B8D storage[stack[-2]] // } 0B6A 5B JUMPDEST 0B6B 80 DUP1 0B6C 60 PUSH1 0x1f 0B6E 01 ADD 0B6F 60 PUSH1 0x20 0B71 80 DUP1 0B72 91 SWAP2 0B73 04 DIV 0B74 02 MUL 0B75 60 PUSH1 0x20 0B77 01 ADD 0B78 60 PUSH1 0x40 0B7A 51 MLOAD 0B7B 90 SWAP1 0B7C 81 DUP2 0B7D 01 ADD 0B7E 60 PUSH1 0x40 0B80 52 MSTORE 0B81 80 DUP1 0B82 92 SWAP3 0B83 91 SWAP2 0B84 90 SWAP1 0B85 81 DUP2 0B86 81 DUP2 0B87 52 MSTORE 0B88 60 PUSH1 0x20 0B8A 01 ADD 0B8B 82 DUP3 0B8C 80 DUP1 0B8D 54 SLOAD 0B8E 61 PUSH2 0x0b96 0B91 90 SWAP1 0B92 61 PUSH2 0x1ba5 0B95 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0B80 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0B82 stack[-2] = memory[0x40:0x60] // @0B83 stack[-1] = stack[-2] // @0B84 stack[0] = stack[-1] // @0B87 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0B8A stack[1] = 0x20 + memory[0x40:0x60] // @0B8B stack[2] = stack[-2] // @0B91 stack[4] = storage[stack[-2]] // @0B91 stack[3] = 0x0b96 // } // Block ends with call to 0x1ba5, returns to 0x0B96 label_0B96: // Incoming return from call to 0x1BA5 at 0x0B95 // Inputs[1] { @0B97 stack[-1] } 0B96 5B JUMPDEST 0B97 80 DUP1 0B98 15 ISZERO 0B99 61 PUSH2 0x0be3 0B9C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0be3, if !stack[-1] label_0B9D: // Incoming jump from 0x0B9C, if not !stack[-1] // Inputs[1] { @0B9D stack[-1] } 0B9D 80 DUP1 0B9E 60 PUSH1 0x1f 0BA0 10 LT 0BA1 61 PUSH2 0x0bb8 0BA4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bb8, if 0x1f < stack[-1] label_0BA5: // Incoming jump from 0x0BA4, if not 0x1f < stack[-1] // Inputs[4] // { // @0BA9 stack[-2] // @0BAA storage[stack[-2]] // @0BAD stack[-3] // @0BAF stack[-1] // } 0BA5 61 PUSH2 0x0100 0BA8 80 DUP1 0BA9 83 DUP4 0BAA 54 SLOAD 0BAB 04 DIV 0BAC 02 MUL 0BAD 83 DUP4 0BAE 52 MSTORE 0BAF 91 SWAP2 0BB0 60 PUSH1 0x20 0BB2 01 ADD 0BB3 91 SWAP2 0BB4 61 PUSH2 0x0be3 0BB7 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0BAE memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0BB3 stack[-1] = stack[-1] // @0BB3 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0be3 label_0BB8: // Incoming jump from 0x0BA4, if 0x1f < stack[-1] // Inputs[5] // { // @0BB9 stack[-3] // @0BBA stack[-1] // @0BBC stack[-2] // @0BC4 memory[0x00:0x20] // @0BC8 storage[keccak256(memory[0x00:0x20])] // } 0BB8 5B JUMPDEST 0BB9 82 DUP3 0BBA 01 ADD 0BBB 91 SWAP2 0BBC 90 SWAP1 0BBD 60 PUSH1 0x00 0BBF 52 MSTORE 0BC0 60 PUSH1 0x20 0BC2 60 PUSH1 0x00 0BC4 20 SHA3 0BC5 90 SWAP1 0BC6 5B JUMPDEST 0BC7 81 DUP2 0BC8 54 SLOAD 0BC9 81 DUP2 0BCA 52 MSTORE 0BCB 90 SWAP1 0BCC 60 PUSH1 0x01 0BCE 01 ADD 0BCF 90 SWAP1 0BD0 60 PUSH1 0x20 0BD2 01 ADD 0BD3 80 DUP1 0BD4 83 DUP4 0BD5 11 GT 0BD6 61 PUSH2 0x0bc6 0BD9 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0BBB stack[-3] = stack[-3] + stack[-1] // @0BBF memory[0x00:0x20] = stack[-2] // @0BCA memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0BCF stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0BD2 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0bc6, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0BDA: // Incoming jump from 0x0BD9, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0BD9, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0BDA stack[-3] // @0BDB stack[-1] // } 0BDA 82 DUP3 0BDB 90 SWAP1 0BDC 03 SUB 0BDD 60 PUSH1 0x1f 0BDF 16 AND 0BE0 82 DUP3 0BE1 01 ADD 0BE2 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0BE2 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0BE2 stack[-1] = stack[-3] // } // Block continues label_0BE3: // Incoming jump from 0x0BB7 // Incoming jump from 0x0BE2 // Incoming jump from 0x0B9C, if !stack[-1] // Inputs[3] // { // @0BE9 stack[-7] // @0BE9 stack[-6] // @0BEE memory[stack[-6]:stack[-6] + 0x20] // } 0BE3 5B JUMPDEST 0BE4 50 POP 0BE5 50 POP 0BE6 50 POP 0BE7 50 POP 0BE8 50 POP 0BE9 90 SWAP1 0BEA 50 POP 0BEB 60 PUSH1 0x00 0BED 81 DUP2 0BEE 51 MLOAD 0BEF 11 GT 0BF0 15 ISZERO 0BF1 61 PUSH2 0x0c1c 0BF4 57 *JUMPI // Stack delta = -6 // Outputs[1] { @0BE9 stack[-7] = stack[-6] } // Block ends with conditional jump to 0x0c1c, if !(memory[stack[-6]:stack[-6] + 0x20] > 0x00) label_0BF5: // Incoming jump from 0x0BF4, if not !(memory[stack[-6]:stack[-6] + 0x20] > 0x00) // Inputs[2] // { // @0BF5 stack[-1] // @0BF8 memory[0x40:0x60] // } 0BF5 80 DUP1 0BF6 60 PUSH1 0x40 0BF8 51 MLOAD 0BF9 60 PUSH1 0x20 0BFB 01 ADD 0BFC 61 PUSH2 0x0c05 0BFF 91 SWAP2 0C00 90 SWAP1 0C01 61 PUSH2 0x1cbf 0C04 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BFF stack[0] = 0x0c05 // @0C00 stack[1] = stack[-1] // @0C00 stack[2] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x1cbf, returns to 0x0C05 label_0C05: // Incoming return from call to 0x1CBF at 0x0C04 // Inputs[5] // { // @0C08 memory[0x40:0x60] // @0C0C stack[-1] // @0C15 stack[-3] // @0C18 stack[-5] // @0C19 stack[-4] // } 0C05 5B JUMPDEST 0C06 60 PUSH1 0x40 0C08 51 MLOAD 0C09 60 PUSH1 0x20 0C0B 81 DUP2 0C0C 83 DUP4 0C0D 03 SUB 0C0E 03 SUB 0C0F 81 DUP2 0C10 52 MSTORE 0C11 90 SWAP1 0C12 60 PUSH1 0x40 0C14 52 MSTORE 0C15 91 SWAP2 0C16 50 POP 0C17 50 POP 0C18 91 SWAP2 0C19 90 SWAP1 0C1A 50 POP 0C1B 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @0C10 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @0C14 memory[0x40:0x60] = stack[-1] // @0C18 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-5] label_0C1C: // Incoming jump from 0x0BF4, if !(memory[stack[-6]:stack[-6] + 0x20] > 0x00) // Inputs[1] { @0C20 stack[-3] } 0C1C 5B JUMPDEST 0C1D 61 PUSH2 0x0c25 0C20 83 DUP4 0C21 61 PUSH2 0x13df 0C24 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C1D stack[0] = 0x0c25 // @0C20 stack[1] = stack[-3] // } // Block ends with unconditional jump to 0x13df label_0C25: // Incoming return from call to 0x1904 at 0x1A3B // Incoming return from call to 0x17DE at 0x181C // Incoming jump from 0x1BA0, if msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0x60) - 0x01 // Incoming return from call to 0x177F at 0x1E2A // Incoming return from call to 0x184A at 0x1D20 // Incoming return from call to 0x177F at 0x17B1 // Incoming return from call to 0x184A at 0x19DD // Inputs[3] // { // @0C26 stack[-1] // @0C26 stack[-5] // @0C27 stack[-4] // } 0C25 5B JUMPDEST 0C26 93 SWAP4 0C27 92 SWAP3 0C28 50 POP 0C29 50 POP 0C2A 50 POP 0C2B 56 *JUMP // Stack delta = -4 // Outputs[1] { @0C26 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0C2C: // Incoming jump from 0x1BC4, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x1BC4, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @0C2E stack[-4] // @0C2E stack[-2] // @0C2F stack[-3] // } 0C2C 5B JUMPDEST 0C2D 50 POP 0C2E 91 SWAP2 0C2F 90 SWAP1 0C30 50 POP 0C31 56 *JUMP // Stack delta = -3 // Outputs[1] { @0C2E stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_0C32: // Incoming jump from 0x035E // Inputs[2] // { // @0C36 memory[0x40:0x60] // @0C51 memory[0x40:0x60] // } 0C32 5B JUMPDEST 0C33 60 PUSH1 0x40 0C35 80 DUP1 0C36 51 MLOAD 0C37 60 PUSH1 0x01 0C39 80 DUP1 0C3A 82 DUP3 0C3B 52 MSTORE 0C3C 81 DUP2 0C3D 83 DUP4 0C3E 01 ADD 0C3F 90 SWAP1 0C40 92 SWAP3 0C41 52 MSTORE 0C42 60 PUSH1 0x60 0C44 91 SWAP2 0C45 60 PUSH1 0x00 0C47 91 SWAP2 0C48 90 SWAP1 0C49 81 DUP2 0C4A 60 PUSH1 0x20 0C4C 01 ADD 0C4D 5B JUMPDEST 0C4E 60 PUSH1 0x40 0C50 80 DUP1 0C51 51 MLOAD 0C52 80 DUP1 0C53 82 DUP3 0C54 01 ADD 0C55 90 SWAP1 0C56 91 SWAP2 0C57 52 MSTORE 0C58 60 PUSH1 0x00 0C5A 80 DUP1 0C5B 82 DUP3 0C5C 52 MSTORE 0C5D 60 PUSH1 0x20 0C5F 82 DUP3 0C60 01 ADD 0C61 52 MSTORE 0C62 81 DUP2 0C63 52 MSTORE 0C64 60 PUSH1 0x20 0C66 01 ADD 0C67 90 SWAP1 0C68 60 PUSH1 0x01 0C6A 90 SWAP1 0C6B 03 SUB 0C6C 90 SWAP1 0C6D 81 DUP2 0C6E 61 PUSH2 0x0c4d 0C71 57 *JUMPI // Stack delta = +5 // Outputs[11] // { // @0C3B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @0C41 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0C44 stack[0] = 0x60 // @0C47 stack[1] = 0x00 // @0C48 stack[2] = memory[0x40:0x60] // @0C57 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0C5C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0C61 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @0C63 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[0x40:0x60] // @0C6C stack[3] = 0x01 - 0x01 // @0C6C stack[4] = 0x20 + 0x20 + memory[0x40:0x60] // } // Block ends with conditional jump to 0x0c4d, if 0x01 - 0x01 label_0C72: // Incoming jump from 0x0C71, if not stack[-2] - 0x01 // Incoming jump from 0x0C71, if not 0x01 - 0x01 // Inputs[6] // { // @0C72 stack[-2] // @0C72 stack[-1] // @0C75 stack[-4] // @0C75 stack[-3] // @0C7C storage[0x06] // @0C91 memory[stack[-3]:stack[-3] + 0x20] // } 0C72 90 SWAP1 0C73 50 POP 0C74 50 POP 0C75 90 SWAP1 0C76 50 POP 0C77 60 PUSH1 0x06 0C79 60 PUSH1 0x14 0C7B 90 SWAP1 0C7C 54 SLOAD 0C7D 90 SWAP1 0C7E 61 PUSH2 0x0100 0C81 0A EXP 0C82 90 SWAP1 0C83 04 DIV 0C84 60 PUSH1 0x01 0C86 60 PUSH1 0x01 0C88 60 PUSH1 0x60 0C8A 1B SHL 0C8B 03 SUB 0C8C 16 AND 0C8D 81 DUP2 0C8E 60 PUSH1 0x00 0C90 81 DUP2 0C91 51 MLOAD 0C92 81 DUP2 0C93 10 LT 0C94 61 PUSH2 0x0c9f 0C97 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0C75 stack[-4] = stack[-3] // @0C8C stack[-3] = (0x01 << 0x60) - 0x01 & storage[0x06] / 0x0100 ** 0x14 // @0C8D stack[-2] = stack[-3] // @0C8E stack[-1] = 0x00 // } // Block ends with conditional jump to 0x0c9f, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] label_0C98: // Incoming jump from 0x0C97, if not 0x00 < memory[stack[-3]:stack[-3] + 0x20] 0C98 61 PUSH2 0x0c9f 0C9B 61 PUSH2 0x1cee 0C9E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C98 stack[0] = 0x0c9f } // Block ends with unconditional jump to 0x1cee label_0C9F: // Incoming jump from 0x0C97, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[7] // { // @0CA2 stack[-1] // @0CA5 stack[-2] // @0CAB memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CB5 stack[-3] // @0CBC storage[0x07] // @0CBD stack[-4] // @0CBE memory[stack[-4]:stack[-4] + 0x20] // } 0C9F 5B JUMPDEST 0CA0 60 PUSH1 0x20 0CA2 90 SWAP1 0CA3 81 DUP2 0CA4 02 MUL 0CA5 91 SWAP2 0CA6 90 SWAP1 0CA7 91 SWAP2 0CA8 01 ADD 0CA9 81 DUP2 0CAA 01 ADD 0CAB 51 MLOAD 0CAC 60 PUSH1 0x01 0CAE 60 PUSH1 0x01 0CB0 60 PUSH1 0x60 0CB2 1B SHL 0CB3 03 SUB 0CB4 90 SWAP1 0CB5 92 SWAP3 0CB6 16 AND 0CB7 91 SWAP2 0CB8 01 ADD 0CB9 52 MSTORE 0CBA 60 PUSH1 0x07 0CBC 54 SLOAD 0CBD 81 DUP2 0CBE 51 MLOAD 0CBF 60 PUSH1 0x01 0CC1 60 PUSH1 0x01 0CC3 60 PUSH1 0xa0 0CC5 1B SHL 0CC6 03 SUB 0CC7 90 SWAP1 0CC8 91 SWAP2 0CC9 16 AND 0CCA 90 SWAP1 0CCB 82 DUP3 0CCC 90 SWAP1 0CCD 60 PUSH1 0x00 0CCF 90 SWAP1 0CD0 61 PUSH2 0x0cdb 0CD3 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0CB9 memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20 + 0x20] = stack[-3] & (0x01 << 0x60) - 0x01 // @0CCA stack[-3] = storage[0x07] & (0x01 << 0xa0) - 0x01 // @0CCC stack[-2] = stack[-4] // @0CCF stack[-1] = 0x00 // } // Block ends with conditional jump to 0x0cdb, if memory[stack[-4]:stack[-4] + 0x20] label_0CD4: // Incoming jump from 0x0CD3, if not memory[stack[-4]:stack[-4] + 0x20] 0CD4 61 PUSH2 0x0cdb 0CD7 61 PUSH2 0x1cee 0CDA 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CD4 stack[0] = 0x0cdb } // Block ends with unconditional jump to 0x1cee label_0CDB: // Incoming jump from 0x0CD3, if memory[stack[-4]:stack[-4] + 0x20] // Inputs[7] // { // @0CDE stack[-1] // @0CE1 stack[-2] // @0CE6 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] // @0CF0 stack[-3] // @0CF4 stack[-7] // @0CF4 stack[-4] // @0CF5 stack[-6] // } 0CDB 5B JUMPDEST 0CDC 60 PUSH1 0x20 0CDE 90 SWAP1 0CDF 81 DUP2 0CE0 02 MUL 0CE1 91 SWAP2 0CE2 90 SWAP1 0CE3 91 SWAP2 0CE4 01 ADD 0CE5 01 ADD 0CE6 51 MLOAD 0CE7 60 PUSH1 0x01 0CE9 60 PUSH1 0x01 0CEB 60 PUSH1 0xa0 0CED 1B SHL 0CEE 03 SUB 0CEF 90 SWAP1 0CF0 91 SWAP2 0CF1 16 AND 0CF2 90 SWAP1 0CF3 52 MSTORE 0CF4 92 SWAP3 0CF5 91 SWAP2 0CF6 50 POP 0CF7 50 POP 0CF8 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @0CF3 memory[memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20]:memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0CF4 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_0CF9: // Incoming jump from 0x05E4 // Incoming jump from 0x10AB // Inputs[4] // { // @0CFC storage[0x08] // @0CFF memory[0x40:0x60] // @0D1A stack[-1] // @0D29 stack[-2] // } 0CF9 5B JUMPDEST 0CFA 60 PUSH1 0x08 0CFC 54 SLOAD 0CFD 60 PUSH1 0x40 0CFF 51 MLOAD 0D00 63 PUSH4 0xc4552791 0D05 60 PUSH1 0xe0 0D07 1B SHL 0D08 81 DUP2 0D09 52 MSTORE 0D0A 60 PUSH1 0x00 0D0C 91 SWAP2 0D0D 60 PUSH1 0x01 0D0F 60 PUSH1 0x01 0D11 60 PUSH1 0xa0 0D13 1B SHL 0D14 03 SUB 0D15 90 SWAP1 0D16 81 DUP2 0D17 16 AND 0D18 91 SWAP2 0D19 90 SWAP1 0D1A 84 DUP5 0D1B 16 AND 0D1C 90 SWAP1 0D1D 82 DUP3 0D1E 90 SWAP1 0D1F 63 PUSH4 0xc4552791 0D24 90 SWAP1 0D25 61 PUSH2 0x0d32 0D28 90 SWAP1 0D29 88 DUP9 0D2A 90 SWAP1 0D2B 60 PUSH1 0x04 0D2D 01 ADD 0D2E 61 PUSH2 0x1836 0D31 56 *JUMP // Stack delta = +8 // Outputs[9] // { // @0D09 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xc4552791 << 0xe0 // @0D0C stack[0] = 0x00 // @0D18 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x08] // @0D1C stack[2] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0D1E stack[3] = (0x01 << 0xa0) - 0x01 & storage[0x08] // @0D24 stack[4] = 0xc4552791 // @0D28 stack[5] = 0x0d32 // @0D2A stack[6] = stack[-2] // @0D2D stack[7] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1836, returns to 0x0D32 label_0D32: // Incoming return from call to 0x1836 at 0x0D31 // Inputs[4] // { // @0D37 memory[0x40:0x60] // @0D39 stack[-1] // @0D3C stack[-3] // @0D3E address(stack[-3]).code.length // } 0D32 5B JUMPDEST 0D33 60 PUSH1 0x20 0D35 60 PUSH1 0x40 0D37 51 MLOAD 0D38 80 DUP1 0D39 83 DUP4 0D3A 03 SUB 0D3B 81 DUP2 0D3C 86 DUP7 0D3D 80 DUP1 0D3E 3B EXTCODESIZE 0D3F 15 ISZERO 0D40 80 DUP1 0D41 15 ISZERO 0D42 61 PUSH2 0x0d4a 0D45 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @0D33 stack[0] = 0x20 // @0D37 stack[1] = memory[0x40:0x60] // @0D3A stack[2] = stack[-1] - memory[0x40:0x60] // @0D3B stack[3] = memory[0x40:0x60] // @0D3C stack[4] = stack[-3] // @0D3F stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x0d4a, if !!address(stack[-3]).code.length label_0D46: // Incoming jump from 0x0D45, if not !!address(stack[-3]).code.length // Inputs[1] { @0D49 memory[0x00:0x00] } 0D46 60 PUSH1 0x00 0D48 80 DUP1 0D49 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D49 revert(memory[0x00:0x00]); } // Block terminates label_0D4A: // Incoming jump from 0x0D45, if !!address(stack[-3]).code.length // Inputs[8] // { // @0D4C msg.gas // @0D4D memory[stack[-3]:stack[-3] + stack[-4]] // @0D4D stack[-6] // @0D4D stack[-3] // @0D4D stack[-5] // @0D4D address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0D4D stack[-2] // @0D4D stack[-4] // } 0D4A 5B JUMPDEST 0D4B 50 POP 0D4C 5A GAS 0D4D FA STATICCALL 0D4E 15 ISZERO 0D4F 80 DUP1 0D50 15 ISZERO 0D51 61 PUSH2 0x0d5e 0D54 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0D4D memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0D4E stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0d5e, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0D55: // Incoming jump from 0x0D54, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0D55 returndata.length // @0D59 returndata[0x00:0x00 + returndata.length] // @0D5A returndata.length // @0D5D memory[0x00:0x00 + returndata.length] // } 0D55 3D RETURNDATASIZE 0D56 60 PUSH1 0x00 0D58 80 DUP1 0D59 3E RETURNDATACOPY 0D5A 3D RETURNDATASIZE 0D5B 60 PUSH1 0x00 0D5D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0D59 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0D5D revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0D5E: // Incoming jump from 0x0D54, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0D65 memory[0x40:0x60] // @0D66 returndata.length // } 0D5E 5B JUMPDEST 0D5F 50 POP 0D60 50 POP 0D61 50 POP 0D62 50 POP 0D63 60 PUSH1 0x40 0D65 51 MLOAD 0D66 3D RETURNDATASIZE 0D67 60 PUSH1 0x1f 0D69 19 NOT 0D6A 60 PUSH1 0x1f 0D6C 82 DUP3 0D6D 01 ADD 0D6E 16 AND 0D6F 82 DUP3 0D70 01 ADD 0D71 80 DUP1 0D72 60 PUSH1 0x40 0D74 52 MSTORE 0D75 50 POP 0D76 81 DUP2 0D77 01 ADD 0D78 90 SWAP1 0D79 61 PUSH2 0x0d82 0D7C 91 SWAP2 0D7D 90 SWAP1 0D7E 61 PUSH2 0x1d04 0D81 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0D74 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0D7C stack[-4] = 0x0d82 // @0D7D stack[-2] = memory[0x40:0x60] // @0D7D stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x1d04 0D82 5B JUMPDEST 0D83 60 PUSH1 0x01 0D85 60 PUSH1 0x01 0D87 60 PUSH1 0xa0 0D89 1B SHL 0D8A 03 SUB 0D8B 16 AND 0D8C 14 EQ 0D8D 15 ISZERO 0D8E 61 PUSH2 0x0d9b 0D91 57 *JUMPI 0D92 60 PUSH1 0x01 0D94 91 SWAP2 0D95 50 POP 0D96 50 POP 0D97 61 PUSH2 0x042b 0D9A 56 *JUMP 0D9B 5B JUMPDEST 0D9C 60 PUSH1 0x01 0D9E 60 PUSH1 0x01 0DA0 60 PUSH1 0xa0 0DA2 1B SHL 0DA3 03 SUB 0DA4 80 DUP1 0DA5 85 DUP6 0DA6 16 AND 0DA7 60 PUSH1 0x00 0DA9 90 SWAP1 0DAA 81 DUP2 0DAB 52 MSTORE 0DAC 60 PUSH1 0x05 0DAE 60 PUSH1 0x20 0DB0 90 SWAP1 0DB1 81 DUP2 0DB2 52 MSTORE 0DB3 60 PUSH1 0x40 0DB5 80 DUP1 0DB6 83 DUP4 0DB7 20 SHA3 0DB8 93 SWAP4 0DB9 87 DUP8 0DBA 16 AND 0DBB 83 DUP4 0DBC 52 MSTORE 0DBD 92 SWAP3 0DBE 90 SWAP1 0DBF 52 MSTORE 0DC0 20 SHA3 0DC1 54 SLOAD 0DC2 60 PUSH1 0xff 0DC4 16 AND label_0DC5: // Incoming return from call to 0x1904 at 0x19C0 // Incoming jump from 0x10A1, if stack[-1] // Incoming jump from 0x1594 // Inputs[3] // { // @0DC6 stack[-1] // @0DC6 stack[-6] // @0DC7 stack[-5] // } 0DC5 5B JUMPDEST 0DC6 94 SWAP5 0DC7 93 SWAP4 0DC8 50 POP 0DC9 50 POP 0DCA 50 POP 0DCB 50 POP 0DCC 56 *JUMP // Stack delta = -5 // Outputs[1] { @0DC6 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] 0DCD 5B JUMPDEST 0DCE 33 CALLER 0DCF 61 PUSH2 0x0dd6 0DD2 61 PUSH2 0x09f0 0DD5 56 *JUMP 0DD6 5B JUMPDEST 0DD7 60 PUSH1 0x01 0DD9 60 PUSH1 0x01 0DDB 60 PUSH1 0xa0 0DDD 1B SHL 0DDE 03 SUB 0DDF 16 AND 0DE0 14 EQ 0DE1 61 PUSH2 0x0dfc 0DE4 57 *JUMPI 0DE5 60 PUSH1 0x40 0DE7 51 MLOAD 0DE8 62 PUSH3 0x461bcd 0DEC 60 PUSH1 0xe5 0DEE 1B SHL 0DEF 81 DUP2 0DF0 52 MSTORE 0DF1 60 PUSH1 0x04 0DF3 01 ADD 0DF4 61 PUSH2 0x052b 0DF7 90 SWAP1 0DF8 61 PUSH2 0x1c8a 0DFB 56 *JUMP 0DFC 5B JUMPDEST 0DFD 60 PUSH1 0x00 0DFF 82 DUP3 0E00 81 DUP2 0E01 52 MSTORE 0E02 60 PUSH1 0x0a 0E04 60 PUSH1 0x20 0E06 90 SWAP1 0E07 81 DUP2 0E08 52 MSTORE 0E09 60 PUSH1 0x40 0E0B 90 SWAP1 0E0C 91 SWAP2 0E0D 20 SHA3 0E0E 82 DUP3 0E0F 51 MLOAD 0E10 61 PUSH2 0x065c 0E13 92 SWAP3 0E14 84 DUP5 0E15 01 ADD 0E16 90 SWAP1 0E17 61 PUSH2 0x16e6 0E1A 56 *JUMP label_0E1B: // Incoming jump from 0x03CA // Inputs[1] { @0E1C msg.sender } 0E1B 5B JUMPDEST 0E1C 33 CALLER 0E1D 61 PUSH2 0x0e24 0E20 61 PUSH2 0x09f0 0E23 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0E1C stack[0] = msg.sender // @0E1D stack[1] = 0x0e24 // } // Block ends with call to 0x09f0, returns to 0x0E24 label_0E24: // Incoming return from call to 0x09F0 at 0x0E23 // Inputs[2] // { // @0E2D stack[-1] // @0E2E stack[-2] // } 0E24 5B JUMPDEST 0E25 60 PUSH1 0x01 0E27 60 PUSH1 0x01 0E29 60 PUSH1 0xa0 0E2B 1B SHL 0E2C 03 SUB 0E2D 16 AND 0E2E 14 EQ 0E2F 61 PUSH2 0x0e4a 0E32 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0e4a, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_0E33: // Incoming jump from 0x0E32, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @0E35 memory[0x40:0x60] } 0E33 60 PUSH1 0x40 0E35 51 MLOAD 0E36 62 PUSH3 0x461bcd 0E3A 60 PUSH1 0xe5 0E3C 1B SHL 0E3D 81 DUP2 0E3E 52 MSTORE 0E3F 60 PUSH1 0x04 0E41 01 ADD 0E42 61 PUSH2 0x052b 0E45 90 SWAP1 0E46 61 PUSH2 0x1c8a 0E49 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E3E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E45 stack[0] = 0x052b // @0E45 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1c8a, returns to 0x052B label_0E4A: // Incoming jump from 0x0E32, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @0E4E storage[0x06] // @0E58 stack[-1] // @0E71 stack[-2] // } 0E4A 5B JUMPDEST 0E4B 60 PUSH1 0x06 0E4D 80 DUP1 0E4E 54 SLOAD 0E4F 60 PUSH1 0x01 0E51 60 PUSH1 0x01 0E53 60 PUSH1 0x60 0E55 1B SHL 0E56 03 SUB 0E57 90 SWAP1 0E58 92 SWAP3 0E59 16 AND 0E5A 60 PUSH1 0x01 0E5C 60 PUSH1 0xa0 0E5E 1B SHL 0E5F 02 MUL 0E60 60 PUSH1 0x01 0E62 60 PUSH1 0x01 0E64 60 PUSH1 0xa0 0E66 1B SHL 0E67 03 SUB 0E68 90 SWAP1 0E69 92 SWAP3 0E6A 16 AND 0E6B 91 SWAP2 0E6C 90 SWAP1 0E6D 91 SWAP2 0E6E 17 OR 0E6F 90 SWAP1 0E70 55 SSTORE 0E71 56 *JUMP // Stack delta = -2 // Outputs[1] { @0E70 storage[0x06] = (storage[0x06] & (0x01 << 0xa0) - 0x01) | (0x01 << 0xa0) * (stack[-1] & (0x01 << 0x60) - 0x01) } // Block ends with unconditional jump to stack[-2] 0E72 5B JUMPDEST 0E73 33 CALLER 0E74 61 PUSH2 0x0e7b 0E77 61 PUSH2 0x09f0 0E7A 56 *JUMP 0E7B 5B JUMPDEST 0E7C 60 PUSH1 0x01 0E7E 60 PUSH1 0x01 0E80 60 PUSH1 0xa0 0E82 1B SHL 0E83 03 SUB 0E84 16 AND 0E85 14 EQ 0E86 61 PUSH2 0x0ea1 0E89 57 *JUMPI 0E8A 60 PUSH1 0x40 0E8C 51 MLOAD 0E8D 62 PUSH3 0x461bcd 0E91 60 PUSH1 0xe5 0E93 1B SHL 0E94 81 DUP2 0E95 52 MSTORE 0E96 60 PUSH1 0x04 0E98 01 ADD 0E99 61 PUSH2 0x052b 0E9C 90 SWAP1 0E9D 61 PUSH2 0x1c8a 0EA0 56 *JUMP 0EA1 5B JUMPDEST 0EA2 60 PUSH1 0x01 0EA4 60 PUSH1 0x01 0EA6 60 PUSH1 0xa0 0EA8 1B SHL 0EA9 03 SUB 0EAA 81 DUP2 0EAB 16 AND 0EAC 61 PUSH2 0x0f06 0EAF 57 *JUMPI 0EB0 60 PUSH1 0x40 0EB2 51 MLOAD 0EB3 62 PUSH3 0x461bcd 0EB7 60 PUSH1 0xe5 0EB9 1B SHL 0EBA 81 DUP2 0EBB 52 MSTORE 0EBC 60 PUSH1 0x20 0EBE 60 PUSH1 0x04 0EC0 82 DUP3 0EC1 01 ADD 0EC2 52 MSTORE 0EC3 60 PUSH1 0x26 0EC5 60 PUSH1 0x24 0EC7 82 DUP3 0EC8 01 ADD 0EC9 52 MSTORE 0ECA 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 0EEB 60 PUSH1 0x44 0EED 82 DUP3 0EEE 01 ADD 0EEF 52 MSTORE 0EF0 65 PUSH6 0x646472657373 0EF7 60 PUSH1 0xd0 0EF9 1B SHL 0EFA 60 PUSH1 0x64 0EFC 82 DUP3 0EFD 01 ADD 0EFE 52 MSTORE 0EFF 60 PUSH1 0x84 0F01 01 ADD 0F02 61 PUSH2 0x052b 0F05 56 *JUMP 0F06 5B JUMPDEST 0F07 61 PUSH2 0x075f 0F0A 81 DUP2 0F0B 61 PUSH2 0x135a 0F0E 56 *JUMP 0F0F 5B JUMPDEST 0F10 60 PUSH1 0x00 0F12 60 PUSH1 0x01 0F14 60 PUSH1 0x01 0F16 60 PUSH1 0xe0 0F18 1B SHL 0F19 03 SUB 0F1A 19 NOT 0F1B 82 DUP3 0F1C 16 AND 0F1D 63 PUSH4 0x80ac58cd 0F22 60 PUSH1 0xe0 0F24 1B SHL 0F25 14 EQ 0F26 80 DUP1 0F27 61 PUSH2 0x0f40 0F2A 57 *JUMPI 0F2B 50 POP 0F2C 60 PUSH1 0x01 0F2E 60 PUSH1 0x01 0F30 60 PUSH1 0xe0 0F32 1B SHL 0F33 03 SUB 0F34 19 NOT 0F35 82 DUP3 0F36 16 AND 0F37 63 PUSH4 0x5b5e139f 0F3C 60 PUSH1 0xe0 0F3E 1B SHL 0F3F 14 EQ 0F40 5B JUMPDEST 0F41 80 DUP1 0F42 61 PUSH2 0x042b 0F45 57 *JUMPI 0F46 50 POP 0F47 63 PUSH4 0x01ffc9a7 0F4C 60 PUSH1 0xe0 0F4E 1B SHL 0F4F 60 PUSH1 0x01 0F51 60 PUSH1 0x01 0F53 60 PUSH1 0xe0 0F55 1B SHL 0F56 03 SUB 0F57 19 NOT 0F58 83 DUP4 0F59 16 AND 0F5A 14 EQ 0F5B 61 PUSH2 0x042b 0F5E 56 *JUMP label_0F5F: // Incoming call from 0x1298, returns to 0x1299 // Incoming call from 0x0B11, returns to 0x0B12 // Incoming call from 0x13E9, returns to 0x13EA // Incoming call from 0x04CD, returns to 0x04CE // Incoming call from 0x0FF4, returns to 0x0FF5 // Inputs[4] // { // @0F62 stack[-1] // @0F6D memory[0x00:0x40] // @0F6E storage[keccak256(memory[0x00:0x40])] // @0F7A stack[-2] // } 0F5F 5B JUMPDEST 0F60 60 PUSH1 0x00 0F62 90 SWAP1 0F63 81 DUP2 0F64 52 MSTORE 0F65 60 PUSH1 0x02 0F67 60 PUSH1 0x20 0F69 52 MSTORE 0F6A 60 PUSH1 0x40 0F6C 90 SWAP1 0F6D 20 SHA3 0F6E 54 SLOAD 0F6F 60 PUSH1 0x01 0F71 60 PUSH1 0x01 0F73 60 PUSH1 0xa0 0F75 1B SHL 0F76 03 SUB 0F77 16 AND 0F78 15 ISZERO 0F79 15 ISZERO 0F7A 90 SWAP1 0F7B 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0F64 memory[0x00:0x20] = stack[-1] // @0F69 memory[0x20:0x40] = 0x02 // @0F7A stack[-2] = !!((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-2] label_0F7C: // Incoming call from 0x065B, returns to 0x065C // Incoming call from 0x1193, returns to 0x1194 // Inputs[4] // { // @0F7F stack[-1] // @0F8A memory[0x00:0x40] // @0F8C storage[keccak256(memory[0x00:0x40])] // @0F9F stack[-2] // } 0F7C 5B JUMPDEST 0F7D 60 PUSH1 0x00 0F7F 81 DUP2 0F80 81 DUP2 0F81 52 MSTORE 0F82 60 PUSH1 0x04 0F84 60 PUSH1 0x20 0F86 52 MSTORE 0F87 60 PUSH1 0x40 0F89 90 SWAP1 0F8A 20 SHA3 0F8B 80 DUP1 0F8C 54 SLOAD 0F8D 60 PUSH1 0x01 0F8F 60 PUSH1 0x01 0F91 60 PUSH1 0xa0 0F93 1B SHL 0F94 03 SUB 0F95 19 NOT 0F96 16 AND 0F97 60 PUSH1 0x01 0F99 60 PUSH1 0x01 0F9B 60 PUSH1 0xa0 0F9D 1B SHL 0F9E 03 SUB 0F9F 84 DUP5 0FA0 16 AND 0FA1 90 SWAP1 0FA2 81 DUP2 0FA3 17 OR 0FA4 90 SWAP1 0FA5 91 SWAP2 0FA6 55 SSTORE 0FA7 81 DUP2 0FA8 90 SWAP1 0FA9 61 PUSH2 0x0fb1 0FAC 82 DUP3 0FAD 61 PUSH2 0x0817 0FB0 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @0F81 memory[0x00:0x20] = stack[-1] // @0F86 memory[0x20:0x40] = 0x04 // @0FA6 storage[keccak256(memory[0x00:0x40])] = (stack[-2] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @0FA8 stack[0] = stack[-1] // @0FA8 stack[1] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0FA9 stack[2] = 0x0fb1 // @0FAC stack[3] = stack[-1] // } // Block ends with call to 0x0817, returns to 0x0FB1 label_0FB1: // Incoming return from call to 0x0817 at 0x0FB0 // Inputs[7] // { // @0FBA stack[-1] // @0FDE memory[0x40:0x60] // @0FE1 memory[0x40:0x60] // @0FE6 stack[-2] // @0FE6 stack[-3] // @0FE6 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0FE9 stack[-6] // } 0FB1 5B JUMPDEST 0FB2 60 PUSH1 0x01 0FB4 60 PUSH1 0x01 0FB6 60 PUSH1 0xa0 0FB8 1B SHL 0FB9 03 SUB 0FBA 16 AND 0FBB 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0FDC 60 PUSH1 0x40 0FDE 51 MLOAD 0FDF 60 PUSH1 0x40 0FE1 51 MLOAD 0FE2 80 DUP1 0FE3 91 SWAP2 0FE4 03 SUB 0FE5 90 SWAP1 0FE6 A4 LOG4 0FE7 50 POP 0FE8 50 POP 0FE9 56 *JUMP // Stack delta = -6 // Outputs[1] { @0FE6 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-2], stack[-3]]); } // Block ends with unconditional jump to stack[-6] label_0FEA: // Incoming call from 0x0AD8, returns to 0x0AD9 // Incoming call from 0x066A, returns to 0x066B // Inputs[1] { @0FF0 stack[-1] } 0FEA 5B JUMPDEST 0FEB 60 PUSH1 0x00 0FED 61 PUSH2 0x0ff5 0FF0 82 DUP3 0FF1 61 PUSH2 0x0f5f 0FF4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FEB stack[0] = 0x00 // @0FED stack[1] = 0x0ff5 // @0FF0 stack[2] = stack[-1] // } // Block ends with call to 0x0f5f, returns to 0x0FF5 label_0FF5: // Incoming return from call to 0x0F5F at 0x0FF4 // Inputs[1] { @0FF9 stack[-1] } 0FF5 5B JUMPDEST 0FF6 61 PUSH2 0x1056 0FF9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1056, if stack[-1] label_0FFA: // Incoming jump from 0x0FF9, if not stack[-1] // Inputs[1] { @0FFC memory[0x40:0x60] } 0FFA 60 PUSH1 0x40 0FFC 51 MLOAD 0FFD 62 PUSH3 0x461bcd 1001 60 PUSH1 0xe5 1003 1B SHL 1004 81 DUP2 1005 52 MSTORE 1006 60 PUSH1 0x20 1008 60 PUSH1 0x04 100A 82 DUP3 100B 01 ADD 100C 52 MSTORE 100D 60 PUSH1 0x2c 100F 60 PUSH1 0x24 1011 82 DUP3 1012 01 ADD 1013 52 MSTORE 1014 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 1035 60 PUSH1 0x44 1037 82 DUP3 1038 01 ADD 1039 52 MSTORE 103A 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 1047 60 PUSH1 0xa1 1049 1B SHL 104A 60 PUSH1 0x64 104C 82 DUP3 104D 01 ADD 104E 52 MSTORE 104F 60 PUSH1 0x84 1051 01 ADD 1052 61 PUSH2 0x052b 1055 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1005 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @100C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1013 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @1039 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 // @104E memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @1051 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x052b label_1056: // Incoming jump from 0x0FF9, if stack[-1] // Inputs[1] { @105C stack[-2] } 1056 5B JUMPDEST 1057 60 PUSH1 0x00 1059 61 PUSH2 0x1061 105C 83 DUP4 105D 61 PUSH2 0x0817 1060 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1057 stack[0] = 0x00 // @1059 stack[1] = 0x1061 // @105C stack[2] = stack[-2] // } // Block ends with call to 0x0817, returns to 0x1061 label_1061: // Incoming return from call to 0x0817 at 0x1060 // Inputs[3] // { // @1062 stack[-1] // @1062 stack[-2] // @106E stack[-5] // } 1061 5B JUMPDEST 1062 90 SWAP1 1063 50 POP 1064 80 DUP1 1065 60 PUSH1 0x01 1067 60 PUSH1 0x01 1069 60 PUSH1 0xa0 106B 1B SHL 106C 03 SUB 106D 16 AND 106E 84 DUP5 106F 60 PUSH1 0x01 1071 60 PUSH1 0x01 1073 60 PUSH1 0xa0 1075 1B SHL 1076 03 SUB 1077 16 AND 1078 14 EQ 1079 80 DUP1 107A 61 PUSH2 0x109c 107D 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1062 stack[-2] = stack[-1] // @1078 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // } // Block ends with conditional jump to 0x109c, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] label_107E: // Incoming jump from 0x107D, if not (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[2] // { // @107F stack[-5] // @108C stack[-4] // } 107E 50 POP 107F 83 DUP4 1080 60 PUSH1 0x01 1082 60 PUSH1 0x01 1084 60 PUSH1 0xa0 1086 1B SHL 1087 03 SUB 1088 16 AND 1089 61 PUSH2 0x1091 108C 84 DUP5 108D 61 PUSH2 0x04c3 1090 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1088 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1089 stack[0] = 0x1091 // @108C stack[1] = stack[-4] // } // Block ends with call to 0x04c3, returns to 0x1091 label_1091: // Incoming return from call to 0x04C3 at 0x1090 // Inputs[2] // { // @109A stack[-1] // @109B stack[-2] // } 1091 5B JUMPDEST 1092 60 PUSH1 0x01 1094 60 PUSH1 0x01 1096 60 PUSH1 0xa0 1098 1B SHL 1099 03 SUB 109A 16 AND 109B 14 EQ // Stack delta = -1 // Outputs[1] { @109B stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_109C: // Incoming jump from 0x107D, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Incoming jump from 0x109B // Inputs[1] { @109D stack[-1] } 109C 5B JUMPDEST 109D 80 DUP1 109E 61 PUSH2 0x0dc5 10A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dc5, if stack[-1] label_10A2: // Incoming jump from 0x10A1, if not stack[-1] // Inputs[2] // { // @10A6 stack[-2] // @10A7 stack[-5] // } 10A2 50 POP 10A3 61 PUSH2 0x0dc5 10A6 81 DUP2 10A7 85 DUP6 10A8 61 PUSH2 0x0cf9 10AB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @10A3 stack[-1] = 0x0dc5 // @10A6 stack[0] = stack[-2] // @10A7 stack[1] = stack[-5] // } // Block ends with unconditional jump to 0x0cf9 label_10AC: // Incoming call from 0x13B6, returns to 0x13B7 // Incoming call from 0x0691, returns to 0x065C // Inputs[2] // { // @10AD stack[-3] // @10BA stack[-1] // } 10AC 5B JUMPDEST 10AD 82 DUP3 10AE 60 PUSH1 0x01 10B0 60 PUSH1 0x01 10B2 60 PUSH1 0xa0 10B4 1B SHL 10B5 03 SUB 10B6 16 AND 10B7 61 PUSH2 0x10bf 10BA 82 DUP3 10BB 61 PUSH2 0x0817 10BE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10B6 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-3] // @10B7 stack[1] = 0x10bf // @10BA stack[2] = stack[-1] // } // Block ends with call to 0x0817, returns to 0x10BF label_10BF: // Incoming return from call to 0x0817 at 0x10BE // Inputs[2] // { // @10C8 stack[-1] // @10C9 stack[-2] // } 10BF 5B JUMPDEST 10C0 60 PUSH1 0x01 10C2 60 PUSH1 0x01 10C4 60 PUSH1 0xa0 10C6 1B SHL 10C7 03 SUB 10C8 16 AND 10C9 14 EQ 10CA 61 PUSH2 0x1127 10CD 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1127, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_10CE: // Incoming jump from 0x10CD, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @10D0 memory[0x40:0x60] } 10CE 60 PUSH1 0x40 10D0 51 MLOAD 10D1 62 PUSH3 0x461bcd 10D5 60 PUSH1 0xe5 10D7 1B SHL 10D8 81 DUP2 10D9 52 MSTORE 10DA 60 PUSH1 0x20 10DC 60 PUSH1 0x04 10DE 82 DUP3 10DF 01 ADD 10E0 52 MSTORE 10E1 60 PUSH1 0x29 10E3 60 PUSH1 0x24 10E5 82 DUP3 10E6 01 ADD 10E7 52 MSTORE 10E8 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 1109 60 PUSH1 0x44 110B 82 DUP3 110C 01 ADD 110D 52 MSTORE 110E 68 PUSH9 0x39903737ba1037bbb7 1118 60 PUSH1 0xb9 111A 1B SHL 111B 60 PUSH1 0x64 111D 82 DUP3 111E 01 ADD 111F 52 MSTORE 1120 60 PUSH1 0x84 1122 01 ADD 1123 61 PUSH2 0x052b 1126 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @10D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10E0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10E7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @110D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 // @111F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x39903737ba1037bbb7 << 0xb9 // @1122 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x052b label_1127: // Incoming jump from 0x10CD, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1130 stack[-2] } 1127 5B JUMPDEST 1128 60 PUSH1 0x01 112A 60 PUSH1 0x01 112C 60 PUSH1 0xa0 112E 1B SHL 112F 03 SUB 1130 82 DUP3 1131 16 AND 1132 61 PUSH2 0x1189 1135 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1189, if stack[-2] & (0x01 << 0xa0) - 0x01 label_1136: // Incoming jump from 0x1135, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1138 memory[0x40:0x60] } 1136 60 PUSH1 0x40 1138 51 MLOAD 1139 62 PUSH3 0x461bcd 113D 60 PUSH1 0xe5 113F 1B SHL 1140 81 DUP2 1141 52 MSTORE 1142 60 PUSH1 0x20 1144 60 PUSH1 0x04 1146 82 DUP3 1147 01 ADD 1148 52 MSTORE 1149 60 PUSH1 0x24 114B 80 DUP1 114C 82 DUP3 114D 01 ADD 114E 52 MSTORE 114F 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 1170 60 PUSH1 0x44 1172 82 DUP3 1173 01 ADD 1174 52 MSTORE 1175 63 PUSH4 0x72657373 117A 60 PUSH1 0xe0 117C 1B SHL 117D 60 PUSH1 0x64 117F 82 DUP3 1180 01 ADD 1181 52 MSTORE 1182 60 PUSH1 0x84 1184 01 ADD 1185 61 PUSH2 0x052b 1188 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1141 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1148 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @114E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @1174 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 // @1181 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x72657373 << 0xe0 // @1184 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x052b label_1189: // Incoming jump from 0x1135, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @118F stack[-1] } 1189 5B JUMPDEST 118A 61 PUSH2 0x1194 118D 60 PUSH1 0x00 118F 82 DUP3 1190 61 PUSH2 0x0f7c 1193 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @118A stack[0] = 0x1194 // @118D stack[1] = 0x00 // @118F stack[2] = stack[-1] // } // Block ends with call to 0x0f7c, returns to 0x1194 label_1194: // Incoming return from call to 0x0F7C at 0x1193 // Inputs[3] // { // @119D stack[-3] // @11AC memory[0x00:0x40] // @11AE storage[keccak256(memory[0x00:0x40])] // } 1194 5B JUMPDEST 1195 60 PUSH1 0x01 1197 60 PUSH1 0x01 1199 60 PUSH1 0xa0 119B 1B SHL 119C 03 SUB 119D 83 DUP4 119E 16 AND 119F 60 PUSH1 0x00 11A1 90 SWAP1 11A2 81 DUP2 11A3 52 MSTORE 11A4 60 PUSH1 0x03 11A6 60 PUSH1 0x20 11A8 52 MSTORE 11A9 60 PUSH1 0x40 11AB 81 DUP2 11AC 20 SHA3 11AD 80 DUP1 11AE 54 SLOAD 11AF 60 PUSH1 0x01 11B1 92 SWAP3 11B2 90 SWAP1 11B3 61 PUSH2 0x11bd 11B6 90 SWAP1 11B7 84 DUP5 11B8 90 SWAP1 11B9 61 PUSH2 0x1d21 11BC 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @11A3 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @11A8 memory[0x20:0x40] = 0x03 // @11AC stack[1] = keccak256(memory[0x00:0x40]) // @11B1 stack[0] = 0x01 // @11B2 stack[2] = 0x00 // @11B6 stack[3] = 0x11bd // @11B8 stack[4] = 0x01 // @11B8 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1d21, returns to 0x11BD label_11BD: // Incoming return from call to 0x1D21 at 0x11BC // Inputs[6] // { // @11BE stack[-1] // @11BE stack[-2] // @11BF stack[-3] // @11CB stack[-6] // @11DA memory[0x00:0x40] // @11DC storage[keccak256(memory[0x00:0x40])] // } 11BD 5B JUMPDEST 11BE 90 SWAP1 11BF 91 SWAP2 11C0 55 SSTORE 11C1 50 POP 11C2 50 POP 11C3 60 PUSH1 0x01 11C5 60 PUSH1 0x01 11C7 60 PUSH1 0xa0 11C9 1B SHL 11CA 03 SUB 11CB 82 DUP3 11CC 16 AND 11CD 60 PUSH1 0x00 11CF 90 SWAP1 11D0 81 DUP2 11D1 52 MSTORE 11D2 60 PUSH1 0x03 11D4 60 PUSH1 0x20 11D6 52 MSTORE 11D7 60 PUSH1 0x40 11D9 81 DUP2 11DA 20 SHA3 11DB 80 DUP1 11DC 54 SLOAD 11DD 60 PUSH1 0x01 11DF 92 SWAP3 11E0 90 SWAP1 11E1 61 PUSH2 0x11eb 11E4 90 SWAP1 11E5 84 DUP5 11E6 90 SWAP1 11E7 61 PUSH2 0x1d38 11EA 56 *JUMP // Stack delta = +2 // Outputs[9] // { // @11C0 storage[stack[-3]] = stack[-1] // @11D1 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @11D6 memory[0x20:0x40] = 0x03 // @11DA stack[-3] = keccak256(memory[0x00:0x40]) // @11DF stack[-4] = 0x01 // @11E0 stack[-2] = 0x00 // @11E4 stack[-1] = 0x11eb // @11E6 stack[0] = 0x01 // @11E6 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1d38, returns to 0x11EB label_11EB: // Incoming return from call to 0x1D38 at 0x11EA // Inputs[13] // { // @11EC stack[-2] // @11EC stack[-1] // @11ED stack[-3] // @11F3 stack[-5] // @11FF memory[0x00:0x40] // @1201 storage[keccak256(memory[0x00:0x40])] // @1214 stack[-6] // @121E memory[0x40:0x60] // @1222 stack[-7] // @1228 memory[0x00:0x20] // @1231 memory[0x00:0x20] // @1235 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1239 stack[-8] // } 11EB 5B JUMPDEST 11EC 90 SWAP1 11ED 91 SWAP2 11EE 55 SSTORE 11EF 50 POP 11F0 50 POP 11F1 60 PUSH1 0x00 11F3 81 DUP2 11F4 81 DUP2 11F5 52 MSTORE 11F6 60 PUSH1 0x02 11F8 60 PUSH1 0x20 11FA 52 MSTORE 11FB 60 PUSH1 0x40 11FD 80 DUP1 11FE 82 DUP3 11FF 20 SHA3 1200 80 DUP1 1201 54 SLOAD 1202 60 PUSH1 0x01 1204 60 PUSH1 0x01 1206 60 PUSH1 0xa0 1208 1B SHL 1209 03 SUB 120A 19 NOT 120B 16 AND 120C 60 PUSH1 0x01 120E 60 PUSH1 0x01 1210 60 PUSH1 0xa0 1212 1B SHL 1213 03 SUB 1214 86 DUP7 1215 81 DUP2 1216 16 AND 1217 91 SWAP2 1218 82 DUP3 1219 17 OR 121A 90 SWAP1 121B 92 SWAP3 121C 55 SSTORE 121D 91 SWAP2 121E 51 MLOAD 121F 84 DUP5 1220 93 SWAP4 1221 91 SWAP2 1222 87 DUP8 1223 16 AND 1224 91 SWAP2 1225 60 PUSH1 0x00 1227 80 DUP1 1228 51 MLOAD 1229 60 PUSH1 0x20 122B 61 PUSH2 0x1e5b 122E 83 DUP4 122F 39 CODECOPY 1230 81 DUP2 1231 51 MLOAD 1232 91 SWAP2 1233 52 MSTORE 1234 91 SWAP2 1235 A4 LOG4 1236 50 POP 1237 50 POP 1238 50 POP 1239 56 *JUMP // Stack delta = -8 // Outputs[7] // { // @11EE storage[stack[-3]] = stack[-1] // @11F5 memory[0x00:0x20] = stack[-5] // @11FA memory[0x20:0x40] = 0x02 // @121C storage[keccak256(memory[0x00:0x40])] = (stack[-6] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @122F memory[0x00:0x20] = code[0x1e5b:0x1e7b] // @1233 memory[0x00:0x20] = memory[0x00:0x20] // @1235 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [memory[0x00:0x20], stack[-7] & (0x01 << 0xa0) - 0x01, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5]]); // } // Block ends with unconditional jump to stack[-8] label_123A: // Incoming call from 0x0714, returns to 0x0715 // Inputs[1] { @1243 stack[-2] } 123A 5B JUMPDEST 123B 60 PUSH1 0x01 123D 60 PUSH1 0x01 123F 60 PUSH1 0xa0 1241 1B SHL 1242 03 SUB 1243 82 DUP3 1244 16 AND 1245 61 PUSH2 0x1290 1248 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1290, if stack[-2] & (0x01 << 0xa0) - 0x01 label_1249: // Incoming jump from 0x1248, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @124B memory[0x40:0x60] } 1249 60 PUSH1 0x40 124B 51 MLOAD 124C 62 PUSH3 0x461bcd 1250 60 PUSH1 0xe5 1252 1B SHL 1253 81 DUP2 1254 52 MSTORE 1255 60 PUSH1 0x20 1257 60 PUSH1 0x04 1259 82 DUP3 125A 01 ADD 125B 81 DUP2 125C 90 SWAP1 125D 52 MSTORE 125E 60 PUSH1 0x24 1260 82 DUP3 1261 01 ADD 1262 52 MSTORE 1263 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 1284 60 PUSH1 0x44 1286 82 DUP3 1287 01 ADD 1288 52 MSTORE 1289 60 PUSH1 0x64 128B 01 ADD 128C 61 PUSH2 0x052b 128F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1254 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @125D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1262 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1288 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 // @128B stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x052b label_1290: // Incoming jump from 0x1248, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1294 stack[-1] } 1290 5B JUMPDEST 1291 61 PUSH2 0x1299 1294 81 DUP2 1295 61 PUSH2 0x0f5f 1298 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1291 stack[0] = 0x1299 // @1294 stack[1] = stack[-1] // } // Block ends with call to 0x0f5f, returns to 0x1299 label_1299: // Incoming return from call to 0x0F5F at 0x1298 // Inputs[1] { @129A stack[-1] } 1299 5B JUMPDEST 129A 15 ISZERO 129B 61 PUSH2 0x12e5 129E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x12e5, if !stack[-1] label_129F: // Incoming jump from 0x129E, if not !stack[-1] // Inputs[1] { @12A1 memory[0x40:0x60] } 129F 60 PUSH1 0x40 12A1 51 MLOAD 12A2 62 PUSH3 0x461bcd 12A6 60 PUSH1 0xe5 12A8 1B SHL 12A9 81 DUP2 12AA 52 MSTORE 12AB 60 PUSH1 0x20 12AD 60 PUSH1 0x04 12AF 82 DUP3 12B0 01 ADD 12B1 52 MSTORE 12B2 60 PUSH1 0x1c 12B4 60 PUSH1 0x24 12B6 82 DUP3 12B7 01 ADD 12B8 52 MSTORE 12B9 7B PUSH28 0x115490cdcc8c4e881d1bdad95b88185b1c9958591e481b5a5b9d1959 12D6 60 PUSH1 0x22 12D8 1B SHL 12D9 60 PUSH1 0x44 12DB 82 DUP3 12DC 01 ADD 12DD 52 MSTORE 12DE 60 PUSH1 0x64 12E0 01 ADD 12E1 61 PUSH2 0x052b 12E4 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @12AA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12B1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @12B8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1c // @12DD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x115490cdcc8c4e881d1bdad95b88185b1c9958591e481b5a5b9d1959 << 0x22 // @12E0 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x052b label_12E5: // Incoming jump from 0x129E, if !stack[-1] // Inputs[3] // { // @12EE stack[-2] // @12FD memory[0x00:0x40] // @12FF storage[keccak256(memory[0x00:0x40])] // } 12E5 5B JUMPDEST 12E6 60 PUSH1 0x01 12E8 60 PUSH1 0x01 12EA 60 PUSH1 0xa0 12EC 1B SHL 12ED 03 SUB 12EE 82 DUP3 12EF 16 AND 12F0 60 PUSH1 0x00 12F2 90 SWAP1 12F3 81 DUP2 12F4 52 MSTORE 12F5 60 PUSH1 0x03 12F7 60 PUSH1 0x20 12F9 52 MSTORE 12FA 60 PUSH1 0x40 12FC 81 DUP2 12FD 20 SHA3 12FE 80 DUP1 12FF 54 SLOAD 1300 60 PUSH1 0x01 1302 92 SWAP3 1303 90 SWAP1 1304 61 PUSH2 0x130e 1307 90 SWAP1 1308 84 DUP5 1309 90 SWAP1 130A 61 PUSH2 0x1d38 130D 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @12F4 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @12F9 memory[0x20:0x40] = 0x03 // @12FD stack[1] = keccak256(memory[0x00:0x40]) // @1302 stack[0] = 0x01 // @1303 stack[2] = 0x00 // @1307 stack[3] = 0x130e // @1309 stack[4] = 0x01 // @1309 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1d38, returns to 0x130E label_130E: // Incoming return from call to 0x1D38 at 0x130D // Inputs[12] // { // @130F stack[-1] // @130F stack[-2] // @1310 stack[-3] // @1316 stack[-5] // @1322 memory[0x00:0x40] // @1324 storage[keccak256(memory[0x00:0x40])] // @1337 stack[-6] // @1340 memory[0x40:0x60] // @1347 memory[0x00:0x20] // @1350 memory[0x00:0x20] // @1356 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1359 stack[-7] // } 130E 5B JUMPDEST 130F 90 SWAP1 1310 91 SWAP2 1311 55 SSTORE 1312 50 POP 1313 50 POP 1314 60 PUSH1 0x00 1316 81 DUP2 1317 81 DUP2 1318 52 MSTORE 1319 60 PUSH1 0x02 131B 60 PUSH1 0x20 131D 52 MSTORE 131E 60 PUSH1 0x40 1320 80 DUP1 1321 82 DUP3 1322 20 SHA3 1323 80 DUP1 1324 54 SLOAD 1325 60 PUSH1 0x01 1327 60 PUSH1 0x01 1329 60 PUSH1 0xa0 132B 1B SHL 132C 03 SUB 132D 19 NOT 132E 16 AND 132F 60 PUSH1 0x01 1331 60 PUSH1 0x01 1333 60 PUSH1 0xa0 1335 1B SHL 1336 03 SUB 1337 86 DUP7 1338 16 AND 1339 90 SWAP1 133A 81 DUP2 133B 17 OR 133C 90 SWAP1 133D 91 SWAP2 133E 55 SSTORE 133F 90 SWAP1 1340 51 MLOAD 1341 83 DUP4 1342 92 SWAP3 1343 90 SWAP1 1344 60 PUSH1 0x00 1346 80 DUP1 1347 51 MLOAD 1348 60 PUSH1 0x20 134A 61 PUSH2 0x1e5b 134D 83 DUP4 134E 39 CODECOPY 134F 81 DUP2 1350 51 MLOAD 1351 91 SWAP2 1352 52 MSTORE 1353 90 SWAP1 1354 82 DUP3 1355 90 SWAP1 1356 A4 LOG4 1357 50 POP 1358 50 POP 1359 56 *JUMP // Stack delta = -7 // Outputs[7] // { // @1311 storage[stack[-3]] = stack[-1] // @1318 memory[0x00:0x20] = stack[-5] // @131D memory[0x20:0x40] = 0x02 // @133E storage[keccak256(memory[0x00:0x40])] = (stack[-6] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @134E memory[0x00:0x20] = code[0x1e5b:0x1e7b] // @1352 memory[0x00:0x20] = memory[0x00:0x20] // @1356 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [memory[0x00:0x20], 0x00, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5]]); // } // Block ends with unconditional jump to stack[-7] label_135A: // Incoming call from 0x098F, returns to 0x0990 // Inputs[5] // { // @135E storage[0x06] // @1367 stack[-1] // @137C memory[0x40:0x60] // @13A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @13AB stack[-2] // } 135A 5B JUMPDEST 135B 60 PUSH1 0x06 135D 80 DUP1 135E 54 SLOAD 135F 60 PUSH1 0x01 1361 60 PUSH1 0x01 1363 60 PUSH1 0xa0 1365 1B SHL 1366 03 SUB 1367 83 DUP4 1368 81 DUP2 1369 16 AND 136A 60 PUSH1 0x01 136C 60 PUSH1 0x01 136E 60 PUSH1 0xa0 1370 1B SHL 1371 03 SUB 1372 19 NOT 1373 83 DUP4 1374 16 AND 1375 81 DUP2 1376 17 OR 1377 90 SWAP1 1378 93 SWAP4 1379 55 SSTORE 137A 60 PUSH1 0x40 137C 51 MLOAD 137D 91 SWAP2 137E 16 AND 137F 91 SWAP2 1380 90 SWAP1 1381 82 DUP3 1382 90 SWAP1 1383 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 13A4 90 SWAP1 13A5 60 PUSH1 0x00 13A7 90 SWAP1 13A8 A3 LOG3 13A9 50 POP 13AA 50 POP 13AB 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1379 storage[0x06] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x06] & ~((0x01 << 0xa0) - 0x01)) // @13A8 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x06] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_13AC: // Incoming call from 0x0B00, returns to 0x0B01 // Inputs[3] // { // @13B0 stack[-4] // @13B1 stack[-3] // @13B2 stack[-2] // } 13AC 5B JUMPDEST 13AD 61 PUSH2 0x13b7 13B0 84 DUP5 13B1 84 DUP5 13B2 84 DUP5 13B3 61 PUSH2 0x10ac 13B6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @13AD stack[0] = 0x13b7 // @13B0 stack[1] = stack[-4] // @13B1 stack[2] = stack[-3] // @13B2 stack[3] = stack[-2] // } // Block ends with call to 0x10ac, returns to 0x13B7 label_13B7: // Incoming return from call to 0x10AC at 0x13B6 // Inputs[4] // { // @13BB stack[-4] // @13BC stack[-3] // @13BD stack[-2] // @13BE stack[-1] // } 13B7 5B JUMPDEST 13B8 61 PUSH2 0x13c3 13BB 84 DUP5 13BC 84 DUP5 13BD 84 DUP5 13BE 84 DUP5 13BF 61 PUSH2 0x1493 13C2 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @13B8 stack[0] = 0x13c3 // @13BB stack[1] = stack[-4] // @13BC stack[2] = stack[-3] // @13BD stack[3] = stack[-2] // @13BE stack[4] = stack[-1] // } // Block ends with call to 0x1493, returns to 0x13C3 label_13C3: // Incoming return from call to 0x1493 at 0x13C2 // Inputs[1] { @13C7 stack[-1] } 13C3 5B JUMPDEST 13C4 61 PUSH2 0x0b01 13C7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b01, if stack[-1] label_13C8: // Incoming jump from 0x13C7, if not stack[-1] // Inputs[1] { @13CA memory[0x40:0x60] } 13C8 60 PUSH1 0x40 13CA 51 MLOAD 13CB 62 PUSH3 0x461bcd 13CF 60 PUSH1 0xe5 13D1 1B SHL 13D2 81 DUP2 13D3 52 MSTORE 13D4 60 PUSH1 0x04 13D6 01 ADD 13D7 61 PUSH2 0x052b 13DA 90 SWAP1 13DB 61 PUSH2 0x1d50 13DE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @13D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13DA stack[0] = 0x052b // @13DA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1d50, returns to 0x052B label_13DF: // Incoming jump from 0x0C24 // Inputs[1] { @13E5 stack[-1] } 13DF 5B JUMPDEST 13E0 60 PUSH1 0x60 13E2 61 PUSH2 0x13ea 13E5 82 DUP3 13E6 61 PUSH2 0x0f5f 13E9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @13E0 stack[0] = 0x60 // @13E2 stack[1] = 0x13ea // @13E5 stack[2] = stack[-1] // } // Block ends with call to 0x0f5f, returns to 0x13EA label_13EA: // Incoming return from call to 0x0F5F at 0x13E9 // Inputs[1] { @13EE stack[-1] } 13EA 5B JUMPDEST 13EB 61 PUSH2 0x144e 13EE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x144e, if stack[-1] label_13EF: // Incoming jump from 0x13EE, if not stack[-1] // Inputs[1] { @13F1 memory[0x40:0x60] } 13EF 60 PUSH1 0x40 13F1 51 MLOAD 13F2 62 PUSH3 0x461bcd 13F6 60 PUSH1 0xe5 13F8 1B SHL 13F9 81 DUP2 13FA 52 MSTORE 13FB 60 PUSH1 0x20 13FD 60 PUSH1 0x04 13FF 82 DUP3 1400 01 ADD 1401 52 MSTORE 1402 60 PUSH1 0x2f 1404 60 PUSH1 0x24 1406 82 DUP3 1407 01 ADD 1408 52 MSTORE 1409 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 142A 60 PUSH1 0x44 142C 82 DUP3 142D 01 ADD 142E 52 MSTORE 142F 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 143F 60 PUSH1 0x89 1441 1B SHL 1442 60 PUSH1 0x64 1444 82 DUP3 1445 01 ADD 1446 52 MSTORE 1447 60 PUSH1 0x84 1449 01 ADD 144A 61 PUSH2 0x052b 144D 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @13FA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1401 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1408 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @142E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @1446 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3732bc34b9ba32b73a103a37b5b2b7 << 0x89 // @1449 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x052b label_144E: // Incoming jump from 0x13EE, if stack[-1] 144E 5B JUMPDEST 144F 60 PUSH1 0x00 1451 61 PUSH2 0x1458 1454 61 PUSH2 0x15a0 1457 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @144F stack[0] = 0x00 // @1451 stack[1] = 0x1458 // } // Block ends with unconditional jump to 0x15a0 1458 5B JUMPDEST 1459 90 SWAP1 145A 50 POP 145B 60 PUSH1 0x00 145D 81 DUP2 145E 51 MLOAD 145F 11 GT 1460 61 PUSH2 0x1478 1463 57 *JUMPI 1464 60 PUSH1 0x40 1466 51 MLOAD 1467 80 DUP1 1468 60 PUSH1 0x20 146A 01 ADD 146B 60 PUSH1 0x40 146D 52 MSTORE 146E 80 DUP1 146F 60 PUSH1 0x00 1471 81 DUP2 1472 52 MSTORE 1473 50 POP 1474 61 PUSH2 0x0c25 1477 56 *JUMP 1478 5B JUMPDEST 1479 80 DUP1 147A 61 PUSH2 0x1482 147D 84 DUP5 147E 61 PUSH2 0x15af 1481 56 *JUMP 1482 5B JUMPDEST 1483 60 PUSH1 0x40 1485 51 MLOAD 1486 60 PUSH1 0x20 1488 01 ADD 1489 61 PUSH2 0x0c05 148C 92 SWAP3 148D 91 SWAP2 148E 90 SWAP1 148F 61 PUSH2 0x1da2 1492 56 *JUMP label_1493: // Incoming call from 0x13C2, returns to 0x13C3 // Inputs[2] // { // @149E stack[-3] // @14A0 address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 1493 5B JUMPDEST 1494 60 PUSH1 0x00 1496 60 PUSH1 0x01 1498 60 PUSH1 0x01 149A 60 PUSH1 0xa0 149C 1B SHL 149D 03 SUB 149E 84 DUP5 149F 16 AND 14A0 3B EXTCODESIZE 14A1 15 ISZERO 14A2 61 PUSH2 0x1595 14A5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1494 stack[0] = 0x00 } // Block ends with conditional jump to 0x1595, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_14A6: // Incoming jump from 0x14A5, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[6] // { // @14A8 memory[0x40:0x60] // @14BB stack[-4] // @14C8 msg.sender // @14CA stack[-5] // @14CC stack[-3] // @14CE stack[-2] // } 14A6 60 PUSH1 0x40 14A8 51 MLOAD 14A9 63 PUSH4 0x0a85bd01 14AE 60 PUSH1 0xe1 14B0 1B SHL 14B1 81 DUP2 14B2 52 MSTORE 14B3 60 PUSH1 0x01 14B5 60 PUSH1 0x01 14B7 60 PUSH1 0xa0 14B9 1B SHL 14BA 03 SUB 14BB 85 DUP6 14BC 16 AND 14BD 90 SWAP1 14BE 63 PUSH4 0x150b7a02 14C3 90 SWAP1 14C4 61 PUSH2 0x14d7 14C7 90 SWAP1 14C8 33 CALLER 14C9 90 SWAP1 14CA 89 DUP10 14CB 90 SWAP1 14CC 88 DUP9 14CD 90 SWAP1 14CE 88 DUP9 14CF 90 SWAP1 14D0 60 PUSH1 0x04 14D2 01 ADD 14D3 61 PUSH2 0x1dd1 14D6 56 *JUMP // Stack delta = +8 // Outputs[9] // { // @14B2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @14BD stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @14C3 stack[1] = 0x150b7a02 // @14C7 stack[2] = 0x14d7 // @14C9 stack[3] = msg.sender // @14CB stack[4] = stack[-5] // @14CD stack[5] = stack[-3] // @14CF stack[6] = stack[-2] // @14D2 stack[7] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1dd1, returns to 0x14D7 label_14D7: // Incoming return from call to 0x1DD1 at 0x14D6 // Inputs[4] // { // @14DC memory[0x40:0x60] // @14DE stack[-1] // @14E3 stack[-3] // @14E5 address(stack[-3]).code.length // } 14D7 5B JUMPDEST 14D8 60 PUSH1 0x20 14DA 60 PUSH1 0x40 14DC 51 MLOAD 14DD 80 DUP1 14DE 83 DUP4 14DF 03 SUB 14E0 81 DUP2 14E1 60 PUSH1 0x00 14E3 87 DUP8 14E4 80 DUP1 14E5 3B EXTCODESIZE 14E6 15 ISZERO 14E7 80 DUP1 14E8 15 ISZERO 14E9 61 PUSH2 0x14f1 14EC 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @14D8 stack[0] = 0x20 // @14DC stack[1] = memory[0x40:0x60] // @14DF stack[2] = stack[-1] - memory[0x40:0x60] // @14E0 stack[3] = memory[0x40:0x60] // @14E1 stack[4] = 0x00 // @14E3 stack[5] = stack[-3] // @14E6 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x14f1, if !!address(stack[-3]).code.length label_14ED: // Incoming jump from 0x14EC, if not !!address(stack[-3]).code.length // Inputs[1] { @14F0 memory[0x00:0x00] } 14ED 60 PUSH1 0x00 14EF 80 DUP1 14F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @14F0 revert(memory[0x00:0x00]); } // Block terminates label_14F1: // Incoming jump from 0x14EC, if !!address(stack[-3]).code.length // Inputs[10] // { // @14F3 msg.gas // @14F4 stack[-6] // @14F4 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @14F4 stack[-5] // @14F4 stack[-3] // @14F4 stack[-2] // @14F4 memory[stack[-4]:stack[-4] + stack[-5]] // @14F4 stack[-7] // @14F4 stack[-4] // @14F5 stack[-10] // } 14F1 5B JUMPDEST 14F2 50 POP 14F3 5A GAS 14F4 F1 CALL 14F5 92 SWAP3 14F6 50 POP 14F7 50 POP 14F8 50 POP 14F9 80 DUP1 14FA 15 ISZERO 14FB 61 PUSH2 0x1521 14FE 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @14F4 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @14F5 stack[-10] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1521, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_14FF: // Incoming jump from 0x14FE, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1503 memory[0x40:0x60] // @1506 returndata.length // } 14FF 50 POP 1500 60 PUSH1 0x40 1502 80 DUP1 1503 51 MLOAD 1504 60 PUSH1 0x1f 1506 3D RETURNDATASIZE 1507 90 SWAP1 1508 81 DUP2 1509 01 ADD 150A 60 PUSH1 0x1f 150C 19 NOT 150D 16 AND 150E 82 DUP3 150F 01 ADD 1510 90 SWAP1 1511 92 SWAP3 1512 52 MSTORE 1513 61 PUSH2 0x151e 1516 91 SWAP2 1517 81 DUP2 1518 01 ADD 1519 90 SWAP1 151A 61 PUSH2 0x1e0e 151D 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1512 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1516 stack[-1] = 0x151e // @1519 stack[1] = memory[0x40:0x60] // @1519 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x1e0e 151E 5B JUMPDEST 151F 60 PUSH1 0x01 label_1521: // Incoming jump from 0x14FE, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1525 stack[-1] } 1521 5B JUMPDEST 1522 61 PUSH2 0x157b 1525 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x157b, if stack[-1] label_1526: // Incoming jump from 0x1525, if not stack[-1] // Inputs[1] { @1526 returndata.length } 1526 3D RETURNDATASIZE 1527 80 DUP1 1528 80 DUP1 1529 15 ISZERO 152A 61 PUSH2 0x154f 152D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1526 stack[0] = returndata.length // @1527 stack[1] = returndata.length // } // Block ends with conditional jump to 0x154f, if !returndata.length label_152E: // Incoming jump from 0x152D, if not !returndata.length // Inputs[6] // { // @1530 memory[0x40:0x60] // @1531 stack[-2] // @1538 returndata.length // @1540 returndata.length // @1543 returndata.length // @154A returndata[0x00:0x00 + returndata.length] // } 152E 60 PUSH1 0x40 1530 51 MLOAD 1531 91 SWAP2 1532 50 POP 1533 60 PUSH1 0x1f 1535 19 NOT 1536 60 PUSH1 0x3f 1538 3D RETURNDATASIZE 1539 01 ADD 153A 16 AND 153B 82 DUP3 153C 01 ADD 153D 60 PUSH1 0x40 153F 52 MSTORE 1540 3D RETURNDATASIZE 1541 82 DUP3 1542 52 MSTORE 1543 3D RETURNDATASIZE 1544 60 PUSH1 0x00 1546 60 PUSH1 0x20 1548 84 DUP5 1549 01 ADD 154A 3E RETURNDATACOPY 154B 61 PUSH2 0x1554 154E 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1531 stack[-2] = memory[0x40:0x60] // @153F memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1542 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @154A memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1554 label_154F: // Incoming jump from 0x152D, if !returndata.length // Inputs[2] // { // @1552 stack[-2] // @1557 memory[0x60:0x80] // } 154F 5B JUMPDEST 1550 60 PUSH1 0x60 1552 91 SWAP2 1553 50 POP 1554 5B JUMPDEST 1555 50 POP 1556 80 DUP1 1557 51 MLOAD 1558 61 PUSH2 0x1573 155B 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1552 stack[-2] = 0x60 } // Block ends with conditional jump to 0x1573, if memory[0x60:0x80] label_155C: // Incoming jump from 0x155B, if not memory[0x60:0x80] // Incoming jump from 0x155B, if not memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @155E memory[0x40:0x60] } 155C 60 PUSH1 0x40 155E 51 MLOAD 155F 62 PUSH3 0x461bcd 1563 60 PUSH1 0xe5 1565 1B SHL 1566 81 DUP2 1567 52 MSTORE 1568 60 PUSH1 0x04 156A 01 ADD 156B 61 PUSH2 0x052b 156E 90 SWAP1 156F 61 PUSH2 0x1d50 1572 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1567 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @156E stack[0] = 0x052b // @156E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1d50, returns to 0x052B label_1573: // Incoming jump from 0x155B, if memory[0x60:0x80] // Incoming jump from 0x155B, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @1574 stack[-1] // @1575 memory[stack[-1]:stack[-1] + 0x20] // @157A memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 1573 5B JUMPDEST 1574 80 DUP1 1575 51 MLOAD 1576 81 DUP2 1577 60 PUSH1 0x20 1579 01 ADD 157A FD *REVERT // Stack delta = +0 // Outputs[1] { @157A revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_157B: // Incoming jump from 0x1525, if stack[-1] // Inputs[2] // { // @1585 stack[-1] // @158F stack[-2] // } 157B 5B JUMPDEST 157C 60 PUSH1 0x01 157E 60 PUSH1 0x01 1580 60 PUSH1 0xe0 1582 1B SHL 1583 03 SUB 1584 19 NOT 1585 16 AND 1586 63 PUSH4 0x0a85bd01 158B 60 PUSH1 0xe1 158D 1B SHL 158E 14 EQ 158F 90 SWAP1 1590 50 POP 1591 61 PUSH2 0x0dc5 1594 56 *JUMP // Stack delta = -1 // Outputs[1] { @158F stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block ends with unconditional jump to 0x0dc5 label_1595: // Incoming jump from 0x14A5, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[2] // { // @1599 stack[-6] // @159A stack[-5] // } 1595 5B JUMPDEST 1596 50 POP 1597 60 PUSH1 0x01 1599 94 SWAP5 159A 93 SWAP4 159B 50 POP 159C 50 POP 159D 50 POP 159E 50 POP 159F 56 *JUMP // Stack delta = -5 // Outputs[1] { @1599 stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_15A0: // Incoming jump from 0x1457 // Inputs[1] { @15A6 storage[0x09] } 15A0 5B JUMPDEST 15A1 60 PUSH1 0x60 15A3 60 PUSH1 0x09 15A5 80 DUP1 15A6 54 SLOAD 15A7 61 PUSH2 0x0440 15AA 90 SWAP1 15AB 61 PUSH2 0x1ba5 15AE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @15A1 stack[0] = 0x60 // @15A3 stack[1] = 0x09 // @15AA stack[2] = 0x0440 // @15AA stack[3] = storage[0x09] // } // Block ends with call to 0x1ba5, returns to 0x0440 15AF 5B JUMPDEST 15B0 60 PUSH1 0x60 15B2 81 DUP2 15B3 61 PUSH2 0x15d3 15B6 57 *JUMPI 15B7 50 POP 15B8 50 POP 15B9 60 PUSH1 0x40 15BB 80 DUP1 15BC 51 MLOAD 15BD 80 DUP1 15BE 82 DUP3 15BF 01 ADD 15C0 90 SWAP1 15C1 91 SWAP2 15C2 52 MSTORE 15C3 60 PUSH1 0x01 15C5 81 DUP2 15C6 52 MSTORE 15C7 60 PUSH1 0x03 15C9 60 PUSH1 0xfc 15CB 1B SHL 15CC 60 PUSH1 0x20 15CE 82 DUP3 15CF 01 ADD 15D0 52 MSTORE 15D1 90 SWAP1 15D2 56 *JUMP 15D3 5B JUMPDEST 15D4 81 DUP2 15D5 60 PUSH1 0x00 15D7 5B JUMPDEST 15D8 81 DUP2 15D9 15 ISZERO 15DA 61 PUSH2 0x15fd 15DD 57 *JUMPI 15DE 80 DUP1 15DF 61 PUSH2 0x15e7 15E2 81 DUP2 15E3 61 PUSH2 0x1e2b 15E6 56 *JUMP 15E7 5B JUMPDEST 15E8 91 SWAP2 15E9 50 POP 15EA 61 PUSH2 0x15f6 15ED 90 SWAP1 15EE 50 POP 15EF 60 PUSH1 0x0a 15F1 83 DUP4 15F2 61 PUSH2 0x1c76 15F5 56 *JUMP 15F6 5B JUMPDEST 15F7 91 SWAP2 15F8 50 POP 15F9 61 PUSH2 0x15d7 15FC 56 *JUMP 15FD 5B JUMPDEST 15FE 60 PUSH1 0x00 1600 81 DUP2 1601 60 PUSH1 0x01 1603 60 PUSH1 0x01 1605 60 PUSH1 0x40 1607 1B SHL 1608 03 SUB 1609 81 DUP2 160A 11 GT 160B 15 ISZERO 160C 61 PUSH2 0x1617 160F 57 *JUMPI 1610 61 PUSH2 0x1617 1613 61 PUSH2 0x18ee 1616 56 *JUMP 1617 5B JUMPDEST 1618 60 PUSH1 0x40 161A 51 MLOAD 161B 90 SWAP1 161C 80 DUP1 161D 82 DUP3 161E 52 MSTORE 161F 80 DUP1 1620 60 PUSH1 0x1f 1622 01 ADD 1623 60 PUSH1 0x1f 1625 19 NOT 1626 16 AND 1627 60 PUSH1 0x20 1629 01 ADD 162A 82 DUP3 162B 01 ADD 162C 60 PUSH1 0x40 162E 52 MSTORE 162F 80 DUP1 1630 15 ISZERO 1631 61 PUSH2 0x1641 1634 57 *JUMPI 1635 60 PUSH1 0x20 1637 82 DUP3 1638 01 ADD 1639 81 DUP2 163A 80 DUP1 163B 36 CALLDATASIZE 163C 83 DUP4 163D 37 CALLDATACOPY 163E 01 ADD 163F 90 SWAP1 1640 50 POP 1641 5B JUMPDEST 1642 50 POP 1643 90 SWAP1 1644 50 POP 1645 5B JUMPDEST 1646 84 DUP5 1647 15 ISZERO 1648 61 PUSH2 0x0dc5 164B 57 *JUMPI 164C 61 PUSH2 0x1656 164F 60 PUSH1 0x01 1651 83 DUP4 1652 61 PUSH2 0x1d21 1655 56 *JUMP 1656 5B JUMPDEST 1657 91 SWAP2 1658 50 POP 1659 61 PUSH2 0x1663 165C 60 PUSH1 0x0a 165E 86 DUP7 165F 61 PUSH2 0x1e46 1662 56 *JUMP 1663 5B JUMPDEST 1664 61 PUSH2 0x166e 1667 90 SWAP1 1668 60 PUSH1 0x30 166A 61 PUSH2 0x1d38 166D 56 *JUMP 166E 5B JUMPDEST 166F 60 PUSH1 0xf8 1671 1B SHL 1672 81 DUP2 1673 83 DUP4 1674 81 DUP2 1675 51 MLOAD 1676 81 DUP2 1677 10 LT 1678 61 PUSH2 0x1683 167B 57 *JUMPI 167C 61 PUSH2 0x1683 167F 61 PUSH2 0x1cee 1682 56 *JUMP 1683 5B JUMPDEST 1684 60 PUSH1 0x20 1686 01 ADD 1687 01 ADD 1688 90 SWAP1 1689 60 PUSH1 0x01 168B 60 PUSH1 0x01 168D 60 PUSH1 0xf8 168F 1B SHL 1690 03 SUB 1691 19 NOT 1692 16 AND 1693 90 SWAP1 1694 81 DUP2 1695 60 PUSH1 0x00 1697 1A BYTE 1698 90 SWAP1 1699 53 MSTORE8 169A 50 POP 169B 61 PUSH2 0x16a5 169E 60 PUSH1 0x0a 16A0 86 DUP7 16A1 61 PUSH2 0x1c76 16A4 56 *JUMP 16A5 5B JUMPDEST 16A6 94 SWAP5 16A7 50 POP 16A8 61 PUSH2 0x1645 16AB 56 *JUMP label_16AC: // Incoming call from 0x075E, returns to 0x075F // Inputs[2] // { // @16AE stack[-2] // @16AF storage[stack[-2]] // } 16AC 5B JUMPDEST 16AD 50 POP 16AE 80 DUP1 16AF 54 SLOAD 16B0 61 PUSH2 0x16b8 16B3 90 SWAP1 16B4 61 PUSH2 0x1ba5 16B7 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @16B3 stack[0] = storage[stack[-2]] // @16B3 stack[-1] = 0x16b8 // } // Block ends with call to 0x1ba5, returns to 0x16B8 label_16B8: // Incoming return from call to 0x1BA5 at 0x16B7 // Inputs[2] // { // @16BB stack[-2] // @16BD stack[-1] // } 16B8 5B JUMPDEST 16B9 60 PUSH1 0x00 16BB 82 DUP3 16BC 55 SSTORE 16BD 80 DUP1 16BE 60 PUSH1 0x1f 16C0 10 LT 16C1 61 PUSH2 0x16c8 16C4 57 *JUMPI // Stack delta = +0 // Outputs[1] { @16BC storage[stack[-2]] = 0x00 } // Block ends with conditional jump to 0x16c8, if 0x1f < stack[-1] label_16C5: // Incoming jump from 0x16C4, if not 0x1f < stack[-1] // Inputs[1] { @16C7 stack[-3] } 16C5 50 POP 16C6 50 POP 16C7 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_16C8: // Incoming jump from 0x16C4, if 0x1f < stack[-1] // Inputs[3] // { // @16CB stack[-1] // @16D0 stack[-2] // @16D8 memory[0x00:0x20] // } 16C8 5B JUMPDEST 16C9 60 PUSH1 0x1f 16CB 01 ADD 16CC 60 PUSH1 0x20 16CE 90 SWAP1 16CF 04 DIV 16D0 90 SWAP1 16D1 60 PUSH1 0x00 16D3 52 MSTORE 16D4 60 PUSH1 0x20 16D6 60 PUSH1 0x00 16D8 20 SHA3 16D9 90 SWAP1 16DA 81 DUP2 16DB 01 ADD 16DC 90 SWAP1 16DD 61 PUSH2 0x075f 16E0 91 SWAP2 16E1 90 SWAP1 16E2 61 PUSH2 0x176a 16E5 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @16D3 memory[0x00:0x20] = stack[-2] // @16E0 stack[-2] = 0x075f // @16E1 stack[-1] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // @16E1 stack[0] = keccak256(memory[0x00:0x20]) // } // Block ends with call to 0x176a, returns to 0x075F label_16E6: // Incoming jump from 0x08CF // Inputs[2] // { // @16E7 stack[-3] // @16E9 storage[stack[-3]] // } 16E6 5B JUMPDEST 16E7 82 DUP3 16E8 80 DUP1 16E9 54 SLOAD 16EA 61 PUSH2 0x16f2 16ED 90 SWAP1 16EE 61 PUSH2 0x1ba5 16F1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @16E7 stack[0] = stack[-3] // @16ED stack[1] = 0x16f2 // @16ED stack[2] = storage[stack[-3]] // } // Block ends with call to 0x1ba5, returns to 0x16F2 label_16F2: // Incoming return from call to 0x1BA5 at 0x16F1 // Inputs[5] // { // @16F3 stack[-1] // @16F3 stack[-2] // @16FB memory[0x00:0x20] // @1706 stack[-4] // @1707 stack[-3] // } 16F2 5B JUMPDEST 16F3 90 SWAP1 16F4 60 PUSH1 0x00 16F6 52 MSTORE 16F7 60 PUSH1 0x20 16F9 60 PUSH1 0x00 16FB 20 SHA3 16FC 90 SWAP1 16FD 60 PUSH1 0x1f 16FF 01 ADD 1700 60 PUSH1 0x20 1702 90 SWAP1 1703 04 DIV 1704 81 DUP2 1705 01 ADD 1706 92 SWAP3 1707 82 DUP3 1708 61 PUSH2 0x1714 170B 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @16F6 memory[0x00:0x20] = stack[-2] // @16FC stack[-2] = keccak256(memory[0x00:0x20]) // @1706 stack[-1] = stack[-4] // @1706 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x1714, if stack[-3] label_170C: // Incoming jump from 0x170B, if not stack[-3] // Inputs[1] { @170E stack[-5] } 170C 60 PUSH1 0x00 170E 85 DUP6 170F 55 SSTORE 1710 61 PUSH2 0x175a 1713 56 *JUMP // Stack delta = +0 // Outputs[1] { @170F storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x175a label_1714: // Incoming jump from 0x170B, if stack[-3] // Inputs[1] { @1715 stack[-3] } 1714 5B JUMPDEST 1715 82 DUP3 1716 60 PUSH1 0x1f 1718 10 LT 1719 61 PUSH2 0x172d 171C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x172d, if 0x1f < stack[-3] label_171D: // Incoming jump from 0x171C, if not 0x1f < stack[-3] // Inputs[4] // { // @171D stack[-1] // @171E memory[stack[-1]:stack[-1] + 0x20] // @1723 stack[-3] // @1727 stack[-5] // } 171D 80 DUP1 171E 51 MLOAD 171F 60 PUSH1 0xff 1721 19 NOT 1722 16 AND 1723 83 DUP4 1724 80 DUP1 1725 01 ADD 1726 17 OR 1727 85 DUP6 1728 55 SSTORE 1729 61 PUSH2 0x175a 172C 56 *JUMP // Stack delta = +0 // Outputs[1] { @1728 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x175a label_172D: // Incoming jump from 0x171C, if 0x1f < stack[-3] // Inputs[2] // { // @172E stack[-3] // @1734 stack[-5] // } 172D 5B JUMPDEST 172E 82 DUP3 172F 80 DUP1 1730 01 ADD 1731 60 PUSH1 0x01 1733 01 ADD 1734 85 DUP6 1735 55 SSTORE 1736 82 DUP3 1737 15 ISZERO 1738 61 PUSH2 0x175a 173B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1735 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x175a, if !stack[-3] label_173C: // Incoming jump from 0x173B, if not !stack[-3] // Inputs[2] // { // @173C stack[-1] // @173C stack[-3] // } 173C 91 SWAP2 173D 82 DUP3 173E 01 ADD 173F 5B JUMPDEST 1740 82 DUP3 1741 81 DUP2 1742 11 GT 1743 15 ISZERO 1744 61 PUSH2 0x175a 1747 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @173C stack[-3] = stack[-1] // @173E stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x175a, if !(stack[-1] + stack[-3] > stack[-1]) label_1748: // Incoming jump from 0x1747, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x1747, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @1748 stack[-3] // @1749 memory[stack[-3]:stack[-3] + 0x20] // @174A stack[-2] // @174C stack[-1] // } 1748 82 DUP3 1749 51 MLOAD 174A 82 DUP3 174B 55 SSTORE 174C 91 SWAP2 174D 60 PUSH1 0x20 174F 01 ADD 1750 91 SWAP2 1751 90 SWAP1 1752 60 PUSH1 0x01 1754 01 ADD 1755 90 SWAP1 1756 61 PUSH2 0x173f 1759 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @174B storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1750 stack[-3] = 0x20 + stack[-3] // @1755 stack[-2] = 0x01 + stack[-2] // @1755 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x173f label_175A: // Incoming jump from 0x173B, if !stack[-3] // Incoming jump from 0x1747, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1747, if !(stack[-1] > stack[-3]) // Incoming jump from 0x172C // Incoming jump from 0x1713 // Inputs[2] // { // @175F stack[-4] // @1760 stack[-3] // } 175A 5B JUMPDEST 175B 50 POP 175C 61 PUSH2 0x1766 175F 92 SWAP3 1760 91 SWAP2 1761 50 POP 1762 61 PUSH2 0x176a 1765 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @175F stack[-4] = 0x1766 // @1760 stack[-3] = stack[-4] // } // Block ends with call to 0x176a, returns to 0x1766 label_1766: // Incoming return from call to 0x176A at 0x1765 // Incoming jump from 0x1773, if !(stack[-2] > stack[-1]) // Incoming jump from 0x1773, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @1768 stack[-2] // @1768 stack[-3] // } 1766 5B JUMPDEST 1767 50 POP 1768 90 SWAP1 1769 56 *JUMP // Stack delta = -2 // Outputs[1] { @1768 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_176A: // Incoming call from 0x1765, returns to 0x1766 // Incoming call from 0x16E5, returns to 0x075F // Inputs[2] // { // @176C stack[-1] // @176D stack[-2] // } 176A 5B JUMPDEST 176B 5B JUMPDEST 176C 80 DUP1 176D 82 DUP3 176E 11 GT 176F 15 ISZERO 1770 61 PUSH2 0x1766 1773 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1766, if !(stack[-2] > stack[-1]) label_1774: // Incoming jump from 0x1773, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1773, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1776 stack[-1] } 1774 60 PUSH1 0x00 1776 81 DUP2 1777 55 SSTORE 1778 60 PUSH1 0x01 177A 01 ADD 177B 61 PUSH2 0x176b 177E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1777 storage[stack[-1]] = 0x00 // @177A stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x176b label_177F: // Incoming call from 0x17B1, returns to 0x0C25 // Incoming call from 0x1E2A, returns to 0x0C25 // Inputs[1] { @1789 stack[-1] } 177F 5B JUMPDEST 1780 60 PUSH1 0x01 1782 60 PUSH1 0x01 1784 60 PUSH1 0xe0 1786 1B SHL 1787 03 SUB 1788 19 NOT 1789 81 DUP2 178A 16 AND 178B 81 DUP2 178C 14 EQ 178D 61 PUSH2 0x075f 1790 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x075f, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1791: // Incoming jump from 0x1790, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1794 memory[0x00:0x00] } 1791 60 PUSH1 0x00 1793 80 DUP1 1794 FD *REVERT // Stack delta = +0 // Outputs[1] { @1794 revert(memory[0x00:0x00]); } // Block terminates label_1795: // Incoming jump from 0x0171 // Inputs[2] // { // @179A stack[-1] // @179B stack[-2] // } 1795 5B JUMPDEST 1796 60 PUSH1 0x00 1798 60 PUSH1 0x20 179A 82 DUP3 179B 84 DUP5 179C 03 SUB 179D 12 SLT 179E 15 ISZERO 179F 61 PUSH2 0x17a7 17A2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1796 stack[0] = 0x00 } // Block ends with conditional jump to 0x17a7, if !(stack[-2] - stack[-1] i< 0x20) label_17A3: // Incoming jump from 0x17A2, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @17A6 memory[0x00:0x00] } 17A3 60 PUSH1 0x00 17A5 80 DUP1 17A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @17A6 revert(memory[0x00:0x00]); } // Block terminates label_17A7: // Incoming jump from 0x17A2, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @17A8 stack[-2] // @17A9 msg.data[stack[-2]:stack[-2] + 0x20] // } 17A7 5B JUMPDEST 17A8 81 DUP2 17A9 35 CALLDATALOAD 17AA 61 PUSH2 0x0c25 17AD 81 DUP2 17AE 61 PUSH2 0x177f 17B1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @17A9 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @17AA stack[1] = 0x0c25 // @17AD stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x177f, returns to 0x0C25 label_17B2: // Incoming call from 0x17F5, returns to 0x17F6 // Incoming call from 0x1CE0, returns to 0x1CE1 // Inputs[1] { @17B6 stack[-3] } 17B2 5B JUMPDEST 17B3 60 PUSH1 0x00 17B5 5B JUMPDEST 17B6 83 DUP4 17B7 81 DUP2 17B8 10 LT 17B9 15 ISZERO 17BA 61 PUSH2 0x17cd 17BD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @17B3 stack[0] = 0x00 } // Block ends with conditional jump to 0x17cd, if !(0x00 < stack[-3]) label_17BE: // Incoming jump from 0x17BD, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x17BD, if not !(0x00 < stack[-3]) // Inputs[4] // { // @17BE stack[-2] // @17BF stack[-1] // @17C1 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @17C2 stack[-3] // } 17BE 81 DUP2 17BF 81 DUP2 17C0 01 ADD 17C1 51 MLOAD 17C2 83 DUP4 17C3 82 DUP3 17C4 01 ADD 17C5 52 MSTORE 17C6 60 PUSH1 0x20 17C8 01 ADD 17C9 61 PUSH2 0x17b5 17CC 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @17C5 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @17C8 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x17b5 label_17CD: // Incoming jump from 0x17BD, if !(stack[-1] < stack[-4]) // Incoming jump from 0x17BD, if !(0x00 < stack[-3]) // Inputs[2] // { // @17CE stack[-4] // @17CF stack[-1] // } 17CD 5B JUMPDEST 17CE 83 DUP4 17CF 81 DUP2 17D0 11 GT 17D1 15 ISZERO 17D2 61 PUSH2 0x0b01 17D5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b01, if !(stack[-1] > stack[-4]) label_17D6: // Incoming jump from 0x17D5, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @17DA stack[-4] // @17DB stack[-3] // @17DD stack[-5] // } 17D6 50 POP 17D7 50 POP 17D8 60 PUSH1 0x00 17DA 91 SWAP2 17DB 01 ADD 17DC 52 MSTORE 17DD 56 *JUMP // Stack delta = -5 // Outputs[1] { @17DC memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_17DE: // Incoming call from 0x181C, returns to 0x0C25 // Incoming call from 0x1E03, returns to 0x1E04 // Inputs[3] // { // @17E1 stack[-1] // @17E2 memory[stack[-1]:stack[-1] + 0x20] // @17E4 stack[-2] // } 17DE 5B JUMPDEST 17DF 60 PUSH1 0x00 17E1 81 DUP2 17E2 51 MLOAD 17E3 80 DUP1 17E4 84 DUP5 17E5 52 MSTORE 17E6 61 PUSH2 0x17f6 17E9 81 DUP2 17EA 60 PUSH1 0x20 17EC 86 DUP7 17ED 01 ADD 17EE 60 PUSH1 0x20 17F0 86 DUP7 17F1 01 ADD 17F2 61 PUSH2 0x17b2 17F5 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @17DF stack[0] = 0x00 // @17E2 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @17E5 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @17E6 stack[2] = 0x17f6 // @17E9 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @17ED stack[4] = stack[-2] + 0x20 // @17F1 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x17b2, returns to 0x17F6 label_17F6: // Incoming return from call to 0x17B2 at 0x17F5 // Inputs[4] // { // @17F9 stack[-1] // @17FE stack[-4] // @17FF stack[-2] // @1805 stack[-5] // } 17F6 5B JUMPDEST 17F7 60 PUSH1 0x1f 17F9 01 ADD 17FA 60 PUSH1 0x1f 17FC 19 NOT 17FD 16 AND 17FE 92 SWAP3 17FF 90 SWAP1 1800 92 SWAP3 1801 01 ADD 1802 60 PUSH1 0x20 1804 01 ADD 1805 92 SWAP3 1806 91 SWAP2 1807 50 POP 1808 50 POP 1809 56 *JUMP // Stack delta = -4 // Outputs[1] { @1805 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_180A: // Incoming jump from 0x01A0 // Inputs[2] // { // @180D stack[-1] // @1818 stack[-2] // } 180A 5B JUMPDEST 180B 60 PUSH1 0x20 180D 81 DUP2 180E 52 MSTORE 180F 60 PUSH1 0x00 1811 61 PUSH2 0x0c25 1814 60 PUSH1 0x20 1816 83 DUP4 1817 01 ADD 1818 84 DUP5 1819 61 PUSH2 0x17de 181C 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @180E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @180F stack[0] = 0x00 // @1811 stack[1] = 0x0c25 // @1817 stack[2] = stack[-1] + 0x20 // @1818 stack[3] = stack[-2] // } // Block ends with call to 0x17de, returns to 0x0C25 label_181D: // Incoming call from 0x01AE, returns to 0x01AF // Incoming call from 0x0359, returns to 0x035A // Incoming call from 0x023B, returns to 0x023C // Incoming call from 0x0346, returns to 0x0347 // Incoming call from 0x0261, returns to 0x0262 // Incoming call from 0x0274, returns to 0x0275 // Inputs[2] // { // @1822 stack[-1] // @1823 stack[-2] // } 181D 5B JUMPDEST 181E 60 PUSH1 0x00 1820 60 PUSH1 0x20 1822 82 DUP3 1823 84 DUP5 1824 03 SUB 1825 12 SLT 1826 15 ISZERO 1827 61 PUSH2 0x182f 182A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @181E stack[0] = 0x00 } // Block ends with conditional jump to 0x182f, if !(stack[-2] - stack[-1] i< 0x20) label_182B: // Incoming jump from 0x182A, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @182E memory[0x00:0x00] } 182B 60 PUSH1 0x00 182D 80 DUP1 182E FD *REVERT // Stack delta = +0 // Outputs[1] { @182E revert(memory[0x00:0x00]); } // Block terminates label_182F: // Incoming jump from 0x182A, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1831 msg.data[stack[-2]:stack[-2] + 0x20] // @1831 stack[-2] // @1832 stack[-4] // @1833 stack[-3] // } 182F 5B JUMPDEST 1830 50 POP 1831 35 CALLDATALOAD 1832 91 SWAP2 1833 90 SWAP1 1834 50 POP 1835 56 *JUMP // Stack delta = -3 // Outputs[1] { @1832 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1836: // Incoming call from 0x0D31, returns to 0x0D32 // Incoming call from 0x01C0, returns to 0x0183 // Inputs[3] // { // @183F stack[-2] // @1840 stack[-1] // @1848 stack[-3] // } 1836 5B JUMPDEST 1837 60 PUSH1 0x01 1839 60 PUSH1 0x01 183B 60 PUSH1 0xa0 183D 1B SHL 183E 03 SUB 183F 91 SWAP2 1840 90 SWAP1 1841 91 SWAP2 1842 16 AND 1843 81 DUP2 1844 52 MSTORE 1845 60 PUSH1 0x20 1847 01 ADD 1848 90 SWAP1 1849 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1844 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1848 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_184A: // Incoming call from 0x187C, returns to 0x187D // Incoming call from 0x1B25, returns to 0x1B26 // Incoming call from 0x1D20, returns to 0x0C25 // Incoming call from 0x19FB, returns to 0x19FC // Incoming call from 0x19DD, returns to 0x0C25 // Incoming call from 0x18AA, returns to 0x18AB // Incoming call from 0x1A6C, returns to 0x1A6D // Incoming call from 0x1B35, returns to 0x1A11 // Incoming call from 0x18BA, returns to 0x18BB // Incoming call from 0x1A5C, returns to 0x1A5D // Inputs[1] { @1853 stack[-1] } 184A 5B JUMPDEST 184B 60 PUSH1 0x01 184D 60 PUSH1 0x01 184F 60 PUSH1 0xa0 1851 1B SHL 1852 03 SUB 1853 81 DUP2 1854 16 AND 1855 81 DUP2 1856 14 EQ 1857 61 PUSH2 0x075f 185A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x075f, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 label_185B: // Incoming jump from 0x185A, if not stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @185E memory[0x00:0x00] } 185B 60 PUSH1 0x00 185D 80 DUP1 185E FD *REVERT // Stack delta = +0 // Outputs[1] { @185E revert(memory[0x00:0x00]); } // Block terminates label_185F: // Incoming call from 0x01CE, returns to 0x01CF // Incoming call from 0x0228, returns to 0x0229 // Inputs[2] // { // @1865 stack[-1] // @1866 stack[-2] // } 185F 5B JUMPDEST 1860 60 PUSH1 0x00 1862 80 DUP1 1863 60 PUSH1 0x40 1865 83 DUP4 1866 85 DUP6 1867 03 SUB 1868 12 SLT 1869 15 ISZERO 186A 61 PUSH2 0x1872 186D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1860 stack[0] = 0x00 // @1862 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1872, if !(stack[-2] - stack[-1] i< 0x40) label_186E: // Incoming jump from 0x186D, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1871 memory[0x00:0x00] } 186E 60 PUSH1 0x00 1870 80 DUP1 1871 FD *REVERT // Stack delta = +0 // Outputs[1] { @1871 revert(memory[0x00:0x00]); } // Block terminates label_1872: // Incoming jump from 0x186D, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1873 stack[-3] // @1874 msg.data[stack[-3]:stack[-3] + 0x20] // } 1872 5B JUMPDEST 1873 82 DUP3 1874 35 CALLDATALOAD 1875 61 PUSH2 0x187d 1878 81 DUP2 1879 61 PUSH2 0x184a 187C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1874 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1875 stack[1] = 0x187d // @1878 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x184a, returns to 0x187D label_187D: // Incoming return from call to 0x184A at 0x187C // Inputs[5] // { // @187E stack[-1] // @187E stack[-6] // @1881 stack[-4] // @1885 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1886 stack[-5] // } 187D 5B JUMPDEST 187E 94 SWAP5 187F 60 PUSH1 0x20 1881 93 SWAP4 1882 90 SWAP1 1883 93 SWAP4 1884 01 ADD 1885 35 CALLDATALOAD 1886 93 SWAP4 1887 50 POP 1888 50 POP 1889 50 POP 188A 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @187E stack[-6] = stack[-1] // @1886 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_188B: // Incoming call from 0x01E3, returns to 0x01E4 // Incoming call from 0x024E, returns to 0x024F // Inputs[2] // { // @1893 stack[-1] // @1894 stack[-2] // } 188B 5B JUMPDEST 188C 60 PUSH1 0x00 188E 80 DUP1 188F 60 PUSH1 0x00 1891 60 PUSH1 0x60 1893 84 DUP5 1894 86 DUP7 1895 03 SUB 1896 12 SLT 1897 15 ISZERO 1898 61 PUSH2 0x18a0 189B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @188C stack[0] = 0x00 // @188E stack[1] = 0x00 // @188F stack[2] = 0x00 // } // Block ends with conditional jump to 0x18a0, if !(stack[-2] - stack[-1] i< 0x60) label_189C: // Incoming jump from 0x189B, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @189F memory[0x00:0x00] } 189C 60 PUSH1 0x00 189E 80 DUP1 189F FD *REVERT // Stack delta = +0 // Outputs[1] { @189F revert(memory[0x00:0x00]); } // Block terminates label_18A0: // Incoming jump from 0x189B, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @18A1 stack[-4] // @18A2 msg.data[stack[-4]:stack[-4] + 0x20] // } 18A0 5B JUMPDEST 18A1 83 DUP4 18A2 35 CALLDATALOAD 18A3 61 PUSH2 0x18ab 18A6 81 DUP2 18A7 61 PUSH2 0x184a 18AA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @18A2 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @18A3 stack[1] = 0x18ab // @18A6 stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x184a, returns to 0x18AB label_18AB: // Incoming return from call to 0x184A at 0x18AA // Inputs[4] // { // @18AC stack[-1] // @18AC stack[-4] // @18B0 stack[-5] // @18B2 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 18AB 5B JUMPDEST 18AC 92 SWAP3 18AD 50 POP 18AE 60 PUSH1 0x20 18B0 84 DUP5 18B1 01 ADD 18B2 35 CALLDATALOAD 18B3 61 PUSH2 0x18bb 18B6 81 DUP2 18B7 61 PUSH2 0x184a 18BA 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @18AC stack[-4] = stack[-1] // @18B2 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @18B3 stack[0] = 0x18bb // @18B6 stack[1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x184a, returns to 0x18BB label_18BB: // Incoming return from call to 0x184A at 0x18BA // Inputs[6] // { // @18BC stack[-4] // @18BC stack[-1] // @18BD stack[-7] // @18BF stack[-6] // @18C5 stack[-5] // @18C9 msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } 18BB 5B JUMPDEST 18BC 92 SWAP3 18BD 95 SWAP6 18BE 92 SWAP3 18BF 94 SWAP5 18C0 50 POP 18C1 50 POP 18C2 50 POP 18C3 60 PUSH1 0x40 18C5 91 SWAP2 18C6 90 SWAP1 18C7 91 SWAP2 18C8 01 ADD 18C9 35 CALLDATALOAD 18CA 90 SWAP1 18CB 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @18BD stack[-7] = stack[-4] // @18BF stack[-6] = stack[-1] // @18CA stack[-5] = msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } // Block ends with unconditional jump to stack[-7] label_18CC: // Incoming call from 0x01F6, returns to 0x01F7 // Inputs[2] // { // @18D2 stack[-1] // @18D3 stack[-2] // } 18CC 5B JUMPDEST 18CD 60 PUSH1 0x00 18CF 80 DUP1 18D0 60 PUSH1 0x40 18D2 83 DUP4 18D3 85 DUP6 18D4 03 SUB 18D5 12 SLT 18D6 15 ISZERO 18D7 61 PUSH2 0x18df 18DA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @18CD stack[0] = 0x00 // @18CF stack[1] = 0x00 // } // Block ends with conditional jump to 0x18df, if !(stack[-2] - stack[-1] i< 0x40) label_18DB: // Incoming jump from 0x18DA, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @18DE memory[0x00:0x00] } 18DB 60 PUSH1 0x00 18DD 80 DUP1 18DE FD *REVERT // Stack delta = +0 // Outputs[1] { @18DE revert(memory[0x00:0x00]); } // Block terminates label_18DF: // Incoming jump from 0x18DA, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[5] // { // @18E2 stack[-3] // @18E3 msg.data[stack[-3]:stack[-3] + 0x20] // @18E4 stack[-5] // @18EA msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @18EB stack[-4] // } 18DF 5B JUMPDEST 18E0 50 POP 18E1 50 POP 18E2 80 DUP1 18E3 35 CALLDATALOAD 18E4 92 SWAP3 18E5 60 PUSH1 0x20 18E7 90 SWAP1 18E8 91 SWAP2 18E9 01 ADD 18EA 35 CALLDATALOAD 18EB 91 SWAP2 18EC 50 POP 18ED 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @18E4 stack[-5] = msg.data[stack[-3]:stack[-3] + 0x20] // @18EB stack[-4] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with unconditional jump to stack[-5] label_18EE: // Incoming jump from 0x1945 // Incoming jump from 0x191D // Inputs[1] { @1903 memory[0x00:0x24] } 18EE 5B JUMPDEST 18EF 63 PUSH4 0x4e487b71 18F4 60 PUSH1 0xe0 18F6 1B SHL 18F7 60 PUSH1 0x00 18F9 52 MSTORE 18FA 60 PUSH1 0x41 18FC 60 PUSH1 0x04 18FE 52 MSTORE 18FF 60 PUSH1 0x24 1901 60 PUSH1 0x00 1903 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @18F9 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @18FE memory[0x04:0x24] = 0x41 // @1903 revert(memory[0x00:0x24]); // } // Block terminates label_1904: // Incoming call from 0x1A3B, returns to 0x0C25 // Incoming call from 0x19C0, returns to 0x0DC5 // Inputs[1] { @1910 stack[-2] } 1904 5B JUMPDEST 1905 60 PUSH1 0x00 1907 60 PUSH1 0x01 1909 60 PUSH1 0x01 190B 60 PUSH1 0x40 190D 1B SHL 190E 03 SUB 190F 80 DUP1 1910 84 DUP5 1911 11 GT 1912 15 ISZERO 1913 61 PUSH2 0x191e 1916 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1905 stack[0] = 0x00 // @190E stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x191e, if !(stack[-2] > (0x01 << 0x40) - 0x01) label_1917: // Incoming jump from 0x1916, if not !(stack[-2] > (0x01 << 0x40) - 0x01) 1917 61 PUSH2 0x191e 191A 61 PUSH2 0x18ee 191D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1917 stack[0] = 0x191e } // Block ends with unconditional jump to 0x18ee label_191E: // Incoming jump from 0x1916, if !(stack[-2] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @1921 memory[0x40:0x60] // @1924 stack[-4] // @1933 stack[-1] // } 191E 5B JUMPDEST 191F 60 PUSH1 0x40 1921 51 MLOAD 1922 60 PUSH1 0x1f 1924 85 DUP6 1925 01 ADD 1926 60 PUSH1 0x1f 1928 19 NOT 1929 90 SWAP1 192A 81 DUP2 192B 16 AND 192C 60 PUSH1 0x3f 192E 01 ADD 192F 16 AND 1930 81 DUP2 1931 01 ADD 1932 90 SWAP1 1933 82 DUP3 1934 82 DUP3 1935 11 GT 1936 81 DUP2 1937 83 DUP4 1938 10 LT 1939 17 OR 193A 15 ISZERO 193B 61 PUSH2 0x1946 193E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1932 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @1932 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x1946, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_193F: // Incoming jump from 0x193E, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 193F 61 PUSH2 0x1946 1942 61 PUSH2 0x18ee 1945 56 *JUMP // Stack delta = +1 // Outputs[1] { @193F stack[0] = 0x1946 } // Block ends with unconditional jump to 0x18ee label_1946: // Incoming jump from 0x193E, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @1947 stack[-2] // @194B stack[-1] // @194C stack[-4] // @194E stack[-6] // @1951 stack[-7] // @1953 stack[-5] // } 1946 5B JUMPDEST 1947 81 DUP2 1948 60 PUSH1 0x40 194A 52 MSTORE 194B 80 DUP1 194C 93 SWAP4 194D 50 POP 194E 85 DUP6 194F 81 DUP2 1950 52 MSTORE 1951 86 DUP7 1952 86 DUP7 1953 86 DUP7 1954 01 ADD 1955 11 GT 1956 15 ISZERO 1957 61 PUSH2 0x195f 195A 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @194A memory[0x40:0x60] = stack[-2] // @194C stack[-4] = stack[-1] // @1950 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x195f, if !(stack[-5] + stack[-6] > stack[-7]) label_195B: // Incoming jump from 0x195A, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @195E memory[0x00:0x00] } 195B 60 PUSH1 0x00 195D 80 DUP1 195E FD *REVERT // Stack delta = +0 // Outputs[1] { @195E revert(memory[0x00:0x00]); } // Block terminates label_195F: // Incoming jump from 0x195A, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @1960 stack[-6] // @1961 stack[-5] // @1964 stack[-1] // @1966 msg.data[stack[-5]:stack[-5] + stack[-6]] // @1973 stack[-4] // @1973 stack[-8] // @1974 stack[-7] // } 195F 5B JUMPDEST 1960 85 DUP6 1961 85 DUP6 1962 60 PUSH1 0x20 1964 83 DUP4 1965 01 ADD 1966 37 CALLDATACOPY 1967 60 PUSH1 0x00 1969 60 PUSH1 0x20 196B 87 DUP8 196C 83 DUP4 196D 01 ADD 196E 01 ADD 196F 52 MSTORE 1970 50 POP 1971 50 POP 1972 50 POP 1973 93 SWAP4 1974 92 SWAP3 1975 50 POP 1976 50 POP 1977 50 POP 1978 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @1966 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @196F memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @1973 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_1979: // Incoming call from 0x0287, returns to 0x0288 // Inputs[2] // { // @197E stack[-1] // @197F stack[-2] // } 1979 5B JUMPDEST 197A 60 PUSH1 0x00 197C 60 PUSH1 0x20 197E 82 DUP3 197F 84 DUP5 1980 03 SUB 1981 12 SLT 1982 15 ISZERO 1983 61 PUSH2 0x198b 1986 57 *JUMPI // Stack delta = +1 // Outputs[1] { @197A stack[0] = 0x00 } // Block ends with conditional jump to 0x198b, if !(stack[-2] - stack[-1] i< 0x20) label_1987: // Incoming jump from 0x1986, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @198A memory[0x00:0x00] } 1987 60 PUSH1 0x00 1989 80 DUP1 198A FD *REVERT // Stack delta = +0 // Outputs[1] { @198A revert(memory[0x00:0x00]); } // Block terminates label_198B: // Incoming jump from 0x1986, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @198C stack[-2] // @198D msg.data[stack[-2]:stack[-2] + 0x20] // } 198B 5B JUMPDEST 198C 81 DUP2 198D 35 CALLDATALOAD 198E 60 PUSH1 0x01 1990 60 PUSH1 0x01 1992 60 PUSH1 0x40 1994 1B SHL 1995 03 SUB 1996 81 DUP2 1997 11 GT 1998 15 ISZERO 1999 61 PUSH2 0x19a1 199C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @198D stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x19a1, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_199D: // Incoming jump from 0x199C, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @19A0 memory[0x00:0x00] } 199D 60 PUSH1 0x00 199F 80 DUP1 19A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @19A0 revert(memory[0x00:0x00]); } // Block terminates label_19A1: // Incoming jump from 0x199C, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @19A2 stack[-3] // @19A3 stack[-1] // @19A8 stack[-4] // } 19A1 5B JUMPDEST 19A2 82 DUP3 19A3 01 ADD 19A4 60 PUSH1 0x1f 19A6 81 DUP2 19A7 01 ADD 19A8 84 DUP5 19A9 13 SGT 19AA 61 PUSH2 0x19b2 19AD 57 *JUMPI // Stack delta = +0 // Outputs[1] { @19A3 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x19b2, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_19AE: // Incoming jump from 0x19AD, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @19B1 memory[0x00:0x00] } 19AE 60 PUSH1 0x00 19B0 80 DUP1 19B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @19B1 revert(memory[0x00:0x00]); } // Block terminates label_19B2: // Incoming jump from 0x19AD, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @19B6 stack[-4] // @19B7 stack[-1] // @19B8 msg.data[stack[-1]:stack[-1] + 0x20] // } 19B2 5B JUMPDEST 19B3 61 PUSH2 0x0dc5 19B6 84 DUP5 19B7 82 DUP3 19B8 35 CALLDATALOAD 19B9 60 PUSH1 0x20 19BB 84 DUP5 19BC 01 ADD 19BD 61 PUSH2 0x1904 19C0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @19B3 stack[0] = 0x0dc5 // @19B6 stack[1] = stack[-4] // @19B8 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @19BC stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1904, returns to 0x0DC5 label_19C1: // Incoming jump from 0x029A // Incoming jump from 0x03D8 // Incoming jump from 0x02CB // Inputs[2] // { // @19C6 stack[-1] // @19C7 stack[-2] // } 19C1 5B JUMPDEST 19C2 60 PUSH1 0x00 19C4 60 PUSH1 0x20 19C6 82 DUP3 19C7 84 DUP5 19C8 03 SUB 19C9 12 SLT 19CA 15 ISZERO 19CB 61 PUSH2 0x19d3 19CE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @19C2 stack[0] = 0x00 } // Block ends with conditional jump to 0x19d3, if !(stack[-2] - stack[-1] i< 0x20) label_19CF: // Incoming jump from 0x19CE, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @19D2 memory[0x00:0x00] } 19CF 60 PUSH1 0x00 19D1 80 DUP1 19D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @19D2 revert(memory[0x00:0x00]); } // Block terminates label_19D3: // Incoming jump from 0x19CE, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @19D4 stack[-2] // @19D5 msg.data[stack[-2]:stack[-2] + 0x20] // } 19D3 5B JUMPDEST 19D4 81 DUP2 19D5 35 CALLDATALOAD 19D6 61 PUSH2 0x0c25 19D9 81 DUP2 19DA 61 PUSH2 0x184a 19DD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @19D5 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @19D6 stack[1] = 0x0c25 // @19D9 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x184a, returns to 0x0C25 label_19DE: // Incoming call from 0x0320, returns to 0x0321 // Inputs[2] // { // @19E4 stack[-1] // @19E5 stack[-2] // } 19DE 5B JUMPDEST 19DF 60 PUSH1 0x00 19E1 80 DUP1 19E2 60 PUSH1 0x40 19E4 83 DUP4 19E5 85 DUP6 19E6 03 SUB 19E7 12 SLT 19E8 15 ISZERO 19E9 61 PUSH2 0x19f1 19EC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @19DF stack[0] = 0x00 // @19E1 stack[1] = 0x00 // } // Block ends with conditional jump to 0x19f1, if !(stack[-2] - stack[-1] i< 0x40) label_19ED: // Incoming jump from 0x19EC, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @19F0 memory[0x00:0x00] } 19ED 60 PUSH1 0x00 19EF 80 DUP1 19F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @19F0 revert(memory[0x00:0x00]); } // Block terminates label_19F1: // Incoming jump from 0x19EC, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @19F2 stack[-3] // @19F3 msg.data[stack[-3]:stack[-3] + 0x20] // } 19F1 5B JUMPDEST 19F2 82 DUP3 19F3 35 CALLDATALOAD 19F4 61 PUSH2 0x19fc 19F7 81 DUP2 19F8 61 PUSH2 0x184a 19FB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @19F3 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @19F4 stack[1] = 0x19fc // @19F7 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x184a, returns to 0x19FC label_19FC: // Incoming return from call to 0x184A at 0x19FB // Inputs[4] // { // @19FD stack[-3] // @19FD stack[-1] // @1A01 stack[-4] // @1A03 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 19FC 5B JUMPDEST 19FD 91 SWAP2 19FE 50 POP 19FF 60 PUSH1 0x20 1A01 83 DUP4 1A02 01 ADD 1A03 35 CALLDATALOAD 1A04 80 DUP1 1A05 15 ISZERO 1A06 15 ISZERO 1A07 81 DUP2 1A08 14 EQ 1A09 61 PUSH2 0x1a11 1A0C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @19FD stack[-3] = stack[-1] // @1A03 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1a11, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_1A0D: // Incoming jump from 0x1A0C, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[1] { @1A10 memory[0x00:0x00] } 1A0D 60 PUSH1 0x00 1A0F 80 DUP1 1A10 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A10 revert(memory[0x00:0x00]); } // Block terminates label_1A11: // Incoming return from call to 0x184A at 0x1B35 // Incoming jump from 0x1A0C, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @1A12 stack[-1] // @1A13 stack[-2] // @1A16 stack[-5] // @1A18 stack[-6] // @1A18 stack[-3] // @1A19 stack[-4] // } 1A11 5B JUMPDEST 1A12 80 DUP1 1A13 91 SWAP2 1A14 50 POP 1A15 50 POP 1A16 92 SWAP3 1A17 50 POP 1A18 92 SWAP3 1A19 90 SWAP1 1A1A 50 POP 1A1B 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1A16 stack[-5] = stack[-1] // @1A18 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1A1C: // Incoming jump from 0x1A9A // Incoming jump from 0x1B71 // Inputs[2] // { // @1A1F stack[-2] // @1A22 stack[-1] // } 1A1C 5B JUMPDEST 1A1D 60 PUSH1 0x00 1A1F 82 DUP3 1A20 60 PUSH1 0x1f 1A22 83 DUP4 1A23 01 ADD 1A24 12 SLT 1A25 61 PUSH2 0x1a2d 1A28 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A1D stack[0] = 0x00 } // Block ends with conditional jump to 0x1a2d, if stack[-1] + 0x1f i< stack[-2] label_1A29: // Incoming jump from 0x1A28, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1A2C memory[0x00:0x00] } 1A29 60 PUSH1 0x00 1A2B 80 DUP1 1A2C FD *REVERT // Stack delta = +0 // Outputs[1] { @1A2C revert(memory[0x00:0x00]); } // Block terminates label_1A2D: // Incoming jump from 0x1A28, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @1A31 stack[-3] // @1A32 stack[-2] // @1A33 msg.data[stack[-2]:stack[-2] + 0x20] // } 1A2D 5B JUMPDEST 1A2E 61 PUSH2 0x0c25 1A31 83 DUP4 1A32 83 DUP4 1A33 35 CALLDATALOAD 1A34 60 PUSH1 0x20 1A36 85 DUP6 1A37 01 ADD 1A38 61 PUSH2 0x1904 1A3B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A2E stack[0] = 0x0c25 // @1A31 stack[1] = stack[-3] // @1A33 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // @1A37 stack[3] = stack[-2] + 0x20 // } // Block ends with call to 0x1904, returns to 0x0C25 label_1A3C: // Incoming jump from 0x0333 // Inputs[2] // { // @1A45 stack[-1] // @1A46 stack[-2] // } 1A3C 5B JUMPDEST 1A3D 60 PUSH1 0x00 1A3F 80 DUP1 1A40 60 PUSH1 0x00 1A42 80 DUP1 1A43 60 PUSH1 0x80 1A45 85 DUP6 1A46 87 DUP8 1A47 03 SUB 1A48 12 SLT 1A49 15 ISZERO 1A4A 61 PUSH2 0x1a52 1A4D 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1A3D stack[0] = 0x00 // @1A3F stack[1] = 0x00 // @1A40 stack[2] = 0x00 // @1A42 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1a52, if !(stack[-2] - stack[-1] i< 0x80) label_1A4E: // Incoming jump from 0x1A4D, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1A51 memory[0x00:0x00] } 1A4E 60 PUSH1 0x00 1A50 80 DUP1 1A51 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A51 revert(memory[0x00:0x00]); } // Block terminates label_1A52: // Incoming jump from 0x1A4D, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @1A53 stack[-5] // @1A54 msg.data[stack[-5]:stack[-5] + 0x20] // } 1A52 5B JUMPDEST 1A53 84 DUP5 1A54 35 CALLDATALOAD 1A55 61 PUSH2 0x1a5d 1A58 81 DUP2 1A59 61 PUSH2 0x184a 1A5C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A54 stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @1A55 stack[1] = 0x1a5d // @1A58 stack[2] = msg.data[stack[-5]:stack[-5] + 0x20] // } // Block ends with call to 0x184a, returns to 0x1A5D label_1A5D: // Incoming return from call to 0x184A at 0x1A5C // Inputs[4] // { // @1A5E stack[-1] // @1A5E stack[-5] // @1A62 stack[-6] // @1A64 msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } 1A5D 5B JUMPDEST 1A5E 93 SWAP4 1A5F 50 POP 1A60 60 PUSH1 0x20 1A62 85 DUP6 1A63 01 ADD 1A64 35 CALLDATALOAD 1A65 61 PUSH2 0x1a6d 1A68 81 DUP2 1A69 61 PUSH2 0x184a 1A6C 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1A5E stack[-5] = stack[-1] // @1A64 stack[-1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @1A65 stack[0] = 0x1a6d // @1A68 stack[1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with call to 0x184a, returns to 0x1A6D label_1A6D: // Incoming return from call to 0x184A at 0x1A6C // Inputs[6] // { // @1A6E stack[-1] // @1A6E stack[-4] // @1A72 stack[-6] // @1A74 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1A75 stack[-3] // @1A7B msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 1A6D 5B JUMPDEST 1A6E 92 SWAP3 1A6F 50 POP 1A70 60 PUSH1 0x40 1A72 85 DUP6 1A73 01 ADD 1A74 35 CALLDATALOAD 1A75 91 SWAP2 1A76 50 POP 1A77 60 PUSH1 0x60 1A79 85 DUP6 1A7A 01 ADD 1A7B 35 CALLDATALOAD 1A7C 60 PUSH1 0x01 1A7E 60 PUSH1 0x01 1A80 60 PUSH1 0x40 1A82 1B SHL 1A83 03 SUB 1A84 81 DUP2 1A85 11 GT 1A86 15 ISZERO 1A87 61 PUSH2 0x1a8f 1A8A 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1A6E stack[-4] = stack[-1] // @1A75 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1A7B stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x1a8f, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) label_1A8B: // Incoming jump from 0x1A8A, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @1A8E memory[0x00:0x00] } 1A8B 60 PUSH1 0x00 1A8D 80 DUP1 1A8E FD *REVERT // Stack delta = +0 // Outputs[1] { @1A8E revert(memory[0x00:0x00]); } // Block terminates label_1A8F: // Incoming jump from 0x1A8A, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @1A93 stack[-7] // @1A94 stack[-1] // @1A95 stack[-6] // } 1A8F 5B JUMPDEST 1A90 61 PUSH2 0x1a9b 1A93 87 DUP8 1A94 82 DUP3 1A95 88 DUP9 1A96 01 ADD 1A97 61 PUSH2 0x1a1c 1A9A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A90 stack[0] = 0x1a9b // @1A93 stack[1] = stack[-7] // @1A96 stack[2] = stack[-6] + stack[-1] // } // Block ends with unconditional jump to 0x1a1c 1A9B 5B JUMPDEST 1A9C 91 SWAP2 1A9D 50 POP 1A9E 50 POP 1A9F 92 SWAP3 1AA0 95 SWAP6 1AA1 91 SWAP2 1AA2 94 SWAP5 1AA3 50 POP 1AA4 92 SWAP3 1AA5 50 POP 1AA6 56 *JUMP label_1AA7: // Incoming call from 0x036B, returns to 0x0183 // Inputs[3] // { // @1AAB stack[-1] // @1AAD stack[-2] // @1AAE memory[stack[-2]:stack[-2] + 0x20] // } 1AA7 5B JUMPDEST 1AA8 60 PUSH1 0x20 1AAA 80 DUP1 1AAB 82 DUP3 1AAC 52 MSTORE 1AAD 82 DUP3 1AAE 51 MLOAD 1AAF 82 DUP3 1AB0 82 DUP3 1AB1 01 ADD 1AB2 81 DUP2 1AB3 90 SWAP1 1AB4 52 MSTORE 1AB5 60 PUSH1 0x00 1AB7 91 SWAP2 1AB8 90 SWAP1 1AB9 60 PUSH1 0x40 1ABB 90 SWAP1 1ABC 81 DUP2 1ABD 85 DUP6 1ABE 01 ADD 1ABF 90 SWAP1 1AC0 86 DUP7 1AC1 84 DUP5 1AC2 01 ADD 1AC3 85 DUP6 1AC4 5B JUMPDEST 1AC5 82 DUP3 1AC6 81 DUP2 1AC7 10 LT 1AC8 15 ISZERO 1AC9 61 PUSH2 0x1afb 1ACC 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @1AAC memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1AB4 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @1AB7 stack[0] = 0x00 // @1AB8 stack[1] = 0x20 // @1ABB stack[2] = 0x40 // @1ABF stack[3] = stack[-1] + 0x40 // @1ABF stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @1AC2 stack[5] = 0x20 + stack[-2] // @1AC3 stack[6] = 0x00 // } // Block ends with conditional jump to 0x1afb, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_1ACD: // Incoming jump from 0x1ACC, if not !(stack[-1] < stack[-3]) // Incoming jump from 0x1ACC, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[8] // { // @1ACD stack[-2] // @1ACE memory[stack[-2]:stack[-2] + 0x20] // @1AD0 memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + 0x20] // @1ADA stack[-4] // @1ADC stack[-6] // @1ADE memory[stack[-6] + memory[stack[-2]:stack[-2] + 0x20]:stack[-6] + memory[stack[-2]:stack[-2] + 0x20] + 0x20] // @1AEC stack[-1] // @1AED stack[-5] // } 1ACD 81 DUP2 1ACE 51 MLOAD 1ACF 80 DUP1 1AD0 51 MLOAD 1AD1 60 PUSH1 0x01 1AD3 60 PUSH1 0x01 1AD5 60 PUSH1 0xa0 1AD7 1B SHL 1AD8 03 SUB 1AD9 16 AND 1ADA 85 DUP6 1ADB 52 MSTORE 1ADC 86 DUP7 1ADD 01 ADD 1ADE 51 MLOAD 1ADF 60 PUSH1 0x01 1AE1 60 PUSH1 0x01 1AE3 60 PUSH1 0x60 1AE5 1B SHL 1AE6 03 SUB 1AE7 16 AND 1AE8 86 DUP7 1AE9 85 DUP6 1AEA 01 ADD 1AEB 52 MSTORE 1AEC 92 SWAP3 1AED 84 DUP5 1AEE 01 ADD 1AEF 92 SWAP3 1AF0 90 SWAP1 1AF1 85 DUP6 1AF2 01 ADD 1AF3 90 SWAP1 1AF4 60 PUSH1 0x01 1AF6 01 ADD 1AF7 61 PUSH2 0x1ac4 1AFA 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @1ADB memory[stack[-4]:stack[-4] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + 0x20] // @1AEB memory[stack[-4] + stack[-6]:stack[-4] + stack[-6] + 0x20] = (0x01 << 0x60) - 0x01 & memory[stack[-6] + memory[stack[-2]:stack[-2] + 0x20]:stack[-6] + memory[stack[-2]:stack[-2] + 0x20] + 0x20] // @1AEF stack[-4] = stack[-5] + stack[-4] // @1AF3 stack[-2] = stack[-6] + stack[-2] // @1AF6 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1ac4 label_1AFB: // Incoming jump from 0x1ACC, if !(stack[-1] < stack[-3]) // Incoming jump from 0x1ACC, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @1AFD stack[-4] // @1AFD stack[-2] // @1AFE stack[-10] // @1AFF stack[-9] // } 1AFB 5B JUMPDEST 1AFC 50 POP 1AFD 91 SWAP2 1AFE 97 SWAP8 1AFF 96 SWAP7 1B00 50 POP 1B01 50 POP 1B02 50 POP 1B03 50 POP 1B04 50 POP 1B05 50 POP 1B06 50 POP 1B07 56 *JUMP // Stack delta = -9 // Outputs[1] { @1AFE stack[-10] = stack[-4] } // Block ends with unconditional jump to stack[-10] label_1B08: // Incoming jump from 0x039F // Inputs[2] // { // @1B0E stack[-1] // @1B0F stack[-2] // } 1B08 5B JUMPDEST 1B09 60 PUSH1 0x00 1B0B 80 DUP1 1B0C 60 PUSH1 0x40 1B0E 83 DUP4 1B0F 85 DUP6 1B10 03 SUB 1B11 12 SLT 1B12 15 ISZERO 1B13 61 PUSH2 0x1b1b 1B16 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1B09 stack[0] = 0x00 // @1B0B stack[1] = 0x00 // } // Block ends with conditional jump to 0x1b1b, if !(stack[-2] - stack[-1] i< 0x40) label_1B17: // Incoming jump from 0x1B16, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1B1A memory[0x00:0x00] } 1B17 60 PUSH1 0x00 1B19 80 DUP1 1B1A FD *REVERT // Stack delta = +0 // Outputs[1] { @1B1A revert(memory[0x00:0x00]); } // Block terminates label_1B1B: // Incoming jump from 0x1B16, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1B1C stack[-3] // @1B1D msg.data[stack[-3]:stack[-3] + 0x20] // } 1B1B 5B JUMPDEST 1B1C 82 DUP3 1B1D 35 CALLDATALOAD 1B1E 61 PUSH2 0x1b26 1B21 81 DUP2 1B22 61 PUSH2 0x184a 1B25 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B1D stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1B1E stack[1] = 0x1b26 // @1B21 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x184a, returns to 0x1B26 label_1B26: // Incoming return from call to 0x184A at 0x1B25 // Inputs[4] // { // @1B27 stack[-1] // @1B27 stack[-3] // @1B2B stack[-4] // @1B2D msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1B26 5B JUMPDEST 1B27 91 SWAP2 1B28 50 POP 1B29 60 PUSH1 0x20 1B2B 83 DUP4 1B2C 01 ADD 1B2D 35 CALLDATALOAD 1B2E 61 PUSH2 0x1a11 1B31 81 DUP2 1B32 61 PUSH2 0x184a 1B35 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1B27 stack[-3] = stack[-1] // @1B2D stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @1B2E stack[0] = 0x1a11 // @1B31 stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x184a, returns to 0x1A11 label_1B36: // Incoming jump from 0x03B2 // Inputs[2] // { // @1B3C stack[-1] // @1B3D stack[-2] // } 1B36 5B JUMPDEST 1B37 60 PUSH1 0x00 1B39 80 DUP1 1B3A 60 PUSH1 0x40 1B3C 83 DUP4 1B3D 85 DUP6 1B3E 03 SUB 1B3F 12 SLT 1B40 15 ISZERO 1B41 61 PUSH2 0x1b49 1B44 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1B37 stack[0] = 0x00 // @1B39 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1b49, if !(stack[-2] - stack[-1] i< 0x40) label_1B45: // Incoming jump from 0x1B44, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1B48 memory[0x00:0x00] } 1B45 60 PUSH1 0x00 1B47 80 DUP1 1B48 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B48 revert(memory[0x00:0x00]); } // Block terminates label_1B49: // Incoming jump from 0x1B44, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @1B4A stack[-3] // @1B4B msg.data[stack[-3]:stack[-3] + 0x20] // @1B4C stack[-2] // @1B52 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 1B49 5B JUMPDEST 1B4A 82 DUP3 1B4B 35 CALLDATALOAD 1B4C 91 SWAP2 1B4D 50 POP 1B4E 60 PUSH1 0x20 1B50 83 DUP4 1B51 01 ADD 1B52 35 CALLDATALOAD 1B53 60 PUSH1 0x01 1B55 60 PUSH1 0x01 1B57 60 PUSH1 0x40 1B59 1B SHL 1B5A 03 SUB 1B5B 81 DUP2 1B5C 11 GT 1B5D 15 ISZERO 1B5E 61 PUSH2 0x1b66 1B61 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1B4C stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @1B52 stack[0] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1b66, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) label_1B62: // Incoming jump from 0x1B61, if not !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @1B65 memory[0x00:0x00] } 1B62 60 PUSH1 0x00 1B64 80 DUP1 1B65 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B65 revert(memory[0x00:0x00]); } // Block terminates label_1B66: // Incoming jump from 0x1B61, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @1B6A stack[-5] // @1B6B stack[-1] // @1B6C stack[-4] // } 1B66 5B JUMPDEST 1B67 61 PUSH2 0x1b72 1B6A 85 DUP6 1B6B 82 DUP3 1B6C 86 DUP7 1B6D 01 ADD 1B6E 61 PUSH2 0x1a1c 1B71 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B67 stack[0] = 0x1b72 // @1B6A stack[1] = stack[-5] // @1B6D stack[2] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x1a1c 1B72 5B JUMPDEST 1B73 91 SWAP2 1B74 50 POP 1B75 50 POP 1B76 92 SWAP3 1B77 50 POP 1B78 92 SWAP3 1B79 90 SWAP1 1B7A 50 POP 1B7B 56 *JUMP label_1B7C: // Incoming call from 0x03C5, returns to 0x03C6 // Inputs[2] // { // @1B81 stack[-1] // @1B82 stack[-2] // } 1B7C 5B JUMPDEST 1B7D 60 PUSH1 0x00 1B7F 60 PUSH1 0x20 1B81 82 DUP3 1B82 84 DUP5 1B83 03 SUB 1B84 12 SLT 1B85 15 ISZERO 1B86 61 PUSH2 0x1b8e 1B89 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B7D stack[0] = 0x00 } // Block ends with conditional jump to 0x1b8e, if !(stack[-2] - stack[-1] i< 0x20) label_1B8A: // Incoming jump from 0x1B89, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1B8D memory[0x00:0x00] } 1B8A 60 PUSH1 0x00 1B8C 80 DUP1 1B8D FD *REVERT // Stack delta = +0 // Outputs[1] { @1B8D revert(memory[0x00:0x00]); } // Block terminates label_1B8E: // Incoming jump from 0x1B89, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1B8F stack[-2] // @1B90 msg.data[stack[-2]:stack[-2] + 0x20] // } 1B8E 5B JUMPDEST 1B8F 81 DUP2 1B90 35 CALLDATALOAD 1B91 60 PUSH1 0x01 1B93 60 PUSH1 0x01 1B95 60 PUSH1 0x60 1B97 1B SHL 1B98 03 SUB 1B99 81 DUP2 1B9A 16 AND 1B9B 81 DUP2 1B9C 14 EQ 1B9D 61 PUSH2 0x0c25 1BA0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B90 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0c25, if msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0x60) - 0x01 label_1BA1: // Incoming jump from 0x1BA0, if not msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0x60) - 0x01 // Inputs[1] { @1BA4 memory[0x00:0x00] } 1BA1 60 PUSH1 0x00 1BA3 80 DUP1 1BA4 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BA4 revert(memory[0x00:0x00]); } // Block terminates label_1BA5: // Incoming call from 0x0B95, returns to 0x0B96 // Incoming call from 0x0B69, returns to 0x0B6A // Incoming call from 0x16B7, returns to 0x16B8 // Incoming call from 0x099E, returns to 0x0796 // Incoming call from 0x16F1, returns to 0x16F2 // Incoming call from 0x15AE, returns to 0x0440 // Incoming call from 0x07C1, returns to 0x07C2 // Incoming call from 0x0795, returns to 0x0796 // Incoming call from 0x043F, returns to 0x0440 // Incoming call from 0x0A0D, returns to 0x0440 // Incoming call from 0x046B, returns to 0x046C // Inputs[1] { @1BA8 stack[-1] } 1BA5 5B JUMPDEST 1BA6 60 PUSH1 0x01 1BA8 81 DUP2 1BA9 81 DUP2 1BAA 1C SHR 1BAB 90 SWAP1 1BAC 82 DUP3 1BAD 16 AND 1BAE 80 DUP1 1BAF 61 PUSH2 0x1bb9 1BB2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1BAB stack[0] = stack[-1] >> 0x01 // @1BAD stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x1bb9, if stack[-1] & 0x01 label_1BB3: // Incoming jump from 0x1BB2, if not stack[-1] & 0x01 // Inputs[2] // { // @1BB5 stack[-2] // @1BBE stack[-1] // } 1BB3 60 PUSH1 0x7f 1BB5 82 DUP3 1BB6 16 AND 1BB7 91 SWAP2 1BB8 50 POP 1BB9 5B JUMPDEST 1BBA 60 PUSH1 0x20 1BBC 82 DUP3 1BBD 10 LT 1BBE 81 DUP2 1BBF 14 EQ 1BC0 15 ISZERO 1BC1 61 PUSH2 0x0c2c 1BC4 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1BB7 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x0c2c, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_1BC5: // Incoming jump from 0x1BC4, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x1BC4, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @1BD9 memory[0x00:0x24] } 1BC5 63 PUSH4 0x4e487b71 1BCA 60 PUSH1 0xe0 1BCC 1B SHL 1BCD 60 PUSH1 0x00 1BCF 52 MSTORE 1BD0 60 PUSH1 0x22 1BD2 60 PUSH1 0x04 1BD4 52 MSTORE 1BD5 60 PUSH1 0x24 1BD7 60 PUSH1 0x00 1BD9 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1BCF memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1BD4 memory[0x04:0x24] = 0x22 // @1BD9 revert(memory[0x00:0x24]); // } // Block terminates label_1BDA: // Incoming call from 0x0686, returns to 0x052B // Incoming call from 0x0AF4, returns to 0x052B // Inputs[2] // { // @1BDE stack[-1] // @1C29 stack[-2] // } 1BDA 5B JUMPDEST 1BDB 60 PUSH1 0x20 1BDD 80 DUP1 1BDE 82 DUP3 1BDF 52 MSTORE 1BE0 60 PUSH1 0x31 1BE2 90 SWAP1 1BE3 82 DUP3 1BE4 01 ADD 1BE5 52 MSTORE 1BE6 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 1C07 60 PUSH1 0x40 1C09 82 DUP3 1C0A 01 ADD 1C0B 52 MSTORE 1C0C 70 PUSH17 0x1ddb995c881b9bdc88185c1c1c9bdd9959 1C1E 60 PUSH1 0x7a 1C20 1B SHL 1C21 60 PUSH1 0x60 1C23 82 DUP3 1C24 01 ADD 1C25 52 MSTORE 1C26 60 PUSH1 0x80 1C28 01 ADD 1C29 90 SWAP1 1C2A 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1BDF memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1BE5 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x31 // @1C0B memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f // @1C25 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x1ddb995c881b9bdc88185c1c1c9bdd9959 << 0x7a // @1C29 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_1C2B: // Incoming jump from 0x1C5A // Incoming jump from 0x1D32 // Incoming jump from 0x1D4A // Inputs[1] { @1C40 memory[0x00:0x24] } 1C2B 5B JUMPDEST 1C2C 63 PUSH4 0x4e487b71 1C31 60 PUSH1 0xe0 1C33 1B SHL 1C34 60 PUSH1 0x00 1C36 52 MSTORE 1C37 60 PUSH1 0x11 1C39 60 PUSH1 0x04 1C3B 52 MSTORE 1C3C 60 PUSH1 0x24 1C3E 60 PUSH1 0x00 1C40 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1C36 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1C3B memory[0x04:0x24] = 0x11 // @1C40 revert(memory[0x00:0x24]); // } // Block terminates label_1C41: // Incoming call from 0x06C6, returns to 0x06C7 // Inputs[2] // { // @1C44 stack[-1] // @1C49 stack[-2] // } 1C41 5B JUMPDEST 1C42 60 PUSH1 0x00 1C44 81 DUP2 1C45 60 PUSH1 0x00 1C47 19 NOT 1C48 04 DIV 1C49 83 DUP4 1C4A 11 GT 1C4B 82 DUP3 1C4C 15 ISZERO 1C4D 15 ISZERO 1C4E 16 AND 1C4F 15 ISZERO 1C50 61 PUSH2 0x1c5b 1C53 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C42 stack[0] = 0x00 } // Block ends with conditional jump to 0x1c5b, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_1C54: // Incoming jump from 0x1C53, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 1C54 61 PUSH2 0x1c5b 1C57 61 PUSH2 0x1c2b 1C5A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C54 stack[0] = 0x1c5b } // Block ends with unconditional jump to 0x1c2b label_1C5B: // Incoming jump from 0x1C53, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @1C5D stack[-3] // @1C5D stack[-2] // @1C5E stack[-4] // } 1C5B 5B JUMPDEST 1C5C 50 POP 1C5D 02 MUL 1C5E 90 SWAP1 1C5F 56 *JUMP // Stack delta = -3 // Outputs[1] { @1C5E stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_1C60: // Incoming jump from 0x1C84 // Inputs[1] { @1C75 memory[0x00:0x24] } 1C60 5B JUMPDEST 1C61 63 PUSH4 0x4e487b71 1C66 60 PUSH1 0xe0 1C68 1B SHL 1C69 60 PUSH1 0x00 1C6B 52 MSTORE 1C6C 60 PUSH1 0x12 1C6E 60 PUSH1 0x04 1C70 52 MSTORE 1C71 60 PUSH1 0x24 1C73 60 PUSH1 0x00 1C75 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1C6B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1C70 memory[0x04:0x24] = 0x12 // @1C75 revert(memory[0x00:0x24]); // } // Block terminates label_1C76: // Incoming call from 0x06D0, returns to 0x06D1 // Inputs[1] { @1C79 stack[-2] } 1C76 5B JUMPDEST 1C77 60 PUSH1 0x00 1C79 82 DUP3 1C7A 61 PUSH2 0x1c85 1C7D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C77 stack[0] = 0x00 } // Block ends with conditional jump to 0x1c85, if stack[-2] label_1C7E: // Incoming jump from 0x1C7D, if not stack[-2] 1C7E 61 PUSH2 0x1c85 1C81 61 PUSH2 0x1c60 1C84 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C7E stack[0] = 0x1c85 } // Block ends with unconditional jump to 0x1c60 label_1C85: // Incoming jump from 0x1C7D, if stack[-2] // Inputs[3] // { // @1C87 stack[-2] // @1C87 stack[-3] // @1C88 stack[-4] // } 1C85 5B JUMPDEST 1C86 50 POP 1C87 04 DIV 1C88 90 SWAP1 1C89 56 *JUMP // Stack delta = -3 // Outputs[1] { @1C88 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_1C8A: // Incoming call from 0x0E49, returns to 0x052B // Incoming call from 0x0985, returns to 0x052B // Incoming call from 0x070A, returns to 0x052B // Incoming call from 0x0747, returns to 0x052B // Incoming call from 0x08BC, returns to 0x052B // Inputs[2] // { // @1C8E stack[-1] // @1CBD stack[-2] // } 1C8A 5B JUMPDEST 1C8B 60 PUSH1 0x20 1C8D 80 DUP1 1C8E 82 DUP3 1C8F 52 MSTORE 1C90 81 DUP2 1C91 81 DUP2 1C92 01 ADD 1C93 52 MSTORE 1C94 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1CB5 60 PUSH1 0x40 1CB7 82 DUP3 1CB8 01 ADD 1CB9 52 MSTORE 1CBA 60 PUSH1 0x60 1CBC 01 ADD 1CBD 90 SWAP1 1CBE 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1C8F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1C93 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @1CB9 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1CBD stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_1CBF: // Incoming call from 0x0C04, returns to 0x0C05 // Inputs[3] // { // @1CCB stack[-1] // @1CCF stack[-2] // @1CD0 memory[stack[-2]:stack[-2] + 0x20] // } 1CBF 5B JUMPDEST 1CC0 66 PUSH7 0x697066733a2f2f 1CC8 60 PUSH1 0xc8 1CCA 1B SHL 1CCB 81 DUP2 1CCC 52 MSTORE 1CCD 60 PUSH1 0x00 1CCF 82 DUP3 1CD0 51 MLOAD 1CD1 61 PUSH2 0x1ce1 1CD4 81 DUP2 1CD5 60 PUSH1 0x07 1CD7 85 DUP6 1CD8 01 ADD 1CD9 60 PUSH1 0x20 1CDB 87 DUP8 1CDC 01 ADD 1CDD 61 PUSH2 0x17b2 1CE0 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1CCC memory[stack[-1]:stack[-1] + 0x20] = 0x697066733a2f2f << 0xc8 // @1CCD stack[0] = 0x00 // @1CD0 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @1CD1 stack[2] = 0x1ce1 // @1CD4 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @1CD8 stack[4] = stack[-1] + 0x07 // @1CDC stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x17b2, returns to 0x1CE1 label_1CE1: // Incoming return from call to 0x17B2 at 0x1CE0 // Inputs[5] // { // @1CE2 stack[-1] // @1CE2 stack[-3] // @1CE3 stack[-2] // @1CE9 stack[-5] // @1CEA stack[-4] // } 1CE1 5B JUMPDEST 1CE2 91 SWAP2 1CE3 90 SWAP1 1CE4 91 SWAP2 1CE5 01 ADD 1CE6 60 PUSH1 0x07 1CE8 01 ADD 1CE9 92 SWAP3 1CEA 91 SWAP2 1CEB 50 POP 1CEC 50 POP 1CED 56 *JUMP // Stack delta = -4 // Outputs[1] { @1CE9 stack[-5] = 0x07 + stack[-1] + stack[-3] } // Block ends with unconditional jump to stack[-5] label_1CEE: // Incoming jump from 0x0CDA // Incoming jump from 0x0C9E // Inputs[1] { @1D03 memory[0x00:0x24] } 1CEE 5B JUMPDEST 1CEF 63 PUSH4 0x4e487b71 1CF4 60 PUSH1 0xe0 1CF6 1B SHL 1CF7 60 PUSH1 0x00 1CF9 52 MSTORE 1CFA 60 PUSH1 0x32 1CFC 60 PUSH1 0x04 1CFE 52 MSTORE 1CFF 60 PUSH1 0x24 1D01 60 PUSH1 0x00 1D03 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1CF9 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1CFE memory[0x04:0x24] = 0x32 // @1D03 revert(memory[0x00:0x24]); // } // Block terminates label_1D04: // Incoming jump from 0x0D81 // Inputs[2] // { // @1D09 stack[-1] // @1D0A stack[-2] // } 1D04 5B JUMPDEST 1D05 60 PUSH1 0x00 1D07 60 PUSH1 0x20 1D09 82 DUP3 1D0A 84 DUP5 1D0B 03 SUB 1D0C 12 SLT 1D0D 15 ISZERO 1D0E 61 PUSH2 0x1d16 1D11 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D05 stack[0] = 0x00 } // Block ends with conditional jump to 0x1d16, if !(stack[-2] - stack[-1] i< 0x20) label_1D12: // Incoming jump from 0x1D11, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1D15 memory[0x00:0x00] } 1D12 60 PUSH1 0x00 1D14 80 DUP1 1D15 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D15 revert(memory[0x00:0x00]); } // Block terminates label_1D16: // Incoming jump from 0x1D11, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1D17 stack[-2] // @1D18 memory[stack[-2]:stack[-2] + 0x20] // } 1D16 5B JUMPDEST 1D17 81 DUP2 1D18 51 MLOAD 1D19 61 PUSH2 0x0c25 1D1C 81 DUP2 1D1D 61 PUSH2 0x184a 1D20 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D18 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @1D19 stack[1] = 0x0c25 // @1D1C stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x184a, returns to 0x0C25 label_1D21: // Incoming call from 0x11BC, returns to 0x11BD // Inputs[2] // { // @1D24 stack[-2] // @1D25 stack[-1] // } 1D21 5B JUMPDEST 1D22 60 PUSH1 0x00 1D24 82 DUP3 1D25 82 DUP3 1D26 10 LT 1D27 15 ISZERO 1D28 61 PUSH2 0x1d33 1D2B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D22 stack[0] = 0x00 } // Block ends with conditional jump to 0x1d33, if !(stack[-1] < stack[-2]) label_1D2C: // Incoming jump from 0x1D2B, if not !(stack[-1] < stack[-2]) 1D2C 61 PUSH2 0x1d33 1D2F 61 PUSH2 0x1c2b 1D32 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D2C stack[0] = 0x1d33 } // Block ends with unconditional jump to 0x1c2b label_1D33: // Incoming jump from 0x1D2B, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @1D35 stack[-3] // @1D35 stack[-2] // @1D36 stack[-4] // } 1D33 5B JUMPDEST 1D34 50 POP 1D35 03 SUB 1D36 90 SWAP1 1D37 56 *JUMP // Stack delta = -3 // Outputs[1] { @1D36 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_1D38: // Incoming call from 0x130D, returns to 0x130E // Incoming call from 0x11EA, returns to 0x11EB // Inputs[2] // { // @1D3B stack[-2] // @1D3D stack[-1] // } 1D38 5B JUMPDEST 1D39 60 PUSH1 0x00 1D3B 82 DUP3 1D3C 19 NOT 1D3D 82 DUP3 1D3E 11 GT 1D3F 15 ISZERO 1D40 61 PUSH2 0x1d4b 1D43 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D39 stack[0] = 0x00 } // Block ends with conditional jump to 0x1d4b, if !(stack[-1] > ~stack[-2]) label_1D44: // Incoming jump from 0x1D43, if not !(stack[-1] > ~stack[-2]) 1D44 61 PUSH2 0x1d4b 1D47 61 PUSH2 0x1c2b 1D4A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D44 stack[0] = 0x1d4b } // Block ends with unconditional jump to 0x1c2b label_1D4B: // Incoming jump from 0x1D43, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @1D4D stack[-2] // @1D4D stack[-3] // @1D4E stack[-4] // } 1D4B 5B JUMPDEST 1D4C 50 POP 1D4D 01 ADD 1D4E 90 SWAP1 1D4F 56 *JUMP // Stack delta = -3 // Outputs[1] { @1D4E stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_1D50: // Incoming call from 0x1572, returns to 0x052B // Incoming call from 0x13DE, returns to 0x052B // Inputs[2] // { // @1D54 stack[-1] // @1DA0 stack[-2] // } 1D50 5B JUMPDEST 1D51 60 PUSH1 0x20 1D53 80 DUP1 1D54 82 DUP3 1D55 52 MSTORE 1D56 60 PUSH1 0x32 1D58 90 SWAP1 1D59 82 DUP3 1D5A 01 ADD 1D5B 52 MSTORE 1D5C 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 1D7D 60 PUSH1 0x40 1D7F 82 DUP3 1D80 01 ADD 1D81 52 MSTORE 1D82 71 PUSH18 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 1D95 60 PUSH1 0x71 1D97 1B SHL 1D98 60 PUSH1 0x60 1D9A 82 DUP3 1D9B 01 ADD 1D9C 52 MSTORE 1D9D 60 PUSH1 0x80 1D9F 01 ADD 1DA0 90 SWAP1 1DA1 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1D55 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1D5B memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x32 // @1D81 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 // @1D9C memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 << 0x71 // @1DA0 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 1DA2 5B JUMPDEST 1DA3 60 PUSH1 0x00 1DA5 83 DUP4 1DA6 51 MLOAD 1DA7 61 PUSH2 0x1db4 1DAA 81 DUP2 1DAB 84 DUP5 1DAC 60 PUSH1 0x20 1DAE 88 DUP9 1DAF 01 ADD 1DB0 61 PUSH2 0x17b2 1DB3 56 *JUMP 1DB4 5B JUMPDEST 1DB5 83 DUP4 1DB6 51 MLOAD 1DB7 90 SWAP1 1DB8 83 DUP4 1DB9 01 ADD 1DBA 90 SWAP1 1DBB 61 PUSH2 0x1dc8 1DBE 81 DUP2 1DBF 83 DUP4 1DC0 60 PUSH1 0x20 1DC2 88 DUP9 1DC3 01 ADD 1DC4 61 PUSH2 0x17b2 1DC7 56 *JUMP 1DC8 5B JUMPDEST 1DC9 01 ADD 1DCA 94 SWAP5 1DCB 93 SWAP4 1DCC 50 POP 1DCD 50 POP 1DCE 50 POP 1DCF 50 POP 1DD0 56 *JUMP label_1DD1: // Incoming call from 0x14D6, returns to 0x14D7 // Inputs[5] // { // @1DDA stack[-5] // @1DDD stack[-1] // @1DDF stack[-4] // @1DEA stack[-3] // @1DFF stack[-2] // } 1DD1 5B JUMPDEST 1DD2 60 PUSH1 0x01 1DD4 60 PUSH1 0x01 1DD6 60 PUSH1 0xa0 1DD8 1B SHL 1DD9 03 SUB 1DDA 85 DUP6 1DDB 81 DUP2 1DDC 16 AND 1DDD 82 DUP3 1DDE 52 MSTORE 1DDF 84 DUP5 1DE0 16 AND 1DE1 60 PUSH1 0x20 1DE3 82 DUP3 1DE4 01 ADD 1DE5 52 MSTORE 1DE6 60 PUSH1 0x40 1DE8 81 DUP2 1DE9 01 ADD 1DEA 83 DUP4 1DEB 90 SWAP1 1DEC 52 MSTORE 1DED 60 PUSH1 0x80 1DEF 60 PUSH1 0x60 1DF1 82 DUP3 1DF2 01 ADD 1DF3 81 DUP2 1DF4 90 SWAP1 1DF5 52 MSTORE 1DF6 60 PUSH1 0x00 1DF8 90 SWAP1 1DF9 61 PUSH2 0x1e04 1DFC 90 SWAP1 1DFD 83 DUP4 1DFE 01 ADD 1DFF 84 DUP5 1E00 61 PUSH2 0x17de 1E03 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @1DDE memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1DE5 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1DEC memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @1DF5 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @1DF8 stack[0] = 0x00 // @1DFC stack[1] = 0x1e04 // @1DFE stack[2] = stack[-1] + 0x80 // @1DFF stack[3] = stack[-2] // } // Block ends with call to 0x17de, returns to 0x1E04 label_1E04: // Incoming return from call to 0x17DE at 0x1E03 // Inputs[3] // { // @1E05 stack[-8] // @1E05 stack[-1] // @1E06 stack[-7] // } 1E04 5B JUMPDEST 1E05 96 SWAP7 1E06 95 SWAP6 1E07 50 POP 1E08 50 POP 1E09 50 POP 1E0A 50 POP 1E0B 50 POP 1E0C 50 POP 1E0D 56 *JUMP // Stack delta = -7 // Outputs[1] { @1E05 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_1E0E: // Incoming jump from 0x151D // Inputs[2] // { // @1E13 stack[-1] // @1E14 stack[-2] // } 1E0E 5B JUMPDEST 1E0F 60 PUSH1 0x00 1E11 60 PUSH1 0x20 1E13 82 DUP3 1E14 84 DUP5 1E15 03 SUB 1E16 12 SLT 1E17 15 ISZERO 1E18 61 PUSH2 0x1e20 1E1B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E0F stack[0] = 0x00 } // Block ends with conditional jump to 0x1e20, if !(stack[-2] - stack[-1] i< 0x20) label_1E1C: // Incoming jump from 0x1E1B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1E1F memory[0x00:0x00] } 1E1C 60 PUSH1 0x00 1E1E 80 DUP1 1E1F FD *REVERT // Stack delta = +0 // Outputs[1] { @1E1F revert(memory[0x00:0x00]); } // Block terminates label_1E20: // Incoming jump from 0x1E1B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E21 stack[-2] // @1E22 memory[stack[-2]:stack[-2] + 0x20] // } 1E20 5B JUMPDEST 1E21 81 DUP2 1E22 51 MLOAD 1E23 61 PUSH2 0x0c25 1E26 81 DUP2 1E27 61 PUSH2 0x177f 1E2A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E22 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @1E23 stack[1] = 0x0c25 // @1E26 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x177f, returns to 0x0C25 1E2B 5B JUMPDEST 1E2C 60 PUSH1 0x00 1E2E 60 PUSH1 0x00 1E30 19 NOT 1E31 82 DUP3 1E32 14 EQ 1E33 15 ISZERO 1E34 61 PUSH2 0x1e3f 1E37 57 *JUMPI 1E38 61 PUSH2 0x1e3f 1E3B 61 PUSH2 0x1c2b 1E3E 56 *JUMP 1E3F 5B JUMPDEST 1E40 50 POP 1E41 60 PUSH1 0x01 1E43 01 ADD 1E44 90 SWAP1 1E45 56 *JUMP 1E46 5B JUMPDEST 1E47 60 PUSH1 0x00 1E49 82 DUP3 1E4A 61 PUSH2 0x1e55 1E4D 57 *JUMPI 1E4E 61 PUSH2 0x1e55 1E51 61 PUSH2 0x1c60 1E54 56 *JUMP 1E55 5B JUMPDEST 1E56 50 POP 1E57 06 MOD 1E58 90 SWAP1 1E59 56 *JUMP 1E5A FE *ASSERT 1E5B DD DD 1E5C F2 CALLCODE 1E5D 52 MSTORE 1E5E AD AD 1E5F 1B SHL 1E60 E2 E2 1E61 C8 C8 1E62 9B SWAP12 1E63 69 PUSH10 0xc2b068fc378daa952ba7 1E6E F1 CALL 1E6F 63 PUSH4 0xc4a11628 1E74 F5 CREATE2 1E75 5A GAS 1E76 4D 4D 1E77 F5 CREATE2 1E78 23 23 1E79 B3 B3 1E7A EF EF 1E7B A2 LOG2 1E7C 64 PUSH5 0x6970667358 1E82 22 22 1E83 12 SLT 1E84 20 SHA3 1E85 6F PUSH16 0x570602881484979fd216ac4407f350b6 1E96 38 CODESIZE 1E97 09 MULMOD 1E98 6F PUSH16 0x277c797e3f4779f1993c013f64736f6c 1EA9 63 PUSH4 0x43000809 1EAE 00 *STOP 1EAF 33 CALLER