Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x014b 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x014b, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x729ad39e 0019 11 GT 001A 61 PUSH2 0x00b6 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00b6, if 0x729ad39e > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x729ad39e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xc87b56dd 0024 11 GT 0025 61 PUSH2 0x006f 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xc87b56dd > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xc87b56dd > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xc87b56dd 002F 14 EQ 0030 61 PUSH2 0x03c3 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c3, if 0xc87b56dd == stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xd0679d34 003A 14 EQ 003B 61 PUSH2 0x03e3 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e3, if 0xd0679d34 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xd0679d34 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe985e9c5 0045 14 EQ 0046 61 PUSH2 0x0403 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0403, if 0xe985e9c5 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xea105ac7 0050 14 EQ 0051 61 PUSH2 0x044c 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x044c, if 0xea105ac7 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xea105ac7 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x0461 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0461, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf3fef3a3 0066 14 EQ 0067 61 PUSH2 0x0481 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0481, if 0xf3fef3a3 == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf3fef3a3 == stack[-1] // Inputs[1] { @006E memory[0x00:0x00] } 006B 60 PUSH1 0x00 006D 80 DUP1 006E FD *REVERT // Stack delta = +0 // Outputs[1] { @006E revert(memory[0x00:0x00]); } // Block terminates label_006F: // Incoming jump from 0x0028, if 0xc87b56dd > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0x729ad39e 0076 14 EQ 0077 61 PUSH2 0x031d 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x031d, if 0x729ad39e == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0x729ad39e == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0x8da5cb5b 0081 14 EQ 0082 61 PUSH2 0x033d 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033d, if 0x8da5cb5b == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0x95d89b41 008C 14 EQ 008D 61 PUSH2 0x035b 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x035b, if 0x95d89b41 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xa0712d68 0097 14 EQ 0098 61 PUSH2 0x0370 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0370, if 0xa0712d68 == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xa0712d68 == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0xa22cb465 00A2 14 EQ 00A3 61 PUSH2 0x0383 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0383, if 0xa22cb465 == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00A7 stack[-1] } 00A7 80 DUP1 00A8 63 PUSH4 0xb88d4fde 00AD 14 EQ 00AE 61 PUSH2 0x03a3 00B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a3, if 0xb88d4fde == stack[-1] label_00B2: // Incoming jump from 0x00B1, if not 0xb88d4fde == stack[-1] // Inputs[1] { @00B5 memory[0x00:0x00] } 00B2 60 PUSH1 0x00 00B4 80 DUP1 00B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @00B5 revert(memory[0x00:0x00]); } // Block terminates label_00B6: // Incoming jump from 0x001D, if 0x729ad39e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00B7 stack[-1] } 00B6 5B JUMPDEST 00B7 80 DUP1 00B8 63 PUSH4 0x23b872dd 00BD 11 GT 00BE 61 PUSH2 0x0108 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0108, if 0x23b872dd > stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x23b872dd > stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x23b872dd 00C8 14 EQ 00C9 61 PUSH2 0x0244 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0244, if 0x23b872dd == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x23b872dd == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0x42842e0e 00D3 14 EQ 00D4 61 PUSH2 0x0264 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0264, if 0x42842e0e == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0x42842e0e == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0x5a9b0b89 00DE 14 EQ 00DF 61 PUSH2 0x0284 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0284, if 0x5a9b0b89 == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0x5a9b0b89 == stack[-1] // Inputs[1] { @00E3 stack[-1] } 00E3 80 DUP1 00E4 63 PUSH4 0x6352211e 00E9 14 EQ 00EA 61 PUSH2 0x02c8 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c8, if 0x6352211e == stack[-1] label_00EE: // Incoming jump from 0x00ED, if not 0x6352211e == stack[-1] // Inputs[1] { @00EE stack[-1] } 00EE 80 DUP1 00EF 63 PUSH4 0x70a08231 00F4 14 EQ 00F5 61 PUSH2 0x02e8 00F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e8, if 0x70a08231 == stack[-1] label_00F9: // Incoming jump from 0x00F8, if not 0x70a08231 == stack[-1] // Inputs[1] { @00F9 stack[-1] } 00F9 80 DUP1 00FA 63 PUSH4 0x715018a6 00FF 14 EQ 0100 61 PUSH2 0x0308 0103 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0308, if 0x715018a6 == stack[-1] label_0104: // Incoming jump from 0x0103, if not 0x715018a6 == stack[-1] // Inputs[1] { @0107 memory[0x00:0x00] } 0104 60 PUSH1 0x00 0106 80 DUP1 0107 FD *REVERT // Stack delta = +0 // Outputs[1] { @0107 revert(memory[0x00:0x00]); } // Block terminates label_0108: // Incoming jump from 0x00C1, if 0x23b872dd > stack[-1] // Inputs[1] { @0109 stack[-1] } 0108 5B JUMPDEST 0109 80 DUP1 010A 63 PUSH4 0x01ffc9a7 010F 14 EQ 0110 61 PUSH2 0x0150 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0150, if 0x01ffc9a7 == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0114 stack[-1] } 0114 80 DUP1 0115 63 PUSH4 0x02fe5305 011A 14 EQ 011B 61 PUSH2 0x0185 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0185, if 0x02fe5305 == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x02fe5305 == stack[-1] // Inputs[1] { @011F stack[-1] } 011F 80 DUP1 0120 63 PUSH4 0x06fdde03 0125 14 EQ 0126 61 PUSH2 0x01a7 0129 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a7, if 0x06fdde03 == stack[-1] label_012A: // Incoming jump from 0x0129, if not 0x06fdde03 == stack[-1] // Inputs[1] { @012A stack[-1] } 012A 80 DUP1 012B 63 PUSH4 0x081812fc 0130 14 EQ 0131 61 PUSH2 0x01c9 0134 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c9, if 0x081812fc == stack[-1] label_0135: // Incoming jump from 0x0134, if not 0x081812fc == stack[-1] // Inputs[1] { @0135 stack[-1] } 0135 80 DUP1 0136 63 PUSH4 0x095ea7b3 013B 14 EQ 013C 61 PUSH2 0x0201 013F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0201, if 0x095ea7b3 == stack[-1] label_0140: // Incoming jump from 0x013F, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0140 stack[-1] } 0140 80 DUP1 0141 63 PUSH4 0x18160ddd 0146 14 EQ 0147 61 PUSH2 0x0221 014A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0221, if 0x18160ddd == stack[-1] label_014B: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x014A, if not 0x18160ddd == stack[-1] // Inputs[1] { @014F memory[0x00:0x00] } 014B 5B JUMPDEST 014C 60 PUSH1 0x00 014E 80 DUP1 014F FD *REVERT // Stack delta = +0 // Outputs[1] { @014F revert(memory[0x00:0x00]); } // Block terminates label_0150: // Incoming jump from 0x0113, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0151 msg.value } 0150 5B JUMPDEST 0151 34 CALLVALUE 0152 80 DUP1 0153 15 ISZERO 0154 61 PUSH2 0x015c 0157 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0151 stack[0] = msg.value } // Block ends with conditional jump to 0x015c, if !msg.value label_0158: // Incoming jump from 0x0157, if not !msg.value // Inputs[1] { @015B memory[0x00:0x00] } 0158 60 PUSH1 0x00 015A 80 DUP1 015B FD *REVERT // Stack delta = +0 // Outputs[1] { @015B revert(memory[0x00:0x00]); } // Block terminates label_015C: // Incoming jump from 0x0157, if !msg.value // Inputs[1] { @0164 msg.data.length } 015C 5B JUMPDEST 015D 50 POP 015E 61 PUSH2 0x0170 0161 61 PUSH2 0x016b 0164 36 CALLDATASIZE 0165 60 PUSH1 0x04 0167 61 PUSH2 0x1135 016A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @015E stack[-1] = 0x0170 // @0161 stack[0] = 0x016b // @0164 stack[1] = msg.data.length // @0165 stack[2] = 0x04 // } // Block ends with call to 0x1135, returns to 0x016B label_016B: // Incoming return from call to 0x1135 at 0x016A 016B 5B JUMPDEST 016C 61 PUSH2 0x04a1 016F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04a1 label_0170: // Incoming return from call to 0x016B at 0x016A // Incoming return from call to 0x041E at 0x041D // Inputs[2] // { // @0173 memory[0x40:0x60] // @0174 stack[-1] // } 0170 5B JUMPDEST 0171 60 PUSH1 0x40 0173 51 MLOAD 0174 90 SWAP1 0175 15 ISZERO 0176 15 ISZERO 0177 81 DUP2 0178 52 MSTORE 0179 60 PUSH1 0x20 017B 01 ADD // Stack delta = +0 // Outputs[2] // { // @0178 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @017B stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_017C: // Incoming jump from 0x0243 // Incoming jump from 0x02C7 // Incoming jump from 0x0200 // Incoming jump from 0x0243 // Incoming jump from 0x017B // Inputs[3] // { // @017F memory[0x40:0x60] // @0181 stack[-1] // @0184 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 017C 5B JUMPDEST 017D 60 PUSH1 0x40 017F 51 MLOAD 0180 80 DUP1 0181 91 SWAP2 0182 03 SUB 0183 90 SWAP1 0184 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0184 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0185: // Incoming jump from 0x011E, if 0x02fe5305 == stack[-1] // Inputs[1] { @0186 msg.value } 0185 5B JUMPDEST 0186 34 CALLVALUE 0187 80 DUP1 0188 15 ISZERO 0189 61 PUSH2 0x0191 018C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0186 stack[0] = msg.value } // Block ends with conditional jump to 0x0191, if !msg.value label_018D: // Incoming jump from 0x018C, if not !msg.value // Inputs[1] { @0190 memory[0x00:0x00] } 018D 60 PUSH1 0x00 018F 80 DUP1 0190 FD *REVERT // Stack delta = +0 // Outputs[1] { @0190 revert(memory[0x00:0x00]); } // Block terminates label_0191: // Incoming jump from 0x018C, if !msg.value // Inputs[1] { @0199 msg.data.length } 0191 5B JUMPDEST 0192 50 POP 0193 61 PUSH2 0x01a5 0196 61 PUSH2 0x01a0 0199 36 CALLDATASIZE 019A 60 PUSH1 0x04 019C 61 PUSH2 0x11de 019F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0193 stack[-1] = 0x01a5 // @0196 stack[0] = 0x01a0 // @0199 stack[1] = msg.data.length // @019A stack[2] = 0x04 // } // Block ends with call to 0x11de, returns to 0x01A0 label_01A0: // Incoming return from call to 0x11DE at 0x019F 01A0 5B JUMPDEST 01A1 61 PUSH2 0x04f3 01A4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04f3 label_01A5: // Incoming return from call to 0x039E at 0x039D // Incoming return from call to 0x027F at 0x027E // Incoming return from call to 0x025F at 0x025E // Incoming return from call to 0x0C79 at 0x0460 // Incoming return from call to 0x03FE at 0x03FD // Incoming return from call to 0x049C at 0x049B // Incoming return from call to 0x03BE at 0x03BD // Incoming return from call to 0x021C at 0x021B // Incoming return from call to 0x0338 at 0x0337 01A5 5B JUMPDEST 01A6 00 *STOP // Stack delta = +0 // Outputs[1] { @01A6 stop(); } // Block terminates label_01A7: // Incoming jump from 0x0129, if 0x06fdde03 == stack[-1] // Inputs[1] { @01A8 msg.value } 01A7 5B JUMPDEST 01A8 34 CALLVALUE 01A9 80 DUP1 01AA 15 ISZERO 01AB 61 PUSH2 0x01b3 01AE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01A8 stack[0] = msg.value } // Block ends with conditional jump to 0x01b3, if !msg.value label_01AF: // Incoming jump from 0x01AE, if not !msg.value // Inputs[1] { @01B2 memory[0x00:0x00] } 01AF 60 PUSH1 0x00 01B1 80 DUP1 01B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @01B2 revert(memory[0x00:0x00]); } // Block terminates label_01B3: // Incoming jump from 0x01AE, if !msg.value 01B3 5B JUMPDEST 01B4 50 POP 01B5 61 PUSH2 0x01bc 01B8 61 PUSH2 0x050b 01BB 56 *JUMP // Stack delta = +0 // Outputs[1] { @01B5 stack[-1] = 0x01bc } // Block ends with call to 0x050b, returns to 0x01BC label_01BC: // Incoming return from call to 0x050B at 0x01BB // Incoming return from call to 0x0965 at 0x036F // Inputs[2] // { // @01BF memory[0x40:0x60] // @01C3 stack[-1] // } 01BC 5B JUMPDEST 01BD 60 PUSH1 0x40 01BF 51 MLOAD 01C0 61 PUSH2 0x017c 01C3 91 SWAP2 01C4 90 SWAP1 01C5 61 PUSH2 0x127f 01C8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01C3 stack[-1] = 0x017c // @01C4 stack[1] = memory[0x40:0x60] // @01C4 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x127f label_01C9: // Incoming jump from 0x0134, if 0x081812fc == stack[-1] // Inputs[1] { @01CA msg.value } 01C9 5B JUMPDEST 01CA 34 CALLVALUE 01CB 80 DUP1 01CC 15 ISZERO 01CD 61 PUSH2 0x01d5 01D0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01CA stack[0] = msg.value } // Block ends with conditional jump to 0x01d5, if !msg.value label_01D1: // Incoming jump from 0x01D0, if not !msg.value // Inputs[1] { @01D4 memory[0x00:0x00] } 01D1 60 PUSH1 0x00 01D3 80 DUP1 01D4 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D4 revert(memory[0x00:0x00]); } // Block terminates label_01D5: // Incoming jump from 0x01D0, if !msg.value // Inputs[1] { @01DD msg.data.length } 01D5 5B JUMPDEST 01D6 50 POP 01D7 61 PUSH2 0x01e9 01DA 61 PUSH2 0x01e4 01DD 36 CALLDATASIZE 01DE 60 PUSH1 0x04 01E0 61 PUSH2 0x1292 01E3 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @01D7 stack[-1] = 0x01e9 // @01DA stack[0] = 0x01e4 // @01DD stack[1] = msg.data.length // @01DE stack[2] = 0x04 // } // Block ends with call to 0x1292, returns to 0x01E4 label_01E4: // Incoming return from call to 0x1292 at 0x01E3 01E4 5B JUMPDEST 01E5 61 PUSH2 0x059d 01E8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x059d label_01E9: // Incoming jump from 0x035A // Incoming return from call to 0x01E4 at 0x01E3 // Incoming return from call to 0x02E3 at 0x02E2 // Inputs[2] // { // @01EC memory[0x40:0x60] // @01F6 stack[-1] // } 01E9 5B JUMPDEST 01EA 60 PUSH1 0x40 01EC 51 MLOAD 01ED 60 PUSH1 0x01 01EF 60 PUSH1 0x01 01F1 60 PUSH1 0xa0 01F3 1B SHL 01F4 03 SUB 01F5 90 SWAP1 01F6 91 SWAP2 01F7 16 AND 01F8 81 DUP2 01F9 52 MSTORE 01FA 60 PUSH1 0x20 01FC 01 ADD 01FD 61 PUSH2 0x017c 0200 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01F9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @01FC stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x017c label_0201: // Incoming jump from 0x013F, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0202 msg.value } 0201 5B JUMPDEST 0202 34 CALLVALUE 0203 80 DUP1 0204 15 ISZERO 0205 61 PUSH2 0x020d 0208 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0202 stack[0] = msg.value } // Block ends with conditional jump to 0x020d, if !msg.value label_0209: // Incoming jump from 0x0208, if not !msg.value // Inputs[1] { @020C memory[0x00:0x00] } 0209 60 PUSH1 0x00 020B 80 DUP1 020C FD *REVERT // Stack delta = +0 // Outputs[1] { @020C revert(memory[0x00:0x00]); } // Block terminates label_020D: // Incoming jump from 0x0208, if !msg.value // Inputs[1] { @0215 msg.data.length } 020D 5B JUMPDEST 020E 50 POP 020F 61 PUSH2 0x01a5 0212 61 PUSH2 0x021c 0215 36 CALLDATASIZE 0216 60 PUSH1 0x04 0218 61 PUSH2 0x12c7 021B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @020F stack[-1] = 0x01a5 // @0212 stack[0] = 0x021c // @0215 stack[1] = msg.data.length // @0216 stack[2] = 0x04 // } // Block ends with call to 0x12c7, returns to 0x021C label_021C: // Incoming return from call to 0x12C7 at 0x021B 021C 5B JUMPDEST 021D 61 PUSH2 0x05e1 0220 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05e1 label_0221: // Incoming jump from 0x014A, if 0x18160ddd == stack[-1] // Inputs[1] { @0222 msg.value } 0221 5B JUMPDEST 0222 34 CALLVALUE 0223 80 DUP1 0224 15 ISZERO 0225 61 PUSH2 0x022d 0228 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0222 stack[0] = msg.value } // Block ends with conditional jump to 0x022d, if !msg.value label_0229: // Incoming jump from 0x0228, if not !msg.value // Inputs[1] { @022C memory[0x00:0x00] } 0229 60 PUSH1 0x00 022B 80 DUP1 022C FD *REVERT // Stack delta = +0 // Outputs[1] { @022C revert(memory[0x00:0x00]); } // Block terminates label_022D: // Incoming jump from 0x0228, if !msg.value // Inputs[3] // { // @0231 storage[0x01] // @0234 storage[0x00] // @0239 memory[0x40:0x60] // } 022D 5B JUMPDEST 022E 50 POP 022F 60 PUSH1 0x01 0231 54 SLOAD 0232 60 PUSH1 0x00 0234 54 SLOAD 0235 03 SUB 0236 5B JUMPDEST 0237 60 PUSH1 0x40 0239 51 MLOAD 023A 90 SWAP1 023B 81 DUP2 023C 52 MSTORE 023D 60 PUSH1 0x20 023F 01 ADD 0240 61 PUSH2 0x017c 0243 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @023C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x00] - storage[0x01] // @023F stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x017c label_0244: // Incoming jump from 0x00CC, if 0x23b872dd == stack[-1] // Inputs[1] { @0245 msg.value } 0244 5B JUMPDEST 0245 34 CALLVALUE 0246 80 DUP1 0247 15 ISZERO 0248 61 PUSH2 0x0250 024B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0245 stack[0] = msg.value } // Block ends with conditional jump to 0x0250, if !msg.value label_024C: // Incoming jump from 0x024B, if not !msg.value // Inputs[1] { @024F memory[0x00:0x00] } 024C 60 PUSH1 0x00 024E 80 DUP1 024F FD *REVERT // Stack delta = +0 // Outputs[1] { @024F revert(memory[0x00:0x00]); } // Block terminates label_0250: // Incoming jump from 0x024B, if !msg.value // Inputs[1] { @0258 msg.data.length } 0250 5B JUMPDEST 0251 50 POP 0252 61 PUSH2 0x01a5 0255 61 PUSH2 0x025f 0258 36 CALLDATASIZE 0259 60 PUSH1 0x04 025B 61 PUSH2 0x12f1 025E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0252 stack[-1] = 0x01a5 // @0255 stack[0] = 0x025f // @0258 stack[1] = msg.data.length // @0259 stack[2] = 0x04 // } // Block ends with call to 0x12f1, returns to 0x025F label_025F: // Incoming return from call to 0x12F1 at 0x025E 025F 5B JUMPDEST 0260 61 PUSH2 0x0681 0263 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0681 label_0264: // Incoming jump from 0x00D7, if 0x42842e0e == stack[-1] // Inputs[1] { @0265 msg.value } 0264 5B JUMPDEST 0265 34 CALLVALUE 0266 80 DUP1 0267 15 ISZERO 0268 61 PUSH2 0x0270 026B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0265 stack[0] = msg.value } // Block ends with conditional jump to 0x0270, if !msg.value label_026C: // Incoming jump from 0x026B, if not !msg.value // Inputs[1] { @026F memory[0x00:0x00] } 026C 60 PUSH1 0x00 026E 80 DUP1 026F FD *REVERT // Stack delta = +0 // Outputs[1] { @026F revert(memory[0x00:0x00]); } // Block terminates label_0270: // Incoming jump from 0x026B, if !msg.value // Inputs[1] { @0278 msg.data.length } 0270 5B JUMPDEST 0271 50 POP 0272 61 PUSH2 0x01a5 0275 61 PUSH2 0x027f 0278 36 CALLDATASIZE 0279 60 PUSH1 0x04 027B 61 PUSH2 0x12f1 027E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0272 stack[-1] = 0x01a5 // @0275 stack[0] = 0x027f // @0278 stack[1] = msg.data.length // @0279 stack[2] = 0x04 // } // Block ends with call to 0x12f1, returns to 0x027F label_027F: // Incoming return from call to 0x12F1 at 0x027E 027F 5B JUMPDEST 0280 61 PUSH2 0x081a 0283 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x081a label_0284: // Incoming jump from 0x00E2, if 0x5a9b0b89 == stack[-1] // Inputs[1] { @0285 msg.value } 0284 5B JUMPDEST 0285 34 CALLVALUE 0286 80 DUP1 0287 15 ISZERO 0288 61 PUSH2 0x0290 028B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0285 stack[0] = msg.value } // Block ends with conditional jump to 0x0290, if !msg.value label_028C: // Incoming jump from 0x028B, if not !msg.value // Inputs[1] { @028F memory[0x00:0x00] } 028C 60 PUSH1 0x00 028E 80 DUP1 028F FD *REVERT // Stack delta = +0 // Outputs[1] { @028F revert(memory[0x00:0x00]); } // Block terminates label_0290: // Incoming jump from 0x028B, if !msg.value // Inputs[6] // { // @0294 storage[0x09] // @0297 storage[0x0c] // @029A storage[0x0b] // @029D storage[0x0a] // @02A0 storage[0x0d] // @02A4 memory[0x40:0x60] // } 0290 5B JUMPDEST 0291 50 POP 0292 60 PUSH1 0x09 0294 54 SLOAD 0295 60 PUSH1 0x0c 0297 54 SLOAD 0298 60 PUSH1 0x0b 029A 54 SLOAD 029B 60 PUSH1 0x0a 029D 54 SLOAD 029E 60 PUSH1 0x0d 02A0 54 SLOAD 02A1 60 PUSH1 0x40 02A3 80 DUP1 02A4 51 MLOAD 02A5 95 SWAP6 02A6 86 DUP7 02A7 52 MSTORE 02A8 60 PUSH1 0x20 02AA 86 DUP7 02AB 01 ADD 02AC 94 SWAP5 02AD 90 SWAP1 02AE 94 SWAP5 02AF 52 MSTORE 02B0 92 SWAP3 02B1 84 DUP5 02B2 01 ADD 02B3 91 SWAP2 02B4 90 SWAP1 02B5 91 SWAP2 02B6 52 MSTORE 02B7 60 PUSH1 0x60 02B9 83 DUP4 02BA 01 ADD 02BB 52 MSTORE 02BC 60 PUSH1 0x80 02BE 82 DUP3 02BF 01 ADD 02C0 52 MSTORE 02C1 60 PUSH1 0xa0 02C3 01 ADD 02C4 61 PUSH2 0x017c 02C7 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @02A7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x09] // @02AF memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = storage[0x0c] // @02B6 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = storage[0x0b] // @02BB memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = storage[0x0a] // @02C0 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = storage[0x0d] // @02C3 stack[-1] = 0xa0 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x017c label_02C8: // Incoming jump from 0x00ED, if 0x6352211e == stack[-1] // Inputs[1] { @02C9 msg.value } 02C8 5B JUMPDEST 02C9 34 CALLVALUE 02CA 80 DUP1 02CB 15 ISZERO 02CC 61 PUSH2 0x02d4 02CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C9 stack[0] = msg.value } // Block ends with conditional jump to 0x02d4, if !msg.value label_02D0: // Incoming jump from 0x02CF, if not !msg.value // Inputs[1] { @02D3 memory[0x00:0x00] } 02D0 60 PUSH1 0x00 02D2 80 DUP1 02D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D3 revert(memory[0x00:0x00]); } // Block terminates label_02D4: // Incoming jump from 0x02CF, if !msg.value // Inputs[1] { @02DC msg.data.length } 02D4 5B JUMPDEST 02D5 50 POP 02D6 61 PUSH2 0x01e9 02D9 61 PUSH2 0x02e3 02DC 36 CALLDATASIZE 02DD 60 PUSH1 0x04 02DF 61 PUSH2 0x1292 02E2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02D6 stack[-1] = 0x01e9 // @02D9 stack[0] = 0x02e3 // @02DC stack[1] = msg.data.length // @02DD stack[2] = 0x04 // } // Block ends with call to 0x1292, returns to 0x02E3 label_02E3: // Incoming return from call to 0x1292 at 0x02E2 02E3 5B JUMPDEST 02E4 61 PUSH2 0x083a 02E7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x083a label_02E8: // Incoming jump from 0x00F8, if 0x70a08231 == stack[-1] // Inputs[1] { @02E9 msg.value } 02E8 5B JUMPDEST 02E9 34 CALLVALUE 02EA 80 DUP1 02EB 15 ISZERO 02EC 61 PUSH2 0x02f4 02EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02E9 stack[0] = msg.value } // Block ends with conditional jump to 0x02f4, if !msg.value label_02F0: // Incoming jump from 0x02EF, if not !msg.value // Inputs[1] { @02F3 memory[0x00:0x00] } 02F0 60 PUSH1 0x00 02F2 80 DUP1 02F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @02F3 revert(memory[0x00:0x00]); } // Block terminates label_02F4: // Incoming jump from 0x02EF, if !msg.value // Inputs[1] { @02FC msg.data.length } 02F4 5B JUMPDEST 02F5 50 POP 02F6 61 PUSH2 0x0236 02F9 61 PUSH2 0x0303 02FC 36 CALLDATASIZE 02FD 60 PUSH1 0x04 02FF 61 PUSH2 0x132d 0302 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02F6 stack[-1] = 0x0236 // @02F9 stack[0] = 0x0303 // @02FC stack[1] = msg.data.length // @02FD stack[2] = 0x04 // } // Block ends with call to 0x132d, returns to 0x0303 label_0303: // Incoming return from call to 0x132D at 0x0302 0303 5B JUMPDEST 0304 61 PUSH2 0x0845 0307 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0845 label_0308: // Incoming jump from 0x0103, if 0x715018a6 == stack[-1] // Inputs[1] { @0309 msg.value } 0308 5B JUMPDEST 0309 34 CALLVALUE 030A 80 DUP1 030B 15 ISZERO 030C 61 PUSH2 0x0314 030F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0309 stack[0] = msg.value } // Block ends with conditional jump to 0x0314, if !msg.value label_0310: // Incoming jump from 0x030F, if not !msg.value // Inputs[1] { @0313 memory[0x00:0x00] } 0310 60 PUSH1 0x00 0312 80 DUP1 0313 FD *REVERT // Stack delta = +0 // Outputs[1] { @0313 revert(memory[0x00:0x00]); } // Block terminates label_0314: // Incoming jump from 0x030F, if !msg.value 0314 5B JUMPDEST 0315 50 POP 0316 61 PUSH2 0x01a5 0319 61 PUSH2 0x0894 031C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0316 stack[-1] = 0x01a5 } // Block ends with unconditional jump to 0x0894 label_031D: // Incoming jump from 0x007A, if 0x729ad39e == stack[-1] // Inputs[1] { @031E msg.value } 031D 5B JUMPDEST 031E 34 CALLVALUE 031F 80 DUP1 0320 15 ISZERO 0321 61 PUSH2 0x0329 0324 57 *JUMPI // Stack delta = +1 // Outputs[1] { @031E stack[0] = msg.value } // Block ends with conditional jump to 0x0329, if !msg.value label_0325: // Incoming jump from 0x0324, if not !msg.value // Inputs[1] { @0328 memory[0x00:0x00] } 0325 60 PUSH1 0x00 0327 80 DUP1 0328 FD *REVERT // Stack delta = +0 // Outputs[1] { @0328 revert(memory[0x00:0x00]); } // Block terminates label_0329: // Incoming jump from 0x0324, if !msg.value // Inputs[1] { @0331 msg.data.length } 0329 5B JUMPDEST 032A 50 POP 032B 61 PUSH2 0x01a5 032E 61 PUSH2 0x0338 0331 36 CALLDATASIZE 0332 60 PUSH1 0x04 0334 61 PUSH2 0x1348 0337 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @032B stack[-1] = 0x01a5 // @032E stack[0] = 0x0338 // @0331 stack[1] = msg.data.length // @0332 stack[2] = 0x04 // } // Block ends with call to 0x1348, returns to 0x0338 label_0338: // Incoming return from call to 0x1348 at 0x0337 0338 5B JUMPDEST 0339 61 PUSH2 0x08a8 033C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08a8 label_033D: // Incoming jump from 0x0085, if 0x8da5cb5b == stack[-1] // Inputs[1] { @033E msg.value } 033D 5B JUMPDEST 033E 34 CALLVALUE 033F 80 DUP1 0340 15 ISZERO 0341 61 PUSH2 0x0349 0344 57 *JUMPI // Stack delta = +1 // Outputs[1] { @033E stack[0] = msg.value } // Block ends with conditional jump to 0x0349, if !msg.value label_0345: // Incoming jump from 0x0344, if not !msg.value // Inputs[1] { @0348 memory[0x00:0x00] } 0345 60 PUSH1 0x00 0347 80 DUP1 0348 FD *REVERT // Stack delta = +0 // Outputs[1] { @0348 revert(memory[0x00:0x00]); } // Block terminates label_0349: // Incoming jump from 0x0344, if !msg.value // Inputs[1] { @034D storage[0x08] } 0349 5B JUMPDEST 034A 50 POP 034B 60 PUSH1 0x08 034D 54 SLOAD 034E 60 PUSH1 0x01 0350 60 PUSH1 0x01 0352 60 PUSH1 0xa0 0354 1B SHL 0355 03 SUB 0356 16 AND 0357 61 PUSH2 0x01e9 035A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0356 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x08] } // Block ends with unconditional jump to 0x01e9 label_035B: // Incoming jump from 0x0090, if 0x95d89b41 == stack[-1] // Inputs[1] { @035C msg.value } 035B 5B JUMPDEST 035C 34 CALLVALUE 035D 80 DUP1 035E 15 ISZERO 035F 61 PUSH2 0x0367 0362 57 *JUMPI // Stack delta = +1 // Outputs[1] { @035C stack[0] = msg.value } // Block ends with conditional jump to 0x0367, if !msg.value label_0363: // Incoming jump from 0x0362, if not !msg.value // Inputs[1] { @0366 memory[0x00:0x00] } 0363 60 PUSH1 0x00 0365 80 DUP1 0366 FD *REVERT // Stack delta = +0 // Outputs[1] { @0366 revert(memory[0x00:0x00]); } // Block terminates label_0367: // Incoming jump from 0x0362, if !msg.value 0367 5B JUMPDEST 0368 50 POP 0369 61 PUSH2 0x01bc 036C 61 PUSH2 0x0965 036F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0369 stack[-1] = 0x01bc } // Block ends with call to 0x0965, returns to 0x01BC label_0370: // Incoming jump from 0x009B, if 0xa0712d68 == stack[-1] // Inputs[1] { @0377 msg.data.length } 0370 5B JUMPDEST 0371 61 PUSH2 0x01a5 0374 61 PUSH2 0x037e 0377 36 CALLDATASIZE 0378 60 PUSH1 0x04 037A 61 PUSH2 0x1292 037D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0371 stack[0] = 0x01a5 // @0374 stack[1] = 0x037e // @0377 stack[2] = msg.data.length // @0378 stack[3] = 0x04 // } // Block ends with call to 0x1292, returns to 0x037E label_037E: // Incoming return from call to 0x1292 at 0x037D 037E 5B JUMPDEST 037F 61 PUSH2 0x0974 0382 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0974 label_0383: // Incoming jump from 0x00A6, if 0xa22cb465 == stack[-1] // Inputs[1] { @0384 msg.value } 0383 5B JUMPDEST 0384 34 CALLVALUE 0385 80 DUP1 0386 15 ISZERO 0387 61 PUSH2 0x038f 038A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0384 stack[0] = msg.value } // Block ends with conditional jump to 0x038f, if !msg.value label_038B: // Incoming jump from 0x038A, if not !msg.value // Inputs[1] { @038E memory[0x00:0x00] } 038B 60 PUSH1 0x00 038D 80 DUP1 038E FD *REVERT // Stack delta = +0 // Outputs[1] { @038E revert(memory[0x00:0x00]); } // Block terminates label_038F: // Incoming jump from 0x038A, if !msg.value // Inputs[1] { @0397 msg.data.length } 038F 5B JUMPDEST 0390 50 POP 0391 61 PUSH2 0x01a5 0394 61 PUSH2 0x039e 0397 36 CALLDATASIZE 0398 60 PUSH1 0x04 039A 61 PUSH2 0x13bd 039D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0391 stack[-1] = 0x01a5 // @0394 stack[0] = 0x039e // @0397 stack[1] = msg.data.length // @0398 stack[2] = 0x04 // } // Block ends with call to 0x13bd, returns to 0x039E label_039E: // Incoming return from call to 0x13BD at 0x039D 039E 5B JUMPDEST 039F 61 PUSH2 0x0aa5 03A2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0aa5 label_03A3: // Incoming jump from 0x00B1, if 0xb88d4fde == stack[-1] // Inputs[1] { @03A4 msg.value } 03A3 5B JUMPDEST 03A4 34 CALLVALUE 03A5 80 DUP1 03A6 15 ISZERO 03A7 61 PUSH2 0x03af 03AA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03A4 stack[0] = msg.value } // Block ends with conditional jump to 0x03af, if !msg.value label_03AB: // Incoming jump from 0x03AA, if not !msg.value // Inputs[1] { @03AE memory[0x00:0x00] } 03AB 60 PUSH1 0x00 03AD 80 DUP1 03AE FD *REVERT // Stack delta = +0 // Outputs[1] { @03AE revert(memory[0x00:0x00]); } // Block terminates label_03AF: // Incoming jump from 0x03AA, if !msg.value // Inputs[1] { @03B7 msg.data.length } 03AF 5B JUMPDEST 03B0 50 POP 03B1 61 PUSH2 0x01a5 03B4 61 PUSH2 0x03be 03B7 36 CALLDATASIZE 03B8 60 PUSH1 0x04 03BA 61 PUSH2 0x13f9 03BD 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03B1 stack[-1] = 0x01a5 // @03B4 stack[0] = 0x03be // @03B7 stack[1] = msg.data.length // @03B8 stack[2] = 0x04 // } // Block ends with call to 0x13f9, returns to 0x03BE label_03BE: // Incoming return from call to 0x13F9 at 0x03BD 03BE 5B JUMPDEST 03BF 61 PUSH2 0x0b3a 03C2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b3a label_03C3: // Incoming jump from 0x0033, if 0xc87b56dd == stack[-1] // Inputs[1] { @03C4 msg.value } 03C3 5B JUMPDEST 03C4 34 CALLVALUE 03C5 80 DUP1 03C6 15 ISZERO 03C7 61 PUSH2 0x03cf 03CA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C4 stack[0] = msg.value } // Block ends with conditional jump to 0x03cf, if !msg.value label_03CB: // Incoming jump from 0x03CA, if not !msg.value // Inputs[1] { @03CE memory[0x00:0x00] } 03CB 60 PUSH1 0x00 03CD 80 DUP1 03CE FD *REVERT // Stack delta = +0 // Outputs[1] { @03CE revert(memory[0x00:0x00]); } // Block terminates label_03CF: // Incoming jump from 0x03CA, if !msg.value // Inputs[1] { @03D7 msg.data.length } 03CF 5B JUMPDEST 03D0 50 POP 03D1 61 PUSH2 0x01bc 03D4 61 PUSH2 0x03de 03D7 36 CALLDATASIZE 03D8 60 PUSH1 0x04 03DA 61 PUSH2 0x1292 03DD 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03D1 stack[-1] = 0x01bc // @03D4 stack[0] = 0x03de // @03D7 stack[1] = msg.data.length // @03D8 stack[2] = 0x04 // } // Block ends with call to 0x1292, returns to 0x03DE label_03DE: // Incoming return from call to 0x1292 at 0x03DD 03DE 5B JUMPDEST 03DF 61 PUSH2 0x0b84 03E2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b84 label_03E3: // Incoming jump from 0x003E, if 0xd0679d34 == stack[-1] // Inputs[1] { @03E4 msg.value } 03E3 5B JUMPDEST 03E4 34 CALLVALUE 03E5 80 DUP1 03E6 15 ISZERO 03E7 61 PUSH2 0x03ef 03EA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E4 stack[0] = msg.value } // Block ends with conditional jump to 0x03ef, if !msg.value label_03EB: // Incoming jump from 0x03EA, if not !msg.value // Inputs[1] { @03EE memory[0x00:0x00] } 03EB 60 PUSH1 0x00 03ED 80 DUP1 03EE FD *REVERT // Stack delta = +0 // Outputs[1] { @03EE revert(memory[0x00:0x00]); } // Block terminates label_03EF: // Incoming jump from 0x03EA, if !msg.value // Inputs[1] { @03F7 msg.data.length } 03EF 5B JUMPDEST 03F0 50 POP 03F1 61 PUSH2 0x01a5 03F4 61 PUSH2 0x03fe 03F7 36 CALLDATASIZE 03F8 60 PUSH1 0x04 03FA 61 PUSH2 0x12c7 03FD 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03F1 stack[-1] = 0x01a5 // @03F4 stack[0] = 0x03fe // @03F7 stack[1] = msg.data.length // @03F8 stack[2] = 0x04 // } // Block ends with call to 0x12c7, returns to 0x03FE label_03FE: // Incoming return from call to 0x12C7 at 0x03FD 03FE 5B JUMPDEST 03FF 61 PUSH2 0x0c08 0402 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c08 label_0403: // Incoming jump from 0x0049, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0404 msg.value } 0403 5B JUMPDEST 0404 34 CALLVALUE 0405 80 DUP1 0406 15 ISZERO 0407 61 PUSH2 0x040f 040A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0404 stack[0] = msg.value } // Block ends with conditional jump to 0x040f, if !msg.value label_040B: // Incoming jump from 0x040A, if not !msg.value // Inputs[1] { @040E memory[0x00:0x00] } 040B 60 PUSH1 0x00 040D 80 DUP1 040E FD *REVERT // Stack delta = +0 // Outputs[1] { @040E revert(memory[0x00:0x00]); } // Block terminates label_040F: // Incoming jump from 0x040A, if !msg.value // Inputs[1] { @0417 msg.data.length } 040F 5B JUMPDEST 0410 50 POP 0411 61 PUSH2 0x0170 0414 61 PUSH2 0x041e 0417 36 CALLDATASIZE 0418 60 PUSH1 0x04 041A 61 PUSH2 0x1475 041D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0411 stack[-1] = 0x0170 // @0414 stack[0] = 0x041e // @0417 stack[1] = msg.data.length // @0418 stack[2] = 0x04 // } // Block ends with call to 0x1475, returns to 0x041E label_041E: // Incoming call from 0x0607, returns to 0x0608 // Incoming call from 0x06EE, returns to 0x06EF // Incoming return from call to 0x1475 at 0x041D // Inputs[6] // { // @0427 stack[-2] // @043A memory[0x00:0x40] // @043B stack[-1] // @0445 memory[0x00:0x40] // @0446 storage[keccak256(memory[0x00:0x40])] // @044A stack[-3] // } 041E 5B JUMPDEST 041F 60 PUSH1 0x01 0421 60 PUSH1 0x01 0423 60 PUSH1 0xa0 0425 1B SHL 0426 03 SUB 0427 91 SWAP2 0428 82 DUP3 0429 16 AND 042A 60 PUSH1 0x00 042C 90 SWAP1 042D 81 DUP2 042E 52 MSTORE 042F 60 PUSH1 0x07 0431 60 PUSH1 0x20 0433 90 SWAP1 0434 81 DUP2 0435 52 MSTORE 0436 60 PUSH1 0x40 0438 80 DUP1 0439 83 DUP4 043A 20 SHA3 043B 93 SWAP4 043C 90 SWAP1 043D 94 SWAP5 043E 16 AND 043F 82 DUP3 0440 52 MSTORE 0441 91 SWAP2 0442 90 SWAP1 0443 91 SWAP2 0444 52 MSTORE 0445 20 SHA3 0446 54 SLOAD 0447 60 PUSH1 0xff 0449 16 AND 044A 90 SWAP1 044B 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @042E memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0435 memory[0x20:0x40] = 0x07 // @0440 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0444 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @044A stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_044C: // Incoming jump from 0x0054, if 0xea105ac7 == stack[-1] // Inputs[1] { @044D msg.value } 044C 5B JUMPDEST 044D 34 CALLVALUE 044E 80 DUP1 044F 15 ISZERO 0450 61 PUSH2 0x0458 0453 57 *JUMPI // Stack delta = +1 // Outputs[1] { @044D stack[0] = msg.value } // Block ends with conditional jump to 0x0458, if !msg.value label_0454: // Incoming jump from 0x0453, if not !msg.value // Inputs[1] { @0457 memory[0x00:0x00] } 0454 60 PUSH1 0x00 0456 80 DUP1 0457 FD *REVERT // Stack delta = +0 // Outputs[1] { @0457 revert(memory[0x00:0x00]); } // Block terminates label_0458: // Incoming jump from 0x0453, if !msg.value 0458 5B JUMPDEST 0459 50 POP 045A 61 PUSH2 0x01a5 045D 61 PUSH2 0x0c79 0460 56 *JUMP // Stack delta = +0 // Outputs[1] { @045A stack[-1] = 0x01a5 } // Block ends with call to 0x0c79, returns to 0x01A5 label_0461: // Incoming jump from 0x005F, if 0xf2fde38b == stack[-1] // Inputs[1] { @0462 msg.value } 0461 5B JUMPDEST 0462 34 CALLVALUE 0463 80 DUP1 0464 15 ISZERO 0465 61 PUSH2 0x046d 0468 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0462 stack[0] = msg.value } // Block ends with conditional jump to 0x046d, if !msg.value label_0469: // Incoming jump from 0x0468, if not !msg.value // Inputs[1] { @046C memory[0x00:0x00] } 0469 60 PUSH1 0x00 046B 80 DUP1 046C FD *REVERT // Stack delta = +0 // Outputs[1] { @046C revert(memory[0x00:0x00]); } // Block terminates label_046D: // Incoming jump from 0x0468, if !msg.value // Inputs[1] { @0475 msg.data.length } 046D 5B JUMPDEST 046E 50 POP 046F 61 PUSH2 0x01a5 0472 61 PUSH2 0x047c 0475 36 CALLDATASIZE 0476 60 PUSH1 0x04 0478 61 PUSH2 0x132d 047B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @046F stack[-1] = 0x01a5 // @0472 stack[0] = 0x047c // @0475 stack[1] = msg.data.length // @0476 stack[2] = 0x04 // } // Block ends with call to 0x132d, returns to 0x047C label_047C: // Incoming return from call to 0x132D at 0x047B 047C 5B JUMPDEST 047D 61 PUSH2 0x0cc6 0480 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cc6 label_0481: // Incoming jump from 0x006A, if 0xf3fef3a3 == stack[-1] // Inputs[1] { @0482 msg.value } 0481 5B JUMPDEST 0482 34 CALLVALUE 0483 80 DUP1 0484 15 ISZERO 0485 61 PUSH2 0x048d 0488 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0482 stack[0] = msg.value } // Block ends with conditional jump to 0x048d, if !msg.value label_0489: // Incoming jump from 0x0488, if not !msg.value // Inputs[1] { @048C memory[0x00:0x00] } 0489 60 PUSH1 0x00 048B 80 DUP1 048C FD *REVERT // Stack delta = +0 // Outputs[1] { @048C revert(memory[0x00:0x00]); } // Block terminates label_048D: // Incoming jump from 0x0488, if !msg.value // Inputs[1] { @0495 msg.data.length } 048D 5B JUMPDEST 048E 50 POP 048F 61 PUSH2 0x01a5 0492 61 PUSH2 0x049c 0495 36 CALLDATASIZE 0496 60 PUSH1 0x04 0498 61 PUSH2 0x12c7 049B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @048F stack[-1] = 0x01a5 // @0492 stack[0] = 0x049c // @0495 stack[1] = msg.data.length // @0496 stack[2] = 0x04 // } // Block ends with call to 0x12c7, returns to 0x049C label_049C: // Incoming return from call to 0x12C7 at 0x049B 049C 5B JUMPDEST 049D 61 PUSH2 0x0d3c 04A0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d3c label_04A1: // Incoming jump from 0x016F // Inputs[1] { @04B5 stack[-1] } 04A1 5B JUMPDEST 04A2 60 PUSH1 0x00 04A4 63 PUSH4 0x01ffc9a7 04A9 60 PUSH1 0xe0 04AB 1B SHL 04AC 60 PUSH1 0x01 04AE 60 PUSH1 0x01 04B0 60 PUSH1 0xe0 04B2 1B SHL 04B3 03 SUB 04B4 19 NOT 04B5 83 DUP4 04B6 16 AND 04B7 14 EQ 04B8 80 DUP1 04B9 61 PUSH2 0x04d2 04BC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @04A2 stack[0] = 0x00 // @04B7 stack[1] = stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // } // Block ends with conditional jump to 0x04d2, if stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 label_04BD: // Incoming jump from 0x04BC, if not stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // Inputs[1] { @04CF stack[-3] } 04BD 50 POP 04BE 63 PUSH4 0x80ac58cd 04C3 60 PUSH1 0xe0 04C5 1B SHL 04C6 60 PUSH1 0x01 04C8 60 PUSH1 0x01 04CA 60 PUSH1 0xe0 04CC 1B SHL 04CD 03 SUB 04CE 19 NOT 04CF 83 DUP4 04D0 16 AND 04D1 14 EQ 04D2 5B JUMPDEST 04D3 80 DUP1 04D4 61 PUSH2 0x04ed 04D7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @04D1 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 } // Block ends with conditional jump to 0x04ed, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 label_04D8: // Incoming jump from 0x04D7, if not stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Incoming jump from 0x04D7, if not stack[-1] // Inputs[1] { @04EA stack[-3] } 04D8 50 POP 04D9 63 PUSH4 0x5b5e139f 04DE 60 PUSH1 0xe0 04E0 1B SHL 04E1 60 PUSH1 0x01 04E3 60 PUSH1 0x01 04E5 60 PUSH1 0xe0 04E7 1B SHL 04E8 03 SUB 04E9 19 NOT 04EA 83 DUP4 04EB 16 AND 04EC 14 EQ // Stack delta = +0 // Outputs[1] { @04EC stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x5b5e139f << 0xe0 } // Block continues label_04ED: // Incoming jump from 0x04D7, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Incoming jump from 0x0E21, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x04D7, if stack[-1] // Incoming jump from 0x04EC // Incoming return from call to 0x0E3C at 0x0844 // Inputs[3] // { // @04EE stack[-4] // @04EE stack[-1] // @04EF stack[-3] // } 04ED 5B JUMPDEST 04EE 92 SWAP3 04EF 91 SWAP2 04F0 50 POP 04F1 50 POP 04F2 56 *JUMP // Stack delta = -3 // Outputs[1] { @04EE stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_04F3: // Incoming jump from 0x01A4 04F3 5B JUMPDEST 04F4 61 PUSH2 0x04fb 04F7 61 PUSH2 0x0dbb 04FA 56 *JUMP // Stack delta = +1 // Outputs[1] { @04F4 stack[0] = 0x04fb } // Block ends with call to 0x0dbb, returns to 0x04FB label_04FB: // Incoming return from call to 0x0DBB at 0x04FA // Inputs[1] { @0501 stack[-1] } 04FB 5B JUMPDEST 04FC 60 PUSH1 0x0e 04FE 61 PUSH2 0x0507 0501 82 DUP3 0502 82 DUP3 0503 61 PUSH2 0x1528 0506 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04FC stack[0] = 0x0e // @04FE stack[1] = 0x0507 // @0501 stack[2] = stack[-1] // @0502 stack[3] = 0x0e // } // Block ends with call to 0x1528, returns to 0x0507 label_0507: // Incoming return from call to 0x0EF5 at 0x0C78 // Incoming return from call to 0x1528 at 0x0506 // Inputs[1] { @050A stack[-3] } 0507 5B JUMPDEST 0508 50 POP 0509 50 POP 050A 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_050B: // Incoming call from 0x01BB, returns to 0x01BC // Inputs[1] { @0511 storage[0x02] } 050B 5B JUMPDEST 050C 60 PUSH1 0x60 050E 60 PUSH1 0x02 0510 80 DUP1 0511 54 SLOAD 0512 61 PUSH2 0x051a 0515 90 SWAP1 0516 61 PUSH2 0x14a8 0519 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @050C stack[0] = 0x60 // @050E stack[1] = 0x02 // @0515 stack[2] = 0x051a // @0515 stack[3] = storage[0x02] // } // Block ends with call to 0x14a8, returns to 0x051A label_051A: // Incoming return from call to 0x14A8 at 0x10CF // Incoming return from call to 0x14A8 at 0x0519 // Incoming return from call to 0x14A8 at 0x0973 // Inputs[4] // { // @051B stack[-1] // @052A memory[0x40:0x60] // @0532 stack[-2] // @053D storage[stack[-2]] // } 051A 5B JUMPDEST 051B 80 DUP1 051C 60 PUSH1 0x1f 051E 01 ADD 051F 60 PUSH1 0x20 0521 80 DUP1 0522 91 SWAP2 0523 04 DIV 0524 02 MUL 0525 60 PUSH1 0x20 0527 01 ADD 0528 60 PUSH1 0x40 052A 51 MLOAD 052B 90 SWAP1 052C 81 DUP2 052D 01 ADD 052E 60 PUSH1 0x40 0530 52 MSTORE 0531 80 DUP1 0532 92 SWAP3 0533 91 SWAP2 0534 90 SWAP1 0535 81 DUP2 0536 81 DUP2 0537 52 MSTORE 0538 60 PUSH1 0x20 053A 01 ADD 053B 82 DUP3 053C 80 DUP1 053D 54 SLOAD 053E 61 PUSH2 0x0546 0541 90 SWAP1 0542 61 PUSH2 0x14a8 0545 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0530 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0532 stack[-2] = memory[0x40:0x60] // @0533 stack[-1] = stack[-2] // @0534 stack[0] = stack[-1] // @0537 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @053A stack[1] = 0x20 + memory[0x40:0x60] // @053B stack[2] = stack[-2] // @0541 stack[4] = storage[stack[-2]] // @0541 stack[3] = 0x0546 // } // Block ends with call to 0x14a8, returns to 0x0546 label_0546: // Incoming return from call to 0x14A8 at 0x0545 // Inputs[1] { @0547 stack[-1] } 0546 5B JUMPDEST 0547 80 DUP1 0548 15 ISZERO 0549 61 PUSH2 0x0593 054C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0593, if !stack[-1] label_054D: // Incoming jump from 0x054C, if not !stack[-1] // Inputs[1] { @054D stack[-1] } 054D 80 DUP1 054E 60 PUSH1 0x1f 0550 10 LT 0551 61 PUSH2 0x0568 0554 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0568, if 0x1f < stack[-1] label_0555: // Incoming jump from 0x0554, if not 0x1f < stack[-1] // Inputs[4] // { // @0559 stack[-2] // @055A storage[stack[-2]] // @055D stack[-3] // @055F stack[-1] // } 0555 61 PUSH2 0x0100 0558 80 DUP1 0559 83 DUP4 055A 54 SLOAD 055B 04 DIV 055C 02 MUL 055D 83 DUP4 055E 52 MSTORE 055F 91 SWAP2 0560 60 PUSH1 0x20 0562 01 ADD 0563 91 SWAP2 0564 61 PUSH2 0x0593 0567 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @055E memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0563 stack[-1] = stack[-1] // @0563 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0593 label_0568: // Incoming jump from 0x0554, if 0x1f < stack[-1] // Inputs[5] // { // @0569 stack[-3] // @056A stack[-1] // @056C stack[-2] // @0574 memory[0x00:0x20] // @0578 storage[keccak256(memory[0x00:0x20])] // } 0568 5B JUMPDEST 0569 82 DUP3 056A 01 ADD 056B 91 SWAP2 056C 90 SWAP1 056D 60 PUSH1 0x00 056F 52 MSTORE 0570 60 PUSH1 0x20 0572 60 PUSH1 0x00 0574 20 SHA3 0575 90 SWAP1 0576 5B JUMPDEST 0577 81 DUP2 0578 54 SLOAD 0579 81 DUP2 057A 52 MSTORE 057B 90 SWAP1 057C 60 PUSH1 0x01 057E 01 ADD 057F 90 SWAP1 0580 60 PUSH1 0x20 0582 01 ADD 0583 80 DUP1 0584 83 DUP4 0585 11 GT 0586 61 PUSH2 0x0576 0589 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @056B stack[-3] = stack[-3] + stack[-1] // @056F memory[0x00:0x20] = stack[-2] // @057A memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @057F stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0582 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0576, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_058A: // Incoming jump from 0x0589, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0589, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @058A stack[-3] // @058B stack[-1] // } 058A 82 DUP3 058B 90 SWAP1 058C 03 SUB 058D 60 PUSH1 0x1f 058F 16 AND 0590 82 DUP3 0591 01 ADD 0592 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0592 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0592 stack[-1] = stack[-3] // } // Block continues label_0593: // Incoming jump from 0x054C, if !stack[-1] // Incoming jump from 0x0567 // Incoming jump from 0x0592 // Inputs[3] // { // @0599 stack[-7] // @0599 stack[-6] // @059B stack[-8] // } 0593 5B JUMPDEST 0594 50 POP 0595 50 POP 0596 50 POP 0597 50 POP 0598 50 POP 0599 90 SWAP1 059A 50 POP 059B 90 SWAP1 059C 56 *JUMP // Stack delta = -7 // Outputs[1] { @059B stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_059D: // Incoming jump from 0x01E8 // Inputs[1] { @05A3 stack[-1] } 059D 5B JUMPDEST 059E 60 PUSH1 0x00 05A0 61 PUSH2 0x05a8 05A3 82 DUP3 05A4 61 PUSH2 0x0e15 05A7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @059E stack[0] = 0x00 // @05A0 stack[1] = 0x05a8 // @05A3 stack[2] = stack[-1] // } // Block ends with call to 0x0e15, returns to 0x05A8 label_05A8: // Incoming return from call to 0x0E15 at 0x05A7 // Inputs[1] { @05AC stack[-1] } 05A8 5B JUMPDEST 05A9 61 PUSH2 0x05c5 05AC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x05c5, if stack[-1] label_05AD: // Incoming jump from 0x05AC, if not stack[-1] // Inputs[3] // { // @05AF memory[0x40:0x60] // @05BF memory[0x40:0x60] // @05C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05AD 60 PUSH1 0x40 05AF 51 MLOAD 05B0 63 PUSH4 0x33d1c039 05B5 60 PUSH1 0xe2 05B7 1B SHL 05B8 81 DUP2 05B9 52 MSTORE 05BA 60 PUSH1 0x04 05BC 01 ADD 05BD 60 PUSH1 0x40 05BF 51 MLOAD 05C0 80 DUP1 05C1 91 SWAP2 05C2 03 SUB 05C3 90 SWAP1 05C4 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @05B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x33d1c039 << 0xe2 // @05C4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_05C5: // Incoming jump from 0x05AC, if stack[-1] // Inputs[4] // { // @05C9 stack[-2] // @05D4 memory[0x00:0x40] // @05D5 storage[keccak256(memory[0x00:0x40])] // @05DF stack[-3] // } 05C5 5B JUMPDEST 05C6 50 POP 05C7 60 PUSH1 0x00 05C9 90 SWAP1 05CA 81 DUP2 05CB 52 MSTORE 05CC 60 PUSH1 0x06 05CE 60 PUSH1 0x20 05D0 52 MSTORE 05D1 60 PUSH1 0x40 05D3 90 SWAP1 05D4 20 SHA3 05D5 54 SLOAD 05D6 60 PUSH1 0x01 05D8 60 PUSH1 0x01 05DA 60 PUSH1 0xa0 05DC 1B SHL 05DD 03 SUB 05DE 16 AND 05DF 90 SWAP1 05E0 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @05CB memory[0x00:0x20] = stack[-2] // @05D0 memory[0x20:0x40] = 0x06 // @05DF stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_05E1: // Incoming jump from 0x0220 // Inputs[1] { @05E7 stack[-1] } 05E1 5B JUMPDEST 05E2 60 PUSH1 0x00 05E4 61 PUSH2 0x05ec 05E7 82 DUP3 05E8 61 PUSH2 0x083a 05EB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @05E2 stack[0] = 0x00 // @05E4 stack[1] = 0x05ec // @05E7 stack[2] = stack[-1] // } // Block ends with call to 0x083a, returns to 0x05EC label_05EC: // Incoming return from call to 0x083A at 0x05EB // Inputs[3] // { // @05ED stack[-2] // @05ED stack[-1] // @05EF msg.sender // } 05EC 5B JUMPDEST 05ED 90 SWAP1 05EE 50 POP 05EF 33 CALLER 05F0 60 PUSH1 0x01 05F2 60 PUSH1 0x01 05F4 60 PUSH1 0xa0 05F6 1B SHL 05F7 03 SUB 05F8 82 DUP3 05F9 16 AND 05FA 14 EQ 05FB 61 PUSH2 0x0625 05FE 57 *JUMPI // Stack delta = -1 // Outputs[1] { @05ED stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0625, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_05FF: // Incoming jump from 0x05FE, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0602 stack[-1] // @0603 msg.sender // } 05FF 61 PUSH2 0x0608 0602 81 DUP2 0603 33 CALLER 0604 61 PUSH2 0x041e 0607 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @05FF stack[0] = 0x0608 // @0602 stack[1] = stack[-1] // @0603 stack[2] = msg.sender // } // Block ends with call to 0x041e, returns to 0x0608 label_0608: // Incoming return from call to 0x041E at 0x0607 // Inputs[1] { @060C stack[-1] } 0608 5B JUMPDEST 0609 61 PUSH2 0x0625 060C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0625, if stack[-1] label_060D: // Incoming jump from 0x060C, if not stack[-1] // Inputs[3] // { // @060F memory[0x40:0x60] // @061F memory[0x40:0x60] // @0624 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 060D 60 PUSH1 0x40 060F 51 MLOAD 0610 63 PUSH4 0x67d9dca1 0615 60 PUSH1 0xe1 0617 1B SHL 0618 81 DUP2 0619 52 MSTORE 061A 60 PUSH1 0x04 061C 01 ADD 061D 60 PUSH1 0x40 061F 51 MLOAD 0620 80 DUP1 0621 91 SWAP2 0622 03 SUB 0623 90 SWAP1 0624 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0619 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x67d9dca1 << 0xe1 // @0624 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0625: // Incoming jump from 0x05FE, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming jump from 0x060C, if stack[-1] // Inputs[8] // { // @0628 stack[-2] // @0634 memory[0x00:0x40] // @0636 storage[keccak256(memory[0x00:0x40])] // @0649 stack[-3] // @0653 memory[0x40:0x60] // @0657 stack[-1] // @067C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0680 stack[-4] // } 0625 5B JUMPDEST 0626 60 PUSH1 0x00 0628 82 DUP3 0629 81 DUP2 062A 52 MSTORE 062B 60 PUSH1 0x06 062D 60 PUSH1 0x20 062F 52 MSTORE 0630 60 PUSH1 0x40 0632 80 DUP1 0633 82 DUP3 0634 20 SHA3 0635 80 DUP1 0636 54 SLOAD 0637 60 PUSH1 0x01 0639 60 PUSH1 0x01 063B 60 PUSH1 0xa0 063D 1B SHL 063E 03 SUB 063F 19 NOT 0640 16 AND 0641 60 PUSH1 0x01 0643 60 PUSH1 0x01 0645 60 PUSH1 0xa0 0647 1B SHL 0648 03 SUB 0649 87 DUP8 064A 81 DUP2 064B 16 AND 064C 91 SWAP2 064D 82 DUP3 064E 17 OR 064F 90 SWAP1 0650 92 SWAP3 0651 55 SSTORE 0652 91 SWAP2 0653 51 MLOAD 0654 85 DUP6 0655 93 SWAP4 0656 91 SWAP2 0657 85 DUP6 0658 16 AND 0659 91 SWAP2 065A 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 067B 91 SWAP2 067C A4 LOG4 067D 50 POP 067E 50 POP 067F 50 POP 0680 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @062A memory[0x00:0x20] = stack[-2] // @062F memory[0x20:0x40] = 0x06 // @0651 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @067C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_0681: // Incoming call from 0x0B44, returns to 0x0B45 // Incoming jump from 0x0263 // Inputs[1] { @0687 stack[-1] } 0681 5B JUMPDEST 0682 60 PUSH1 0x00 0684 61 PUSH2 0x068c 0687 82 DUP3 0688 61 PUSH2 0x0e3c 068B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0682 stack[0] = 0x00 // @0684 stack[1] = 0x068c // @0687 stack[2] = stack[-1] // } // Block ends with call to 0x0e3c, returns to 0x068C label_068C: // Incoming return from call to 0x0E3C at 0x068B // Inputs[3] // { // @068D stack[-1] // @068D stack[-2] // @068F stack[-5] // } 068C 5B JUMPDEST 068D 90 SWAP1 068E 50 POP 068F 83 DUP4 0690 60 PUSH1 0x01 0692 60 PUSH1 0x01 0694 60 PUSH1 0xa0 0696 1B SHL 0697 03 SUB 0698 16 AND 0699 81 DUP2 069A 60 PUSH1 0x01 069C 60 PUSH1 0x01 069E 60 PUSH1 0xa0 06A0 1B SHL 06A1 03 SUB 06A2 16 AND 06A3 14 EQ 06A4 61 PUSH2 0x06bf 06A7 57 *JUMPI // Stack delta = -1 // Outputs[1] { @068D stack[-2] = stack[-1] } // Block ends with conditional jump to 0x06bf, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] label_06A8: // Incoming jump from 0x06A7, if not (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @06AA memory[0x40:0x60] // @06B9 memory[0x40:0x60] // @06BE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 06A8 60 PUSH1 0x40 06AA 51 MLOAD 06AB 62 PUSH3 0xa11481 06AF 60 PUSH1 0xe8 06B1 1B SHL 06B2 81 DUP2 06B3 52 MSTORE 06B4 60 PUSH1 0x04 06B6 01 ADD 06B7 60 PUSH1 0x40 06B9 51 MLOAD 06BA 80 DUP1 06BB 91 SWAP2 06BC 03 SUB 06BD 90 SWAP1 06BE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @06B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa11481 << 0xe8 // @06BE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_06BF: // Incoming jump from 0x06A7, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[5] // { // @06C2 stack[-2] // @06CD memory[0x00:0x40] // @06CF storage[keccak256(memory[0x00:0x40])] // @06D0 msg.sender // @06DC stack[-4] // } 06BF 5B JUMPDEST 06C0 60 PUSH1 0x00 06C2 82 DUP3 06C3 81 DUP2 06C4 52 MSTORE 06C5 60 PUSH1 0x06 06C7 60 PUSH1 0x20 06C9 52 MSTORE 06CA 60 PUSH1 0x40 06CC 90 SWAP1 06CD 20 SHA3 06CE 80 DUP1 06CF 54 SLOAD 06D0 33 CALLER 06D1 80 DUP1 06D2 82 DUP3 06D3 14 EQ 06D4 60 PUSH1 0x01 06D6 60 PUSH1 0x01 06D8 60 PUSH1 0xa0 06DA 1B SHL 06DB 03 SUB 06DC 88 DUP9 06DD 16 AND 06DE 90 SWAP1 06DF 91 SWAP2 06E0 14 EQ 06E1 17 OR 06E2 61 PUSH2 0x070c 06E5 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @06C4 memory[0x00:0x20] = stack[-2] // @06C9 memory[0x20:0x40] = 0x06 // @06CD stack[0] = keccak256(memory[0x00:0x40]) // @06CF stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x070c, if (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) label_06E6: // Incoming jump from 0x06E5, if not (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Inputs[2] // { // @06E9 stack[-6] // @06EA msg.sender // } 06E6 61 PUSH2 0x06ef 06E9 86 DUP7 06EA 33 CALLER 06EB 61 PUSH2 0x041e 06EE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06E6 stack[0] = 0x06ef // @06E9 stack[1] = stack[-6] // @06EA stack[2] = msg.sender // } // Block ends with call to 0x041e, returns to 0x06EF label_06EF: // Incoming return from call to 0x041E at 0x06EE // Inputs[1] { @06F3 stack[-1] } 06EF 5B JUMPDEST 06F0 61 PUSH2 0x070c 06F3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x070c, if stack[-1] label_06F4: // Incoming jump from 0x06F3, if not stack[-1] // Inputs[3] // { // @06F6 memory[0x40:0x60] // @0706 memory[0x40:0x60] // @070B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 06F4 60 PUSH1 0x40 06F6 51 MLOAD 06F7 63 PUSH4 0x2ce44b5f 06FC 60 PUSH1 0xe1 06FE 1B SHL 06FF 81 DUP2 0700 52 MSTORE 0701 60 PUSH1 0x04 0703 01 ADD 0704 60 PUSH1 0x40 0706 51 MLOAD 0707 80 DUP1 0708 91 SWAP2 0709 03 SUB 070A 90 SWAP1 070B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0700 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @070B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_070C: // Incoming jump from 0x06F3, if stack[-1] // Incoming jump from 0x06E5, if (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Inputs[1] { @0715 stack[-5] } 070C 5B JUMPDEST 070D 60 PUSH1 0x01 070F 60 PUSH1 0x01 0711 60 PUSH1 0xa0 0713 1B SHL 0714 03 SUB 0715 85 DUP6 0716 16 AND 0717 61 PUSH2 0x0733 071A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0733, if stack[-5] & (0x01 << 0xa0) - 0x01 label_071B: // Incoming jump from 0x071A, if not stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @071D memory[0x40:0x60] // @072D memory[0x40:0x60] // @0732 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 071B 60 PUSH1 0x40 071D 51 MLOAD 071E 63 PUSH4 0x3a954ecd 0723 60 PUSH1 0xe2 0725 1B SHL 0726 81 DUP2 0727 52 MSTORE 0728 60 PUSH1 0x04 072A 01 ADD 072B 60 PUSH1 0x40 072D 51 MLOAD 072E 80 DUP1 072F 91 SWAP2 0730 03 SUB 0731 90 SWAP1 0732 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0727 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3a954ecd << 0xe2 // @0732 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0733: // Incoming jump from 0x071A, if stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0734 stack[-1] } 0733 5B JUMPDEST 0734 80 DUP1 0735 15 ISZERO 0736 61 PUSH2 0x073e 0739 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x073e, if !stack[-1] label_073A: // Incoming jump from 0x0739, if not !stack[-1] // Inputs[11] // { // @073C stack[-2] // @0747 stack[-6] // @0758 memory[0x00:0x40] // @075A storage[keccak256(memory[0x00:0x40])] // @0762 stack[-5] // @0769 memory[0x00:0x40] // @076B storage[keccak256(memory[0x00:0x40])] // @0771 block.timestamp // @077E stack[-4] // @0789 memory[0x00:0x40] // @0793 stack[-3] // } 073A 60 PUSH1 0x00 073C 82 DUP3 073D 55 SSTORE 073E 5B JUMPDEST 073F 60 PUSH1 0x01 0741 60 PUSH1 0x01 0743 60 PUSH1 0xa0 0745 1B SHL 0746 03 SUB 0747 86 DUP7 0748 81 DUP2 0749 16 AND 074A 60 PUSH1 0x00 074C 90 SWAP1 074D 81 DUP2 074E 52 MSTORE 074F 60 PUSH1 0x05 0751 60 PUSH1 0x20 0753 52 MSTORE 0754 60 PUSH1 0x40 0756 80 DUP1 0757 82 DUP3 0758 20 SHA3 0759 80 DUP1 075A 54 SLOAD 075B 60 PUSH1 0x00 075D 19 NOT 075E 01 ADD 075F 90 SWAP1 0760 55 SSTORE 0761 91 SWAP2 0762 87 DUP8 0763 16 AND 0764 80 DUP1 0765 82 DUP3 0766 52 MSTORE 0767 91 SWAP2 0768 90 SWAP1 0769 20 SHA3 076A 80 DUP1 076B 54 SLOAD 076C 60 PUSH1 0x01 076E 01 ADD 076F 90 SWAP1 0770 55 SSTORE 0771 42 TIMESTAMP 0772 60 PUSH1 0xa0 0774 1B SHL 0775 17 OR 0776 60 PUSH1 0x01 0778 60 PUSH1 0xe1 077A 1B SHL 077B 17 OR 077C 60 PUSH1 0x00 077E 85 DUP6 077F 81 DUP2 0780 52 MSTORE 0781 60 PUSH1 0x04 0783 60 PUSH1 0x20 0785 52 MSTORE 0786 60 PUSH1 0x40 0788 81 DUP2 0789 20 SHA3 078A 91 SWAP2 078B 90 SWAP1 078C 91 SWAP2 078D 55 SSTORE 078E 60 PUSH1 0x01 0790 60 PUSH1 0xe1 0792 1B SHL 0793 84 DUP5 0794 16 AND 0795 90 SWAP1 0796 03 SUB 0797 61 PUSH2 0x07d0 079A 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @073D storage[stack[-2]] = 0x00 // @074E memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @0753 memory[0x20:0x40] = 0x05 // @0760 storage[keccak256(memory[0x00:0x40])] = ~0x00 + storage[keccak256(memory[0x00:0x40])] // @0766 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @0770 storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // @0780 memory[0x00:0x20] = stack[-4] // @0785 memory[0x20:0x40] = 0x04 // @078D storage[keccak256(memory[0x00:0x40])] = (0x01 << 0xe1) | (block.timestamp << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) // } // Block ends with conditional jump to 0x07d0, if 0x00 - (stack[-3] & (0x01 << 0xe1)) label_079B: // Incoming jump from 0x079A, if not 0x00 - (stack[-3] & (0x01 << 0xe1)) // Incoming jump from 0x079A, if not 0x00 - (stack[-3] & (0x01 << 0xe1)) // Inputs[3] // { // @079D stack[-4] // @07AC memory[0x00:0x40] // @07AD storage[keccak256(memory[0x00:0x40])] // } 079B 60 PUSH1 0x01 079D 84 DUP5 079E 01 ADD 079F 60 PUSH1 0x00 07A1 81 DUP2 07A2 81 DUP2 07A3 52 MSTORE 07A4 60 PUSH1 0x04 07A6 60 PUSH1 0x20 07A8 52 MSTORE 07A9 60 PUSH1 0x40 07AB 81 DUP2 07AC 20 SHA3 07AD 54 SLOAD 07AE 90 SWAP1 07AF 03 SUB 07B0 61 PUSH2 0x07ce 07B3 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @079E stack[0] = stack[-4] + 0x01 // @07A3 memory[0x00:0x20] = stack[-4] + 0x01 // @07A8 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x07ce, if 0x00 - storage[keccak256(memory[0x00:0x40])] label_07B4: // Incoming jump from 0x07B3, if not 0x00 - storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @07B6 storage[0x00] // @07B7 stack[-1] // } 07B4 60 PUSH1 0x00 07B6 54 SLOAD 07B7 81 DUP2 07B8 14 EQ 07B9 61 PUSH2 0x07ce 07BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07ce, if stack[-1] == storage[0x00] label_07BD: // Incoming jump from 0x07BC, if not stack[-1] == storage[0x00] // Inputs[3] // { // @07BF stack[-1] // @07CA memory[0x00:0x40] // @07CB stack[-4] // } 07BD 60 PUSH1 0x00 07BF 81 DUP2 07C0 81 DUP2 07C1 52 MSTORE 07C2 60 PUSH1 0x04 07C4 60 PUSH1 0x20 07C6 52 MSTORE 07C7 60 PUSH1 0x40 07C9 90 SWAP1 07CA 20 SHA3 07CB 84 DUP5 07CC 90 SWAP1 07CD 55 SSTORE // Stack delta = +0 // Outputs[3] // { // @07C1 memory[0x00:0x20] = stack[-1] // @07C6 memory[0x20:0x40] = 0x04 // @07CD storage[keccak256(memory[0x00:0x40])] = stack[-4] // } // Block continues label_07CE: // Incoming jump from 0x07B3, if 0x00 - storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x07CD // Incoming jump from 0x07BC, if stack[-1] == storage[0x00] 07CE 5B JUMPDEST 07CF 50 POP // Stack delta = -1 // Block continues label_07D0: // Incoming jump from 0x079A, if 0x00 - (stack[-3] & (0x01 << 0xe1)) // Incoming jump from 0x07CF // Incoming jump from 0x079A, if 0x00 - (stack[-3] & (0x01 << 0xe1)) // Inputs[7] // { // @07D1 stack[-4] // @07D2 stack[-5] // @07DC stack[-6] // @0809 memory[0x40:0x60] // @080C memory[0x40:0x60] // @0811 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0819 stack[-7] // } 07D0 5B JUMPDEST 07D1 83 DUP4 07D2 85 DUP6 07D3 60 PUSH1 0x01 07D5 60 PUSH1 0x01 07D7 60 PUSH1 0xa0 07D9 1B SHL 07DA 03 SUB 07DB 16 AND 07DC 87 DUP8 07DD 60 PUSH1 0x01 07DF 60 PUSH1 0x01 07E1 60 PUSH1 0xa0 07E3 1B SHL 07E4 03 SUB 07E5 16 AND 07E6 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0807 60 PUSH1 0x40 0809 51 MLOAD 080A 60 PUSH1 0x40 080C 51 MLOAD 080D 80 DUP1 080E 91 SWAP2 080F 03 SUB 0810 90 SWAP1 0811 A4 LOG4 0812 5B JUMPDEST 0813 50 POP 0814 50 POP 0815 50 POP 0816 50 POP 0817 50 POP 0818 50 POP 0819 56 *JUMP // Stack delta = -7 // Outputs[1] { @0811 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5] & (0x01 << 0xa0) - 0x01, stack[-4]]); } // Block ends with unconditional jump to stack[-7] label_081A: // Incoming jump from 0x0283 // Inputs[4] // { // @081E stack[-3] // @081F stack[-2] // @0820 stack[-1] // @0823 memory[0x40:0x60] // } 081A 5B JUMPDEST 081B 61 PUSH2 0x0835 081E 83 DUP4 081F 83 DUP4 0820 83 DUP4 0821 60 PUSH1 0x40 0823 51 MLOAD 0824 80 DUP1 0825 60 PUSH1 0x20 0827 01 ADD 0828 60 PUSH1 0x40 082A 52 MSTORE 082B 80 DUP1 082C 60 PUSH1 0x00 082E 81 DUP2 082F 52 MSTORE 0830 50 POP 0831 61 PUSH2 0x0b3a 0834 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @081B stack[0] = 0x0835 // @081E stack[1] = stack[-3] // @081F stack[2] = stack[-2] // @0820 stack[3] = stack[-1] // @0823 stack[4] = memory[0x40:0x60] // @082A memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @082F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x0b3a, returns to 0x0835 label_0835: // Incoming jump from 0x14EB, if !(stack[-2] > 0x1f) // Incoming return from call to 0x0B3A at 0x0834 // Incoming jump from 0x0922, if !(0x00 < stack[-5]) // Incoming jump from 0x0DB1, if !!address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Incoming jump from 0x0922, if !(stack[-1] < stack[-2]) // Inputs[1] { @0839 stack[-4] } 0835 5B JUMPDEST 0836 50 POP 0837 50 POP 0838 50 POP 0839 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_083A: // Incoming call from 0x05EB, returns to 0x05EC // Incoming jump from 0x02E7 // Inputs[1] { @0840 stack[-1] } 083A 5B JUMPDEST 083B 60 PUSH1 0x00 083D 61 PUSH2 0x04ed 0840 82 DUP3 0841 61 PUSH2 0x0e3c 0844 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @083B stack[0] = 0x00 // @083D stack[1] = 0x04ed // @0840 stack[2] = stack[-1] // } // Block ends with call to 0x0e3c, returns to 0x04ED label_0845: // Incoming jump from 0x0307 // Inputs[1] { @0850 stack[-1] } 0845 5B JUMPDEST 0846 60 PUSH1 0x00 0848 60 PUSH1 0x01 084A 60 PUSH1 0x01 084C 60 PUSH1 0xa0 084E 1B SHL 084F 03 SUB 0850 82 DUP3 0851 16 AND 0852 61 PUSH2 0x086e 0855 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0846 stack[0] = 0x00 } // Block ends with conditional jump to 0x086e, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0856: // Incoming jump from 0x0855, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0858 memory[0x40:0x60] // @0868 memory[0x40:0x60] // @086D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0856 60 PUSH1 0x40 0858 51 MLOAD 0859 63 PUSH4 0x23d3ad81 085E 60 PUSH1 0xe2 0860 1B SHL 0861 81 DUP2 0862 52 MSTORE 0863 60 PUSH1 0x04 0865 01 ADD 0866 60 PUSH1 0x40 0868 51 MLOAD 0869 80 DUP1 086A 91 SWAP2 086B 03 SUB 086C 90 SWAP1 086D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0862 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x23d3ad81 << 0xe2 // @086D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_086E: // Incoming jump from 0x0855, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0878 stack[-2] // @0886 memory[0x00:0x40] // @0887 storage[keccak256(memory[0x00:0x40])] // @0892 stack[-3] // } 086E 5B JUMPDEST 086F 50 POP 0870 60 PUSH1 0x01 0872 60 PUSH1 0x01 0874 60 PUSH1 0xa0 0876 1B SHL 0877 03 SUB 0878 16 AND 0879 60 PUSH1 0x00 087B 90 SWAP1 087C 81 DUP2 087D 52 MSTORE 087E 60 PUSH1 0x05 0880 60 PUSH1 0x20 0882 52 MSTORE 0883 60 PUSH1 0x40 0885 90 SWAP1 0886 20 SHA3 0887 54 SLOAD 0888 67 PUSH8 0xffffffffffffffff 0891 16 AND 0892 90 SWAP1 0893 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @087D memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0882 memory[0x20:0x40] = 0x05 // @0892 stack[-3] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0894: // Incoming jump from 0x031C 0894 5B JUMPDEST 0895 61 PUSH2 0x089c 0898 61 PUSH2 0x0dbb 089B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0895 stack[0] = 0x089c } // Block ends with call to 0x0dbb, returns to 0x089C label_089C: // Incoming return from call to 0x0DBB at 0x089B 089C 5B JUMPDEST 089D 61 PUSH2 0x08a6 08A0 60 PUSH1 0x00 08A2 61 PUSH2 0x0ea3 08A5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @089D stack[0] = 0x08a6 // @08A0 stack[1] = 0x00 // } // Block ends with call to 0x0ea3, returns to 0x08A6 label_08A6: // Incoming jump from 0x0CAD, if 0x01 - storage[0x09] // Incoming return from call to 0x0EA3 at 0x08A5 // Incoming jump from 0x0DCD, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @08A7 stack[-1] } 08A6 5B JUMPDEST 08A7 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_08A8: // Incoming jump from 0x033C 08A8 5B JUMPDEST 08A9 61 PUSH2 0x08b0 08AC 61 PUSH2 0x0dbb 08AF 56 *JUMP // Stack delta = +1 // Outputs[1] { @08A9 stack[0] = 0x08b0 } // Block ends with call to 0x0dbb, returns to 0x08B0 label_08B0: // Incoming return from call to 0x0DBB at 0x08AF // Inputs[2] // { // @08B3 storage[0x0d] // @08B4 stack[-1] // } 08B0 5B JUMPDEST 08B1 60 PUSH1 0x0d 08B3 54 SLOAD 08B4 81 DUP2 08B5 11 GT 08B6 15 ISZERO 08B7 61 PUSH2 0x08fc 08BA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08fc, if !(stack[-1] > storage[0x0d]) label_08BB: // Incoming jump from 0x08BA, if not !(stack[-1] > storage[0x0d]) // Inputs[1] { @08BD memory[0x40:0x60] } 08BB 60 PUSH1 0x40 08BD 51 MLOAD 08BE 62 PUSH3 0x461bcd 08C2 60 PUSH1 0xe5 08C4 1B SHL 08C5 81 DUP2 08C6 52 MSTORE 08C7 60 PUSH1 0x20 08C9 60 PUSH1 0x04 08CB 82 DUP3 08CC 01 ADD 08CD 52 MSTORE 08CE 60 PUSH1 0x12 08D0 60 PUSH1 0x24 08D2 82 DUP3 08D3 01 ADD 08D4 52 MSTORE 08D5 71 PUSH18 0x4e6f7420656e6f7567682072657365727665 08E8 60 PUSH1 0x70 08EA 1B SHL 08EB 60 PUSH1 0x44 08ED 82 DUP3 08EE 01 ADD 08EF 52 MSTORE 08F0 60 PUSH1 0x64 08F2 01 ADD // Stack delta = +1 // Outputs[5] // { // @08C6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08CD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @08D4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @08EF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4e6f7420656e6f7567682072657365727665 << 0x70 // @08F2 stack[0] = 0x64 + memory[0x40:0x60] // } // Block continues label_08F3: // Incoming jump from 0x0C56 // Incoming jump from 0x08F2 // Incoming jump from 0x0E14 // Incoming jump from 0x0D84 // Incoming jump from 0x09C5 // Incoming jump from 0x0A23 // Incoming jump from 0x0D32 // Incoming jump from 0x0A7F // Inputs[3] // { // @08F6 memory[0x40:0x60] // @08F8 stack[-1] // @08FB memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 08F3 5B JUMPDEST 08F4 60 PUSH1 0x40 08F6 51 MLOAD 08F7 80 DUP1 08F8 91 SWAP2 08F9 03 SUB 08FA 90 SWAP1 08FB FD *REVERT // Stack delta = -1 // Outputs[1] { @08FB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_08FC: // Incoming jump from 0x08BA, if !(stack[-1] > storage[0x0d]) // Inputs[3] // { // @08FD stack[-2] // @08FE stack[-1] // @0907 storage[0x0d] // } 08FC 5B JUMPDEST 08FD 81 DUP2 08FE 81 DUP2 08FF 90 SWAP1 0900 50 POP 0901 60 PUSH1 0x0d 0903 60 PUSH1 0x00 0905 82 DUP3 0906 82 DUP3 0907 54 SLOAD 0908 61 PUSH2 0x0911 090B 91 SWAP2 090C 90 SWAP1 090D 61 PUSH2 0x15fe 0910 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @08FF stack[0] = stack[-1] // @0901 stack[1] = 0x0d // @0903 stack[2] = 0x00 // @090B stack[3] = 0x0911 // @090C stack[4] = stack[-1] // @090C stack[5] = storage[0x0d] // } // Block ends with call to 0x15fe, returns to 0x0911 label_0911: // Incoming return from call to 0x15FE at 0x0910 // Inputs[5] // { // @0912 stack[-2] // @0912 stack[-1] // @0913 stack[-3] // @0918 stack[-4] // @091B stack[-5] // } 0911 5B JUMPDEST 0912 90 SWAP1 0913 91 SWAP2 0914 55 SSTORE 0915 50 POP 0916 60 PUSH1 0x00 0918 90 SWAP1 0919 50 POP 091A 5B JUMPDEST 091B 81 DUP2 091C 81 DUP2 091D 10 LT 091E 15 ISZERO 091F 61 PUSH2 0x0835 0922 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @0914 storage[stack[-3]] = stack[-1] // @0918 stack[-4] = 0x00 // } // Block ends with conditional jump to 0x0835, if !(0x00 < stack[-5]) label_0923: // Incoming jump from 0x0922, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x0922, if not !(0x00 < stack[-5]) // Inputs[3] // { // @0926 stack[-3] // @0927 stack[-2] // @0928 stack[-1] // } 0923 61 PUSH2 0x0953 0926 83 DUP4 0927 83 DUP4 0928 83 DUP4 0929 81 DUP2 092A 81 DUP2 092B 10 LT 092C 61 PUSH2 0x0937 092F 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0923 stack[0] = 0x0953 // @0926 stack[1] = stack[-3] // @0927 stack[2] = stack[-2] // @0928 stack[3] = stack[-1] // } // Block ends with conditional call to 0x0937, returns to 0x0953, if stack[-1] < stack[-2] label_0930: // Incoming jump from 0x092F, if not stack[-1] < stack[-2] 0930 61 PUSH2 0x0937 0933 61 PUSH2 0x1615 0936 56 *JUMP // Stack delta = +1 // Outputs[1] { @0930 stack[0] = 0x0937 } // Block ends with unconditional jump to 0x1615 label_0937: // Incoming call from 0x092F, returns to 0x0953, if stack[-1] < stack[-2] // Inputs[3] // { // @0938 stack[-1] // @0938 stack[-2] // @093D stack[-3] // } 0937 5B JUMPDEST 0938 90 SWAP1 0939 50 POP 093A 60 PUSH1 0x20 093C 02 MUL 093D 01 ADD 093E 60 PUSH1 0x20 0940 81 DUP2 0941 01 ADD 0942 90 SWAP1 0943 61 PUSH2 0x094c 0946 91 SWAP2 0947 90 SWAP1 0948 61 PUSH2 0x132d 094B 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0946 stack[-3] = 0x094c // @0947 stack[-1] = 0x20 * stack[-1] + stack[-3] // @0947 stack[-2] = 0x20 * stack[-1] + stack[-3] + 0x20 // } // Block ends with call to 0x132d, returns to 0x094C label_094C: // Incoming return from call to 0x132D at 0x094B 094C 5B JUMPDEST 094D 60 PUSH1 0x01 094F 61 PUSH2 0x0ef5 0952 56 *JUMP // Stack delta = +1 // Outputs[1] { @094D stack[0] = 0x01 } // Block ends with unconditional jump to 0x0ef5 label_0953: // Incoming return from call to 0x0937 at 0x092F // Inputs[1] { @0954 stack[-1] } 0953 5B JUMPDEST 0954 80 DUP1 0955 61 PUSH2 0x095d 0958 81 DUP2 0959 61 PUSH2 0x162b 095C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0954 stack[0] = stack[-1] // @0955 stack[1] = 0x095d // @0958 stack[2] = stack[-1] // } // Block ends with call to 0x162b, returns to 0x095D label_095D: // Incoming return from call to 0x162B at 0x095C // Inputs[2] // { // @095E stack[-1] // @095E stack[-3] // } 095D 5B JUMPDEST 095E 91 SWAP2 095F 50 POP 0960 50 POP 0961 61 PUSH2 0x091a 0964 56 *JUMP // Stack delta = -2 // Outputs[1] { @095E stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x091a label_0965: // Incoming call from 0x036F, returns to 0x01BC // Inputs[1] { @096B storage[0x03] } 0965 5B JUMPDEST 0966 60 PUSH1 0x60 0968 60 PUSH1 0x03 096A 80 DUP1 096B 54 SLOAD 096C 61 PUSH2 0x051a 096F 90 SWAP1 0970 61 PUSH2 0x14a8 0973 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0966 stack[0] = 0x60 // @0968 stack[1] = 0x03 // @096F stack[2] = 0x051a // @096F stack[3] = storage[0x03] // } // Block ends with call to 0x14a8, returns to 0x051A label_0974: // Incoming jump from 0x0382 // Inputs[1] { @0979 storage[0x09] } 0974 5B JUMPDEST 0975 60 PUSH1 0x00 0977 60 PUSH1 0x09 0979 54 SLOAD 097A 11 GT 097B 61 PUSH2 0x09c6 097E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09c6, if storage[0x09] > 0x00 label_097F: // Incoming jump from 0x097E, if not storage[0x09] > 0x00 // Inputs[1] { @0981 memory[0x40:0x60] } 097F 60 PUSH1 0x40 0981 51 MLOAD 0982 62 PUSH3 0x461bcd 0986 60 PUSH1 0xe5 0988 1B SHL 0989 81 DUP2 098A 52 MSTORE 098B 60 PUSH1 0x20 098D 60 PUSH1 0x04 098F 82 DUP3 0990 01 ADD 0991 52 MSTORE 0992 60 PUSH1 0x19 0994 60 PUSH1 0x24 0996 82 DUP3 0997 01 ADD 0998 52 MSTORE 0999 7F PUSH32 0x53616c65206973206e6f74207965742061637469766174656400000000000000 09BA 60 PUSH1 0x44 09BC 82 DUP3 09BD 01 ADD 09BE 52 MSTORE 09BF 60 PUSH1 0x64 09C1 01 ADD 09C2 61 PUSH2 0x08f3 09C5 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @098A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0991 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0998 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @09BE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53616c65206973206e6f74207965742061637469766174656400000000000000 // @09C1 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f3 label_09C6: // Incoming jump from 0x097E, if storage[0x09] > 0x00 // Inputs[3] // { // @09C9 storage[0x0a] // @09CC storage[0x0b] // @09D1 stack[-1] // } 09C6 5B JUMPDEST 09C7 60 PUSH1 0x0a 09C9 54 SLOAD 09CA 60 PUSH1 0x0b 09CC 54 SLOAD 09CD 61 PUSH2 0x09d6 09D0 90 SWAP1 09D1 83 DUP4 09D2 61 PUSH2 0x1644 09D5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @09C9 stack[0] = storage[0x0a] // @09D0 stack[1] = 0x09d6 // @09D0 stack[2] = storage[0x0b] // @09D1 stack[3] = stack[-1] // } // Block ends with call to 0x1644, returns to 0x09D6 label_09D6: // Incoming return from call to 0x1644 at 0x09D5 // Inputs[2] // { // @09D7 stack[-2] // @09D7 stack[-1] // } 09D6 5B JUMPDEST 09D7 11 GT 09D8 15 ISZERO 09D9 61 PUSH2 0x0a24 09DC 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0a24, if !(stack[-1] > stack[-2]) label_09DD: // Incoming jump from 0x09DC, if not !(stack[-1] > stack[-2]) // Inputs[1] { @09DF memory[0x40:0x60] } 09DD 60 PUSH1 0x40 09DF 51 MLOAD 09E0 62 PUSH3 0x461bcd 09E4 60 PUSH1 0xe5 09E6 1B SHL 09E7 81 DUP2 09E8 52 MSTORE 09E9 60 PUSH1 0x20 09EB 60 PUSH1 0x04 09ED 82 DUP3 09EE 01 ADD 09EF 52 MSTORE 09F0 60 PUSH1 0x19 09F2 60 PUSH1 0x24 09F4 82 DUP3 09F5 01 ADD 09F6 52 MSTORE 09F7 7F PUSH32 0x416d6f756e742065786365656473206d617820737570706c7900000000000000 0A18 60 PUSH1 0x44 0A1A 82 DUP3 0A1B 01 ADD 0A1C 52 MSTORE 0A1D 60 PUSH1 0x64 0A1F 01 ADD 0A20 61 PUSH2 0x08f3 0A23 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @09E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09EF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09F6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @0A1C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416d6f756e742065786365656473206d617820737570706c7900000000000000 // @0A1F stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f3 label_0A24: // Incoming jump from 0x09DC, if !(stack[-1] > stack[-2]) // Inputs[3] // { // @0A25 msg.value // @0A28 storage[0x0c] // @0A29 stack[-1] // } 0A24 5B JUMPDEST 0A25 34 CALLVALUE 0A26 60 PUSH1 0x0c 0A28 54 SLOAD 0A29 82 DUP3 0A2A 61 PUSH2 0x0a33 0A2D 91 SWAP2 0A2E 90 SWAP1 0A2F 61 PUSH2 0x165c 0A32 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A25 stack[0] = msg.value // @0A2D stack[1] = 0x0a33 // @0A2E stack[2] = storage[0x0c] // @0A2E stack[3] = stack[-1] // } // Block ends with call to 0x165c, returns to 0x0A33 label_0A33: // Incoming return from call to 0x165C at 0x0A32 // Inputs[2] // { // @0A34 stack[-1] // @0A34 stack[-2] // } 0A33 5B JUMPDEST 0A34 14 EQ 0A35 61 PUSH2 0x0a80 0A38 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0a80, if stack[-1] == stack[-2] label_0A39: // Incoming jump from 0x0A38, if not stack[-1] == stack[-2] // Inputs[1] { @0A3B memory[0x40:0x60] } 0A39 60 PUSH1 0x40 0A3B 51 MLOAD 0A3C 62 PUSH3 0x461bcd 0A40 60 PUSH1 0xe5 0A42 1B SHL 0A43 81 DUP2 0A44 52 MSTORE 0A45 60 PUSH1 0x20 0A47 60 PUSH1 0x04 0A49 82 DUP3 0A4A 01 ADD 0A4B 52 MSTORE 0A4C 60 PUSH1 0x1b 0A4E 60 PUSH1 0x24 0A50 82 DUP3 0A51 01 ADD 0A52 52 MSTORE 0A53 7F PUSH32 0x416d6f756e7420646f6573206e6f74206d617463682070726963650000000000 0A74 60 PUSH1 0x44 0A76 82 DUP3 0A77 01 ADD 0A78 52 MSTORE 0A79 60 PUSH1 0x64 0A7B 01 ADD 0A7C 61 PUSH2 0x08f3 0A7F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A44 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A4B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A52 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1b // @0A78 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416d6f756e7420646f6573206e6f74206d617463682070726963650000000000 // @0A7B stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f3 label_0A80: // Incoming jump from 0x0A38, if stack[-1] == stack[-2] // Inputs[2] // { // @0A81 stack[-1] // @0A88 storage[0x0b] // } 0A80 5B JUMPDEST 0A81 80 DUP1 0A82 60 PUSH1 0x0b 0A84 60 PUSH1 0x00 0A86 82 DUP3 0A87 82 DUP3 0A88 54 SLOAD 0A89 61 PUSH2 0x0a92 0A8C 91 SWAP2 0A8D 90 SWAP1 0A8E 61 PUSH2 0x1644 0A91 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0A81 stack[0] = stack[-1] // @0A82 stack[1] = 0x0b // @0A84 stack[2] = 0x00 // @0A8C stack[3] = 0x0a92 // @0A8D stack[4] = stack[-1] // @0A8D stack[5] = storage[0x0b] // } // Block ends with call to 0x1644, returns to 0x0A92 label_0A92: // Incoming return from call to 0x1644 at 0x0A91 // Inputs[6] // { // @0A93 stack[-1] // @0A93 stack[-2] // @0A94 stack[-3] // @0A9A stack[-4] // @0A9C msg.sender // @0A9D stack[-5] // } 0A92 5B JUMPDEST 0A93 90 SWAP1 0A94 91 SWAP2 0A95 55 SSTORE 0A96 50 POP 0A97 61 PUSH2 0x0aa2 0A9A 90 SWAP1 0A9B 50 POP 0A9C 33 CALLER 0A9D 82 DUP3 0A9E 61 PUSH2 0x0ef5 0AA1 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0A95 storage[stack[-3]] = stack[-1] // @0A9A stack[-4] = 0x0aa2 // @0A9C stack[-3] = msg.sender // @0A9D stack[-2] = stack[-5] // } // Block ends with call to 0x0ef5, returns to 0x0AA2 label_0AA2: // Incoming return from call to 0x0EA3 at 0x0D3B // Incoming jump from 0x1130, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x0EF5 at 0x0AA1 // Inputs[1] { @0AA4 stack[-2] } 0AA2 5B JUMPDEST 0AA3 50 POP 0AA4 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0AA5: // Incoming jump from 0x03A2 // Inputs[2] // { // @0AA6 msg.sender // @0AAF stack[-2] // } 0AA5 5B JUMPDEST 0AA6 33 CALLER 0AA7 60 PUSH1 0x01 0AA9 60 PUSH1 0x01 0AAB 60 PUSH1 0xa0 0AAD 1B SHL 0AAE 03 SUB 0AAF 83 DUP4 0AB0 16 AND 0AB1 03 SUB 0AB2 61 PUSH2 0x0ace 0AB5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ace, if (stack[-2] & (0x01 << 0xa0) - 0x01) - msg.sender label_0AB6: // Incoming jump from 0x0AB5, if not (stack[-2] & (0x01 << 0xa0) - 0x01) - msg.sender // Inputs[3] // { // @0AB8 memory[0x40:0x60] // @0AC8 memory[0x40:0x60] // @0ACD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0AB6 60 PUSH1 0x40 0AB8 51 MLOAD 0AB9 63 PUSH4 0xb06307db 0ABE 60 PUSH1 0xe0 0AC0 1B SHL 0AC1 81 DUP2 0AC2 52 MSTORE 0AC3 60 PUSH1 0x04 0AC5 01 ADD 0AC6 60 PUSH1 0x40 0AC8 51 MLOAD 0AC9 80 DUP1 0ACA 91 SWAP2 0ACB 03 SUB 0ACC 90 SWAP1 0ACD FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0AC2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb06307db << 0xe0 // @0ACD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0ACE: // Incoming jump from 0x0AB5, if (stack[-2] & (0x01 << 0xa0) - 0x01) - msg.sender // Inputs[10] // { // @0ACF msg.sender // @0AE0 memory[0x00:0x40] // @0AE9 stack[-2] // @0AF4 memory[0x00:0x40] // @0AF6 storage[keccak256(memory[0x00:0x40])] // @0AFB stack[-1] // @0B05 memory[0x40:0x60] // @0B31 memory[0x40:0x60] // @0B36 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0B39 stack[-3] // } 0ACE 5B JUMPDEST 0ACF 33 CALLER 0AD0 60 PUSH1 0x00 0AD2 81 DUP2 0AD3 81 DUP2 0AD4 52 MSTORE 0AD5 60 PUSH1 0x07 0AD7 60 PUSH1 0x20 0AD9 90 SWAP1 0ADA 81 DUP2 0ADB 52 MSTORE 0ADC 60 PUSH1 0x40 0ADE 80 DUP1 0ADF 83 DUP4 0AE0 20 SHA3 0AE1 60 PUSH1 0x01 0AE3 60 PUSH1 0x01 0AE5 60 PUSH1 0xa0 0AE7 1B SHL 0AE8 03 SUB 0AE9 87 DUP8 0AEA 16 AND 0AEB 80 DUP1 0AEC 85 DUP6 0AED 52 MSTORE 0AEE 90 SWAP1 0AEF 83 DUP4 0AF0 52 MSTORE 0AF1 92 SWAP3 0AF2 81 DUP2 0AF3 90 SWAP1 0AF4 20 SHA3 0AF5 80 DUP1 0AF6 54 SLOAD 0AF7 60 PUSH1 0xff 0AF9 19 NOT 0AFA 16 AND 0AFB 86 DUP7 0AFC 15 ISZERO 0AFD 15 ISZERO 0AFE 90 SWAP1 0AFF 81 DUP2 0B00 17 OR 0B01 90 SWAP1 0B02 91 SWAP2 0B03 55 SSTORE 0B04 90 SWAP1 0B05 51 MLOAD 0B06 90 SWAP1 0B07 81 DUP2 0B08 52 MSTORE 0B09 91 SWAP2 0B0A 92 SWAP3 0B0B 91 SWAP2 0B0C 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0B2D 91 SWAP2 0B2E 01 ADD 0B2F 60 PUSH1 0x40 0B31 51 MLOAD 0B32 80 DUP1 0B33 91 SWAP2 0B34 03 SUB 0B35 90 SWAP1 0B36 A3 LOG3 0B37 50 POP 0B38 50 POP 0B39 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0AD4 memory[0x00:0x20] = msg.sender // @0ADB memory[0x20:0x40] = 0x07 // @0AED memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0AF0 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0B03 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0B08 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0B36 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_0B3A: // Incoming call from 0x0834, returns to 0x0835 // Incoming jump from 0x03C2 // Inputs[3] // { // @0B3E stack[-4] // @0B3F stack[-3] // @0B40 stack[-2] // } 0B3A 5B JUMPDEST 0B3B 61 PUSH2 0x0b45 0B3E 84 DUP5 0B3F 84 DUP5 0B40 84 DUP5 0B41 61 PUSH2 0x0681 0B44 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B3B stack[0] = 0x0b45 // @0B3E stack[1] = stack[-4] // @0B3F stack[2] = stack[-3] // @0B40 stack[3] = stack[-2] // } // Block ends with call to 0x0681, returns to 0x0B45 label_0B45: // Incoming return from call to 0x0681 at 0x0B44 // Inputs[2] // { // @0B4E stack[-3] // @0B50 address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 0B45 5B JUMPDEST 0B46 60 PUSH1 0x01 0B48 60 PUSH1 0x01 0B4A 60 PUSH1 0xa0 0B4C 1B SHL 0B4D 03 SUB 0B4E 83 DUP4 0B4F 16 AND 0B50 3B EXTCODESIZE 0B51 15 ISZERO 0B52 61 PUSH2 0x0b7e 0B55 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b7e, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_0B56: // Incoming jump from 0x0B55, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[4] // { // @0B59 stack[-4] // @0B5A stack[-3] // @0B5B stack[-2] // @0B5C stack[-1] // } 0B56 61 PUSH2 0x0b61 0B59 84 DUP5 0B5A 84 DUP5 0B5B 84 DUP5 0B5C 84 DUP5 0B5D 61 PUSH2 0x0fd5 0B60 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0B56 stack[0] = 0x0b61 // @0B59 stack[1] = stack[-4] // @0B5A stack[2] = stack[-3] // @0B5B stack[3] = stack[-2] // @0B5C stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x0fd5 0B61 5B JUMPDEST 0B62 61 PUSH2 0x0b7e 0B65 57 *JUMPI 0B66 60 PUSH1 0x40 0B68 51 MLOAD 0B69 63 PUSH4 0x68d2bf6b 0B6E 60 PUSH1 0xe1 0B70 1B SHL 0B71 81 DUP2 0B72 52 MSTORE 0B73 60 PUSH1 0x04 0B75 01 ADD 0B76 60 PUSH1 0x40 0B78 51 MLOAD 0B79 80 DUP1 0B7A 91 SWAP2 0B7B 03 SUB 0B7C 90 SWAP1 0B7D FD *REVERT label_0B7E: // Incoming jump from 0x0B55, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Incoming jump from 0x124A, if !(stack[-1] > stack[-4]) // Inputs[1] { @0B83 stack[-5] } 0B7E 5B JUMPDEST 0B7F 50 POP 0B80 50 POP 0B81 50 POP 0B82 50 POP 0B83 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0B84: // Incoming jump from 0x03E2 // Inputs[1] { @0B8A stack[-1] } 0B84 5B JUMPDEST 0B85 60 PUSH1 0x60 0B87 61 PUSH2 0x0b8f 0B8A 82 DUP3 0B8B 61 PUSH2 0x0e15 0B8E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B85 stack[0] = 0x60 // @0B87 stack[1] = 0x0b8f // @0B8A stack[2] = stack[-1] // } // Block ends with call to 0x0e15, returns to 0x0B8F label_0B8F: // Incoming return from call to 0x0E15 at 0x0B8E // Inputs[1] { @0B93 stack[-1] } 0B8F 5B JUMPDEST 0B90 61 PUSH2 0x0bac 0B93 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0bac, if stack[-1] label_0B94: // Incoming jump from 0x0B93, if not stack[-1] // Inputs[3] // { // @0B96 memory[0x40:0x60] // @0BA6 memory[0x40:0x60] // @0BAB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B94 60 PUSH1 0x40 0B96 51 MLOAD 0B97 63 PUSH4 0x0a14c4b5 0B9C 60 PUSH1 0xe4 0B9E 1B SHL 0B9F 81 DUP2 0BA0 52 MSTORE 0BA1 60 PUSH1 0x04 0BA3 01 ADD 0BA4 60 PUSH1 0x40 0BA6 51 MLOAD 0BA7 80 DUP1 0BA8 91 SWAP2 0BA9 03 SUB 0BAA 90 SWAP1 0BAB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0BA0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a14c4b5 << 0xe4 // @0BAB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0BAC: // Incoming jump from 0x0B93, if stack[-1] 0BAC 5B JUMPDEST 0BAD 60 PUSH1 0x00 0BAF 61 PUSH2 0x0bb6 0BB2 61 PUSH2 0x10c1 0BB5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0BAD stack[0] = 0x00 // @0BAF stack[1] = 0x0bb6 // } // Block ends with unconditional jump to 0x10c1 0BB6 5B JUMPDEST 0BB7 90 SWAP1 0BB8 50 POP 0BB9 80 DUP1 0BBA 51 MLOAD 0BBB 60 PUSH1 0x00 0BBD 03 SUB 0BBE 61 PUSH2 0x0bd6 0BC1 57 *JUMPI 0BC2 60 PUSH1 0x40 0BC4 51 MLOAD 0BC5 80 DUP1 0BC6 60 PUSH1 0x20 0BC8 01 ADD 0BC9 60 PUSH1 0x40 0BCB 52 MSTORE 0BCC 80 DUP1 0BCD 60 PUSH1 0x00 0BCF 81 DUP2 0BD0 52 MSTORE 0BD1 50 POP 0BD2 61 PUSH2 0x0c01 0BD5 56 *JUMP 0BD6 5B JUMPDEST 0BD7 80 DUP1 0BD8 61 PUSH2 0x0be0 0BDB 84 DUP5 0BDC 61 PUSH2 0x10d0 0BDF 56 *JUMP 0BE0 5B JUMPDEST 0BE1 60 PUSH1 0x40 0BE3 51 MLOAD 0BE4 60 PUSH1 0x20 0BE6 01 ADD 0BE7 61 PUSH2 0x0bf1 0BEA 92 SWAP3 0BEB 91 SWAP2 0BEC 90 SWAP1 0BED 61 PUSH2 0x167b 0BF0 56 *JUMP 0BF1 5B JUMPDEST 0BF2 60 PUSH1 0x40 0BF4 51 MLOAD 0BF5 60 PUSH1 0x20 0BF7 81 DUP2 0BF8 83 DUP4 0BF9 03 SUB 0BFA 03 SUB 0BFB 81 DUP2 0BFC 52 MSTORE 0BFD 90 SWAP1 0BFE 60 PUSH1 0x40 0C00 52 MSTORE label_0C01: // Incoming jump from 0x0E6F, if 0x00 - stack[-1] // Incoming return from call to 0x111F at 0x1703 // Incoming return from call to 0x1253 at 0x1291 // Incoming return from call to 0x111F at 0x1151 // Incoming return from call to 0x12AB at 0x1347 // Inputs[3] // { // @0C02 stack[-5] // @0C02 stack[-1] // @0C03 stack[-4] // } 0C01 5B JUMPDEST 0C02 93 SWAP4 0C03 92 SWAP3 0C04 50 POP 0C05 50 POP 0C06 50 POP 0C07 56 *JUMP // Stack delta = -4 // Outputs[1] { @0C02 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0C08: // Incoming jump from 0x0402 0C08 5B JUMPDEST 0C09 61 PUSH2 0x0c10 0C0C 61 PUSH2 0x0dbb 0C0F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C09 stack[0] = 0x0c10 } // Block ends with call to 0x0dbb, returns to 0x0C10 label_0C10: // Incoming return from call to 0x0DBB at 0x0C0F // Inputs[2] // { // @0C13 storage[0x0d] // @0C14 stack[-1] // } 0C10 5B JUMPDEST 0C11 60 PUSH1 0x0d 0C13 54 SLOAD 0C14 81 DUP2 0C15 11 GT 0C16 15 ISZERO 0C17 61 PUSH2 0x0c57 0C1A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c57, if !(stack[-1] > storage[0x0d]) label_0C1B: // Incoming jump from 0x0C1A, if not !(stack[-1] > storage[0x0d]) // Inputs[1] { @0C1D memory[0x40:0x60] } 0C1B 60 PUSH1 0x40 0C1D 51 MLOAD 0C1E 62 PUSH3 0x461bcd 0C22 60 PUSH1 0xe5 0C24 1B SHL 0C25 81 DUP2 0C26 52 MSTORE 0C27 60 PUSH1 0x20 0C29 60 PUSH1 0x04 0C2B 82 DUP3 0C2C 01 ADD 0C2D 52 MSTORE 0C2E 60 PUSH1 0x12 0C30 60 PUSH1 0x24 0C32 82 DUP3 0C33 01 ADD 0C34 52 MSTORE 0C35 71 PUSH18 0x4e6f7420656e6f7567682072657365727665 0C48 60 PUSH1 0x70 0C4A 1B SHL 0C4B 60 PUSH1 0x44 0C4D 82 DUP3 0C4E 01 ADD 0C4F 52 MSTORE 0C50 60 PUSH1 0x64 0C52 01 ADD 0C53 61 PUSH2 0x08f3 0C56 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0C26 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C2D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C34 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @0C4F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4e6f7420656e6f7567682072657365727665 << 0x70 // @0C52 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f3 label_0C57: // Incoming jump from 0x0C1A, if !(stack[-1] > storage[0x0d]) // Inputs[2] // { // @0C58 stack[-1] // @0C5F storage[0x0d] // } 0C57 5B JUMPDEST 0C58 80 DUP1 0C59 60 PUSH1 0x0d 0C5B 60 PUSH1 0x00 0C5D 82 DUP3 0C5E 82 DUP3 0C5F 54 SLOAD 0C60 61 PUSH2 0x0c69 0C63 91 SWAP2 0C64 90 SWAP1 0C65 61 PUSH2 0x15fe 0C68 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0C58 stack[0] = stack[-1] // @0C59 stack[1] = 0x0d // @0C5B stack[2] = 0x00 // @0C63 stack[3] = 0x0c69 // @0C64 stack[4] = stack[-1] // @0C64 stack[5] = storage[0x0d] // } // Block ends with call to 0x15fe, returns to 0x0C69 label_0C69: // Incoming return from call to 0x15FE at 0x0C68 // Inputs[6] // { // @0C6A stack[-2] // @0C6A stack[-1] // @0C6B stack[-3] // @0C71 stack[-4] // @0C73 stack[-6] // @0C74 stack[-5] // } 0C69 5B JUMPDEST 0C6A 90 SWAP1 0C6B 91 SWAP2 0C6C 55 SSTORE 0C6D 50 POP 0C6E 61 PUSH2 0x0507 0C71 90 SWAP1 0C72 50 POP 0C73 82 DUP3 0C74 82 DUP3 0C75 61 PUSH2 0x0ef5 0C78 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0C6C storage[stack[-3]] = stack[-1] // @0C71 stack[-4] = 0x0507 // @0C73 stack[-3] = stack[-6] // @0C74 stack[-2] = stack[-5] // } // Block ends with call to 0x0ef5, returns to 0x0507 label_0C79: // Incoming call from 0x0460, returns to 0x01A5 0C79 5B JUMPDEST 0C7A 61 PUSH2 0x0c81 0C7D 61 PUSH2 0x0dbb 0C80 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C7A stack[0] = 0x0c81 } // Block ends with call to 0x0dbb, returns to 0x0C81 label_0C81: // Incoming return from call to 0x0DBB at 0x0C80 // Inputs[1] { @0C84 storage[0x09] } 0C81 5B JUMPDEST 0C82 60 PUSH1 0x09 0C84 54 SLOAD 0C85 60 PUSH1 0x00 0C87 03 SUB 0C88 61 PUSH2 0x0ca3 0C8B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ca3, if 0x00 - storage[0x09] label_0C8C: // Incoming jump from 0x0C8B, if not 0x00 - storage[0x09] // Inputs[1] { @0CA2 stack[-1] } 0C8C 60 PUSH1 0x01 0C8E 60 PUSH1 0x09 0C90 55 SSTORE 0C91 61 PUSH2 0x03e8 0C94 60 PUSH1 0x0a 0C96 55 SSTORE 0C97 66 PUSH7 0xd529ae9e860000 0C9F 60 PUSH1 0x0c 0CA1 55 SSTORE 0CA2 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0C90 storage[0x09] = 0x01 // @0C96 storage[0x0a] = 0x03e8 // @0CA1 storage[0x0c] = 0xd529ae9e860000 // } // Block ends with unconditional jump to stack[-1] label_0CA3: // Incoming jump from 0x0C8B, if 0x00 - storage[0x09] // Inputs[1] { @0CA6 storage[0x09] } 0CA3 5B JUMPDEST 0CA4 60 PUSH1 0x09 0CA6 54 SLOAD 0CA7 60 PUSH1 0x01 0CA9 03 SUB 0CAA 61 PUSH2 0x08a6 0CAD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08a6, if 0x01 - storage[0x09] label_0CAE: // Incoming jump from 0x0CAD, if not 0x01 - storage[0x09] // Inputs[1] { @0CC5 stack[-1] } 0CAE 60 PUSH1 0x02 0CB0 60 PUSH1 0x09 0CB2 55 SSTORE 0CB3 61 PUSH2 0x251c 0CB6 60 PUSH1 0x0a 0CB8 55 SSTORE 0CB9 67 PUSH8 0x013fbe85edc90000 0CC2 60 PUSH1 0x0c 0CC4 55 SSTORE 0CC5 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0CB2 storage[0x09] = 0x02 // @0CB8 storage[0x0a] = 0x251c // @0CC4 storage[0x0c] = 0x013fbe85edc90000 // } // Block ends with unconditional jump to stack[-1] label_0CC6: // Incoming jump from 0x0480 0CC6 5B JUMPDEST 0CC7 61 PUSH2 0x0cce 0CCA 61 PUSH2 0x0dbb 0CCD 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CC7 stack[0] = 0x0cce } // Block ends with call to 0x0dbb, returns to 0x0CCE label_0CCE: // Incoming return from call to 0x0DBB at 0x0CCD // Inputs[1] { @0CD7 stack[-1] } 0CCE 5B JUMPDEST 0CCF 60 PUSH1 0x01 0CD1 60 PUSH1 0x01 0CD3 60 PUSH1 0xa0 0CD5 1B SHL 0CD6 03 SUB 0CD7 81 DUP2 0CD8 16 AND 0CD9 61 PUSH2 0x0d33 0CDC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d33, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0CDD: // Incoming jump from 0x0CDC, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0CDF memory[0x40:0x60] } 0CDD 60 PUSH1 0x40 0CDF 51 MLOAD 0CE0 62 PUSH3 0x461bcd 0CE4 60 PUSH1 0xe5 0CE6 1B SHL 0CE7 81 DUP2 0CE8 52 MSTORE 0CE9 60 PUSH1 0x20 0CEB 60 PUSH1 0x04 0CED 82 DUP3 0CEE 01 ADD 0CEF 52 MSTORE 0CF0 60 PUSH1 0x26 0CF2 60 PUSH1 0x24 0CF4 82 DUP3 0CF5 01 ADD 0CF6 52 MSTORE 0CF7 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 0D18 60 PUSH1 0x44 0D1A 82 DUP3 0D1B 01 ADD 0D1C 52 MSTORE 0D1D 65 PUSH6 0x646472657373 0D24 60 PUSH1 0xd0 0D26 1B SHL 0D27 60 PUSH1 0x64 0D29 82 DUP3 0D2A 01 ADD 0D2B 52 MSTORE 0D2C 60 PUSH1 0x84 0D2E 01 ADD 0D2F 61 PUSH2 0x08f3 0D32 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0CE8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CEF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0CF6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0D1C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @0D2B memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @0D2E stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f3 label_0D33: // Incoming jump from 0x0CDC, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0D37 stack[-1] } 0D33 5B JUMPDEST 0D34 61 PUSH2 0x0aa2 0D37 81 DUP2 0D38 61 PUSH2 0x0ea3 0D3B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D34 stack[0] = 0x0aa2 // @0D37 stack[1] = stack[-1] // } // Block ends with call to 0x0ea3, returns to 0x0AA2 label_0D3C: // Incoming jump from 0x04A0 0D3C 5B JUMPDEST 0D3D 61 PUSH2 0x0d44 0D40 61 PUSH2 0x0dbb 0D43 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D3D stack[0] = 0x0d44 } // Block ends with call to 0x0dbb, returns to 0x0D44 label_0D44: // Incoming return from call to 0x0DBB at 0x0D43 // Inputs[3] // { // @0D45 address(this) // @0D45 address(this).balance // @0D46 stack[-1] // } 0D44 5B JUMPDEST 0D45 47 SELFBALANCE 0D46 81 DUP2 0D47 11 GT 0D48 15 ISZERO 0D49 61 PUSH2 0x0d85 0D4C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d85, if !(stack[-1] > address(this).balance) label_0D4D: // Incoming jump from 0x0D4C, if not !(stack[-1] > address(this).balance) // Inputs[1] { @0D4F memory[0x40:0x60] } 0D4D 60 PUSH1 0x40 0D4F 51 MLOAD 0D50 62 PUSH3 0x461bcd 0D54 60 PUSH1 0xe5 0D56 1B SHL 0D57 81 DUP2 0D58 52 MSTORE 0D59 60 PUSH1 0x20 0D5B 60 PUSH1 0x04 0D5D 82 DUP3 0D5E 01 ADD 0D5F 52 MSTORE 0D60 60 PUSH1 0x0e 0D62 60 PUSH1 0x24 0D64 82 DUP3 0D65 01 ADD 0D66 52 MSTORE 0D67 6D PUSH14 0x09cdee840cadcdeeaced0408aa89 0D76 60 PUSH1 0x93 0D78 1B SHL 0D79 60 PUSH1 0x44 0D7B 82 DUP3 0D7C 01 ADD 0D7D 52 MSTORE 0D7E 60 PUSH1 0x64 0D80 01 ADD 0D81 61 PUSH2 0x08f3 0D84 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0D58 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D5F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D66 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @0D7D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x09cdee840cadcdeeaced0408aa89 << 0x93 // @0D80 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f3 label_0D85: // Incoming jump from 0x0D4C, if !(stack[-1] > address(this).balance) // Inputs[5] // { // @0D88 memory[0x40:0x60] // @0D91 stack[-2] // @0D94 stack[-1] // @0DA5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0DA5 address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } 0D85 5B JUMPDEST 0D86 60 PUSH1 0x40 0D88 51 MLOAD 0D89 60 PUSH1 0x01 0D8B 60 PUSH1 0x01 0D8D 60 PUSH1 0xa0 0D8F 1B SHL 0D90 03 SUB 0D91 83 DUP4 0D92 16 AND 0D93 90 SWAP1 0D94 82 DUP3 0D95 15 ISZERO 0D96 61 PUSH2 0x08fc 0D99 02 MUL 0D9A 90 SWAP1 0D9B 83 DUP4 0D9C 90 SWAP1 0D9D 60 PUSH1 0x00 0D9F 81 DUP2 0DA0 81 DUP2 0DA1 81 DUP2 0DA2 85 DUP6 0DA3 88 DUP9 0DA4 88 DUP9 0DA5 F1 CALL 0DA6 93 SWAP4 0DA7 50 POP 0DA8 50 POP 0DA9 50 POP 0DAA 50 POP 0DAB 15 ISZERO 0DAC 80 DUP1 0DAD 15 ISZERO 0DAE 61 PUSH2 0x0835 0DB1 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0DA5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0DAB stack[0] = !address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x0835, if !!address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_0DB2: // Incoming jump from 0x0DB1, if not !!address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @0DB2 returndata.length // @0DB6 returndata[0x00:0x00 + returndata.length] // @0DB7 returndata.length // @0DBA memory[0x00:0x00 + returndata.length] // } 0DB2 3D RETURNDATASIZE 0DB3 60 PUSH1 0x00 0DB5 80 DUP1 0DB6 3E RETURNDATACOPY 0DB7 3D RETURNDATASIZE 0DB8 60 PUSH1 0x00 0DBA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0DB6 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0DBA revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0DBB: // Incoming call from 0x04FA, returns to 0x04FB // Incoming call from 0x0CCD, returns to 0x0CCE // Incoming call from 0x0C80, returns to 0x0C81 // Incoming call from 0x0C0F, returns to 0x0C10 // Incoming call from 0x08AF, returns to 0x08B0 // Incoming call from 0x089B, returns to 0x089C // Incoming call from 0x0D43, returns to 0x0D44 // Inputs[2] // { // @0DBE storage[0x08] // @0DC8 msg.sender // } 0DBB 5B JUMPDEST 0DBC 60 PUSH1 0x08 0DBE 54 SLOAD 0DBF 60 PUSH1 0x01 0DC1 60 PUSH1 0x01 0DC3 60 PUSH1 0xa0 0DC5 1B SHL 0DC6 03 SUB 0DC7 16 AND 0DC8 33 CALLER 0DC9 14 EQ 0DCA 61 PUSH2 0x08a6 0DCD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08a6, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0DCE: // Incoming jump from 0x0DCD, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0DD0 memory[0x40:0x60] } 0DCE 60 PUSH1 0x40 0DD0 51 MLOAD 0DD1 62 PUSH3 0x461bcd 0DD5 60 PUSH1 0xe5 0DD7 1B SHL 0DD8 81 DUP2 0DD9 52 MSTORE 0DDA 60 PUSH1 0x20 0DDC 60 PUSH1 0x04 0DDE 82 DUP3 0DDF 01 ADD 0DE0 81 DUP2 0DE1 90 SWAP1 0DE2 52 MSTORE 0DE3 60 PUSH1 0x24 0DE5 82 DUP3 0DE6 01 ADD 0DE7 52 MSTORE 0DE8 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0E09 60 PUSH1 0x44 0E0B 82 DUP3 0E0C 01 ADD 0E0D 52 MSTORE 0E0E 60 PUSH1 0x64 0E10 01 ADD 0E11 61 PUSH2 0x08f3 0E14 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0DD9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DE2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DE7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0E0D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0E10 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f3 label_0E15: // Incoming call from 0x05A7, returns to 0x05A8 // Incoming call from 0x0B8E, returns to 0x0B8F // Inputs[2] // { // @0E19 storage[0x00] // @0E1A stack[-1] // } 0E15 5B JUMPDEST 0E16 60 PUSH1 0x00 0E18 80 DUP1 0E19 54 SLOAD 0E1A 82 DUP3 0E1B 10 LT 0E1C 80 DUP1 0E1D 15 ISZERO 0E1E 61 PUSH2 0x04ed 0E21 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0E16 stack[0] = 0x00 // @0E1B stack[1] = stack[-1] < storage[0x00] // } // Block ends with conditional jump to 0x04ed, if !(stack[-1] < storage[0x00]) label_0E22: // Incoming jump from 0x0E21, if not !(stack[-1] < storage[0x00]) // Inputs[4] // { // @0E26 stack[-3] // @0E31 memory[0x00:0x40] // @0E32 storage[keccak256(memory[0x00:0x40])] // @0E3A stack[-4] // } 0E22 50 POP 0E23 50 POP 0E24 60 PUSH1 0x00 0E26 90 SWAP1 0E27 81 DUP2 0E28 52 MSTORE 0E29 60 PUSH1 0x04 0E2B 60 PUSH1 0x20 0E2D 52 MSTORE 0E2E 60 PUSH1 0x40 0E30 90 SWAP1 0E31 20 SHA3 0E32 54 SLOAD 0E33 60 PUSH1 0x01 0E35 60 PUSH1 0xe0 0E37 1B SHL 0E38 16 AND 0E39 15 ISZERO 0E3A 90 SWAP1 0E3B 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0E28 memory[0x00:0x20] = stack[-3] // @0E2D memory[0x20:0x40] = 0x04 // @0E3A stack[-4] = !((0x01 << 0xe0) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-4] label_0E3C: // Incoming call from 0x068B, returns to 0x068C // Incoming call from 0x0844, returns to 0x04ED // Inputs[2] // { // @0E3F stack[-1] // @0E42 storage[0x00] // } 0E3C 5B JUMPDEST 0E3D 60 PUSH1 0x00 0E3F 81 DUP2 0E40 60 PUSH1 0x00 0E42 54 SLOAD 0E43 81 DUP2 0E44 10 LT 0E45 15 ISZERO 0E46 61 PUSH2 0x0e8a 0E49 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0E3D stack[0] = 0x00 // @0E3F stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0e8a, if !(stack[-1] < storage[0x00]) label_0E4A: // Incoming jump from 0x0E49, if not !(stack[-1] < storage[0x00]) // Inputs[3] // { // @0E4C stack[-1] // @0E57 memory[0x00:0x40] // @0E58 storage[keccak256(memory[0x00:0x40])] // } 0E4A 60 PUSH1 0x00 0E4C 81 DUP2 0E4D 81 DUP2 0E4E 52 MSTORE 0E4F 60 PUSH1 0x04 0E51 60 PUSH1 0x20 0E53 52 MSTORE 0E54 60 PUSH1 0x40 0E56 81 DUP2 0E57 20 SHA3 0E58 54 SLOAD 0E59 90 SWAP1 0E5A 60 PUSH1 0x01 0E5C 60 PUSH1 0xe0 0E5E 1B SHL 0E5F 82 DUP3 0E60 16 AND 0E61 90 SWAP1 0E62 03 SUB 0E63 61 PUSH2 0x0e88 0E66 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0E4E memory[0x00:0x20] = stack[-1] // @0E53 memory[0x20:0x40] = 0x04 // @0E59 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0e88, if 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) label_0E67: // Incoming jump from 0x0E87 // Incoming jump from 0x0E66, if not 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) // Inputs[1] { @0E68 stack[-1] } 0E67 5B JUMPDEST 0E68 80 DUP1 0E69 60 PUSH1 0x00 0E6B 03 SUB 0E6C 61 PUSH2 0x0c01 0E6F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c01, if 0x00 - stack[-1] label_0E70: // Incoming jump from 0x0E6F, if not 0x00 - stack[-1] // Inputs[3] // { // @0E74 stack[-2] // @0E82 memory[0x00:0x40] // @0E83 storage[keccak256(memory[0x00:0x40])] // } 0E70 50 POP 0E71 60 PUSH1 0x00 0E73 19 NOT 0E74 01 ADD 0E75 60 PUSH1 0x00 0E77 81 DUP2 0E78 81 DUP2 0E79 52 MSTORE 0E7A 60 PUSH1 0x04 0E7C 60 PUSH1 0x20 0E7E 52 MSTORE 0E7F 60 PUSH1 0x40 0E81 90 SWAP1 0E82 20 SHA3 0E83 54 SLOAD 0E84 61 PUSH2 0x0e67 0E87 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0E74 stack[-2] = ~0x00 + stack[-2] // @0E79 memory[0x00:0x20] = ~0x00 + stack[-2] // @0E7E memory[0x20:0x40] = 0x04 // @0E83 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x0e67 label_0E88: // Incoming jump from 0x0E66, if 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) 0E88 5B JUMPDEST 0E89 50 POP // Stack delta = -1 // Block continues label_0E8A: // Incoming jump from 0x0E89 // Incoming jump from 0x0E49, if !(stack[-1] < storage[0x00]) // Inputs[3] // { // @0E8D memory[0x40:0x60] // @0E9D memory[0x40:0x60] // @0EA2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E8A 5B JUMPDEST 0E8B 60 PUSH1 0x40 0E8D 51 MLOAD 0E8E 63 PUSH4 0x6f96cda1 0E93 60 PUSH1 0xe1 0E95 1B SHL 0E96 81 DUP2 0E97 52 MSTORE 0E98 60 PUSH1 0x04 0E9A 01 ADD 0E9B 60 PUSH1 0x40 0E9D 51 MLOAD 0E9E 80 DUP1 0E9F 91 SWAP2 0EA0 03 SUB 0EA1 90 SWAP1 0EA2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0E97 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @0EA2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0EA3: // Incoming call from 0x0D3B, returns to 0x0AA2 // Incoming call from 0x08A5, returns to 0x08A6 // Inputs[5] // { // @0EA7 storage[0x08] // @0EB0 stack[-1] // @0EC5 memory[0x40:0x60] // @0EF1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0EF4 stack[-2] // } 0EA3 5B JUMPDEST 0EA4 60 PUSH1 0x08 0EA6 80 DUP1 0EA7 54 SLOAD 0EA8 60 PUSH1 0x01 0EAA 60 PUSH1 0x01 0EAC 60 PUSH1 0xa0 0EAE 1B SHL 0EAF 03 SUB 0EB0 83 DUP4 0EB1 81 DUP2 0EB2 16 AND 0EB3 60 PUSH1 0x01 0EB5 60 PUSH1 0x01 0EB7 60 PUSH1 0xa0 0EB9 1B SHL 0EBA 03 SUB 0EBB 19 NOT 0EBC 83 DUP4 0EBD 16 AND 0EBE 81 DUP2 0EBF 17 OR 0EC0 90 SWAP1 0EC1 93 SWAP4 0EC2 55 SSTORE 0EC3 60 PUSH1 0x40 0EC5 51 MLOAD 0EC6 91 SWAP2 0EC7 16 AND 0EC8 91 SWAP2 0EC9 90 SWAP1 0ECA 82 DUP3 0ECB 90 SWAP1 0ECC 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 0EED 90 SWAP1 0EEE 60 PUSH1 0x00 0EF0 90 SWAP1 0EF1 A3 LOG3 0EF2 50 POP 0EF3 50 POP 0EF4 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0EC2 storage[0x08] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x08] & ~((0x01 << 0xa0) - 0x01)) // @0EF1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x08] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_0EF5: // Incoming call from 0x0C78, returns to 0x0507 // Incoming call from 0x0AA1, returns to 0x0AA2 // Incoming jump from 0x0952 // Inputs[2] // { // @0EF8 storage[0x00] // @0F01 stack[-2] // } 0EF5 5B JUMPDEST 0EF6 60 PUSH1 0x00 0EF8 54 SLOAD 0EF9 60 PUSH1 0x01 0EFB 60 PUSH1 0x01 0EFD 60 PUSH1 0xa0 0EFF 1B SHL 0F00 03 SUB 0F01 83 DUP4 0F02 16 AND 0F03 61 PUSH2 0x0f1e 0F06 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0EF8 stack[0] = storage[0x00] } // Block ends with conditional jump to 0x0f1e, if stack[-2] & (0x01 << 0xa0) - 0x01 label_0F07: // Incoming jump from 0x0F06, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0F09 memory[0x40:0x60] // @0F18 memory[0x40:0x60] // @0F1D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F07 60 PUSH1 0x40 0F09 51 MLOAD 0F0A 62 PUSH3 0x2e0763 0F0E 60 PUSH1 0xe8 0F10 1B SHL 0F11 81 DUP2 0F12 52 MSTORE 0F13 60 PUSH1 0x04 0F15 01 ADD 0F16 60 PUSH1 0x40 0F18 51 MLOAD 0F19 80 DUP1 0F1A 91 SWAP2 0F1B 03 SUB 0F1C 90 SWAP1 0F1D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F12 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e0763 << 0xe8 // @0F1D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F1E: // Incoming jump from 0x0F06, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0F1F stack[-2] } 0F1E 5B JUMPDEST 0F1F 81 DUP2 0F20 60 PUSH1 0x00 0F22 03 SUB 0F23 61 PUSH2 0x0f3f 0F26 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f3f, if 0x00 - stack[-2] label_0F27: // Incoming jump from 0x0F26, if not 0x00 - stack[-2] // Inputs[3] // { // @0F29 memory[0x40:0x60] // @0F39 memory[0x40:0x60] // @0F3E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F27 60 PUSH1 0x40 0F29 51 MLOAD 0F2A 63 PUSH4 0xb562e8dd 0F2F 60 PUSH1 0xe0 0F31 1B SHL 0F32 81 DUP2 0F33 52 MSTORE 0F34 60 PUSH1 0x04 0F36 01 ADD 0F37 60 PUSH1 0x40 0F39 51 MLOAD 0F3A 80 DUP1 0F3B 91 SWAP2 0F3C 03 SUB 0F3D 90 SWAP1 0F3E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F33 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd << 0xe0 // @0F3E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F3F: // Incoming jump from 0x0F26, if 0x00 - stack[-2] // Inputs[9] // { // @0F48 stack[-3] // @0F57 memory[0x00:0x40] // @0F59 storage[keccak256(memory[0x00:0x40])] // @0F64 stack[-2] // @0F69 block.timestamp // @0F78 stack[-1] // @0F83 memory[0x00:0x40] // @0F8C memory[0x40:0x60] // @0FC5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // } 0F3F 5B JUMPDEST 0F40 60 PUSH1 0x01 0F42 60 PUSH1 0x01 0F44 60 PUSH1 0xa0 0F46 1B SHL 0F47 03 SUB 0F48 83 DUP4 0F49 16 AND 0F4A 60 PUSH1 0x00 0F4C 81 DUP2 0F4D 81 DUP2 0F4E 52 MSTORE 0F4F 60 PUSH1 0x05 0F51 60 PUSH1 0x20 0F53 52 MSTORE 0F54 60 PUSH1 0x40 0F56 90 SWAP1 0F57 20 SHA3 0F58 80 DUP1 0F59 54 SLOAD 0F5A 68 PUSH9 0x010000000000000001 0F64 85 DUP6 0F65 02 MUL 0F66 01 ADD 0F67 90 SWAP1 0F68 55 SSTORE 0F69 42 TIMESTAMP 0F6A 60 PUSH1 0xa0 0F6C 1B SHL 0F6D 60 PUSH1 0x01 0F6F 84 DUP5 0F70 14 EQ 0F71 60 PUSH1 0xe1 0F73 1B SHL 0F74 17 OR 0F75 17 OR 0F76 60 PUSH1 0x00 0F78 82 DUP3 0F79 81 DUP2 0F7A 52 MSTORE 0F7B 60 PUSH1 0x04 0F7D 60 PUSH1 0x20 0F7F 52 MSTORE 0F80 60 PUSH1 0x40 0F82 90 SWAP1 0F83 20 SHA3 0F84 55 SSTORE 0F85 80 DUP1 0F86 82 DUP3 0F87 81 DUP2 0F88 01 ADD 0F89 5B JUMPDEST 0F8A 60 PUSH1 0x40 0F8C 51 MLOAD 0F8D 60 PUSH1 0x01 0F8F 83 DUP4 0F90 01 ADD 0F91 92 SWAP3 0F92 90 SWAP1 0F93 60 PUSH1 0x01 0F95 60 PUSH1 0x01 0F97 60 PUSH1 0xa0 0F99 1B SHL 0F9A 03 SUB 0F9B 87 DUP8 0F9C 16 AND 0F9D 90 SWAP1 0F9E 60 PUSH1 0x00 0FA0 90 SWAP1 0FA1 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0FC2 90 SWAP1 0FC3 82 DUP3 0FC4 90 SWAP1 0FC5 A4 LOG4 0FC6 80 DUP1 0FC7 82 DUP3 0FC8 10 LT 0FC9 61 PUSH2 0x0f89 0FCC 57 *JUMPI // Stack delta = +2 // Outputs[9] // { // @0F4E memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0F53 memory[0x20:0x40] = 0x05 // @0F68 storage[keccak256(memory[0x00:0x40])] = stack[-2] * 0x010000000000000001 + storage[keccak256(memory[0x00:0x40])] // @0F7A memory[0x00:0x20] = stack[-1] // @0F7F memory[0x20:0x40] = 0x04 // @0F84 storage[keccak256(memory[0x00:0x40])] = ((stack[-2] == 0x01) << 0xe1) | (block.timestamp << 0xa0) | (stack[-3] & (0x01 << 0xa0) - 0x01) // @0F88 stack[1] = stack[-1] + stack[-2] // @0F91 stack[0] = stack[-1] + 0x01 // @0FC5 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-1]]); // } // Block ends with conditional jump to 0x0f89, if stack[-1] + 0x01 < stack[-1] + stack[-2] label_0FCD: // Incoming jump from 0x0FCC, if not stack[-1] + 0x01 < stack[-1] + stack[-2] // Incoming jump from 0x0FCC, if not stack[-2] + 0x01 < stack[-1] // Inputs[2] // { // @0FCF stack[-1] // @0FD4 stack[-6] // } 0FCD 60 PUSH1 0x00 0FCF 55 SSTORE 0FD0 50 POP 0FD1 50 POP 0FD2 50 POP 0FD3 50 POP 0FD4 56 *JUMP // Stack delta = -6 // Outputs[1] { @0FCF storage[0x00] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0FD5: // Incoming jump from 0x0B60 // Inputs[6] // { // @0FD8 memory[0x40:0x60] // @0FEE stack[-3] // @0FFB msg.sender // @0FFD stack[-4] // @0FFF stack[-2] // @1001 stack[-1] // } 0FD5 5B JUMPDEST 0FD6 60 PUSH1 0x40 0FD8 51 MLOAD 0FD9 63 PUSH4 0x0a85bd01 0FDE 60 PUSH1 0xe1 0FE0 1B SHL 0FE1 81 DUP2 0FE2 52 MSTORE 0FE3 60 PUSH1 0x00 0FE5 90 SWAP1 0FE6 60 PUSH1 0x01 0FE8 60 PUSH1 0x01 0FEA 60 PUSH1 0xa0 0FEC 1B SHL 0FED 03 SUB 0FEE 85 DUP6 0FEF 16 AND 0FF0 90 SWAP1 0FF1 63 PUSH4 0x150b7a02 0FF6 90 SWAP1 0FF7 61 PUSH2 0x100a 0FFA 90 SWAP1 0FFB 33 CALLER 0FFC 90 SWAP1 0FFD 89 DUP10 0FFE 90 SWAP1 0FFF 88 DUP9 1000 90 SWAP1 1001 88 DUP9 1002 90 SWAP1 1003 60 PUSH1 0x04 1005 01 ADD 1006 61 PUSH2 0x16aa 1009 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @0FE2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @0FE5 stack[0] = 0x00 // @0FF0 stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0FF6 stack[2] = 0x150b7a02 // @0FFA stack[3] = 0x100a // @0FFC stack[4] = msg.sender // @0FFE stack[5] = stack[-4] // @1000 stack[6] = stack[-2] // @1002 stack[7] = stack[-1] // @1005 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x16aa, returns to 0x100A label_100A: // Incoming return from call to 0x16AA at 0x1009 // Inputs[6] // { // @100F memory[0x40:0x60] // @1011 stack[-1] // @1016 stack[-3] // @1017 msg.gas // @1018 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @1018 address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } 100A 5B JUMPDEST 100B 60 PUSH1 0x20 100D 60 PUSH1 0x40 100F 51 MLOAD 1010 80 DUP1 1011 83 DUP4 1012 03 SUB 1013 81 DUP2 1014 60 PUSH1 0x00 1016 87 DUP8 1017 5A GAS 1018 F1 CALL 1019 92 SWAP3 101A 50 POP 101B 50 POP 101C 50 POP 101D 80 DUP1 101E 15 ISZERO 101F 61 PUSH2 0x1045 1022 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1018 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1019 stack[-3] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x1045, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_1023: // Incoming jump from 0x1022, if not !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[2] // { // @1027 memory[0x40:0x60] // @102A returndata.length // } 1023 50 POP 1024 60 PUSH1 0x40 1026 80 DUP1 1027 51 MLOAD 1028 60 PUSH1 0x1f 102A 3D RETURNDATASIZE 102B 90 SWAP1 102C 81 DUP2 102D 01 ADD 102E 60 PUSH1 0x1f 1030 19 NOT 1031 16 AND 1032 82 DUP3 1033 01 ADD 1034 90 SWAP1 1035 92 SWAP3 1036 52 MSTORE 1037 61 PUSH2 0x1042 103A 91 SWAP2 103B 81 DUP2 103C 01 ADD 103D 90 SWAP1 103E 61 PUSH2 0x16e7 1041 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1036 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @103A stack[-1] = 0x1042 // @103D stack[1] = memory[0x40:0x60] // @103D stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x16e7 1042 5B JUMPDEST 1043 60 PUSH1 0x01 label_1045: // Incoming jump from 0x1022, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[1] { @1049 stack[-1] } 1045 5B JUMPDEST 1046 61 PUSH2 0x10a3 1049 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x10a3, if stack[-1] label_104A: // Incoming jump from 0x1049, if not stack[-1] // Inputs[1] { @104A returndata.length } 104A 3D RETURNDATASIZE 104B 80 DUP1 104C 80 DUP1 104D 15 ISZERO 104E 61 PUSH2 0x1073 1051 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @104A stack[0] = returndata.length // @104B stack[1] = returndata.length // } // Block ends with conditional jump to 0x1073, if !returndata.length label_1052: // Incoming jump from 0x1051, if not !returndata.length // Inputs[6] // { // @1054 memory[0x40:0x60] // @1055 stack[-2] // @105C returndata.length // @1064 returndata.length // @1067 returndata.length // @106E returndata[0x00:0x00 + returndata.length] // } 1052 60 PUSH1 0x40 1054 51 MLOAD 1055 91 SWAP2 1056 50 POP 1057 60 PUSH1 0x1f 1059 19 NOT 105A 60 PUSH1 0x3f 105C 3D RETURNDATASIZE 105D 01 ADD 105E 16 AND 105F 82 DUP3 1060 01 ADD 1061 60 PUSH1 0x40 1063 52 MSTORE 1064 3D RETURNDATASIZE 1065 82 DUP3 1066 52 MSTORE 1067 3D RETURNDATASIZE 1068 60 PUSH1 0x00 106A 60 PUSH1 0x20 106C 84 DUP5 106D 01 ADD 106E 3E RETURNDATACOPY 106F 61 PUSH2 0x1078 1072 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1055 stack[-2] = memory[0x40:0x60] // @1063 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1066 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @106E memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1078 label_1073: // Incoming jump from 0x1051, if !returndata.length // Inputs[2] // { // @1076 stack[-2] // @107B memory[0x60:0x80] // } 1073 5B JUMPDEST 1074 60 PUSH1 0x60 1076 91 SWAP2 1077 50 POP 1078 5B JUMPDEST 1079 50 POP 107A 80 DUP1 107B 51 MLOAD 107C 60 PUSH1 0x00 107E 03 SUB 107F 61 PUSH2 0x109b 1082 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1076 stack[-2] = 0x60 } // Block ends with conditional jump to 0x109b, if 0x00 - memory[0x60:0x80] label_1083: // Incoming jump from 0x1082, if not 0x00 - memory[0x60:0x80] // Incoming jump from 0x1082, if not 0x00 - memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @1085 memory[0x40:0x60] // @1095 memory[0x40:0x60] // @109A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1083 60 PUSH1 0x40 1085 51 MLOAD 1086 63 PUSH4 0x68d2bf6b 108B 60 PUSH1 0xe1 108D 1B SHL 108E 81 DUP2 108F 52 MSTORE 1090 60 PUSH1 0x04 1092 01 ADD 1093 60 PUSH1 0x40 1095 51 MLOAD 1096 80 DUP1 1097 91 SWAP2 1098 03 SUB 1099 90 SWAP1 109A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @108F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @109A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_109B: // Incoming jump from 0x1082, if 0x00 - memory[0x60:0x80] // Incoming jump from 0x1082, if 0x00 - memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @109C stack[-1] // @109D memory[stack[-1]:stack[-1] + 0x20] // @10A2 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 109B 5B JUMPDEST 109C 80 DUP1 109D 51 MLOAD 109E 81 DUP2 109F 60 PUSH1 0x20 10A1 01 ADD 10A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @10A2 revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_10A3: // Incoming jump from 0x1049, if stack[-1] // Inputs[2] // { // @10AD stack[-1] // @10B7 stack[-2] // } 10A3 5B JUMPDEST 10A4 60 PUSH1 0x01 10A6 60 PUSH1 0x01 10A8 60 PUSH1 0xe0 10AA 1B SHL 10AB 03 SUB 10AC 19 NOT 10AD 16 AND 10AE 63 PUSH4 0x0a85bd01 10B3 60 PUSH1 0xe1 10B5 1B SHL 10B6 14 EQ 10B7 90 SWAP1 10B8 50 POP // Stack delta = -1 // Outputs[1] { @10B7 stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block continues label_10B9: // Incoming return from call to 0x1168 at 0x1226 // Incoming jump from 0x10B8 // Inputs[3] // { // @10BA stack[-6] // @10BA stack[-1] // @10BB stack[-5] // } 10B9 5B JUMPDEST 10BA 94 SWAP5 10BB 93 SWAP4 10BC 50 POP 10BD 50 POP 10BE 50 POP 10BF 50 POP 10C0 56 *JUMP // Stack delta = -5 // Outputs[1] { @10BA stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_10C1: // Incoming jump from 0x0BB5 // Inputs[1] { @10C7 storage[0x0e] } 10C1 5B JUMPDEST 10C2 60 PUSH1 0x60 10C4 60 PUSH1 0x0e 10C6 80 DUP1 10C7 54 SLOAD 10C8 61 PUSH2 0x051a 10CB 90 SWAP1 10CC 61 PUSH2 0x14a8 10CF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @10C2 stack[0] = 0x60 // @10C4 stack[1] = 0x0e // @10CB stack[2] = 0x051a // @10CB stack[3] = storage[0x0e] // } // Block ends with call to 0x14a8, returns to 0x051A 10D0 5B JUMPDEST 10D1 60 PUSH1 0x40 10D3 80 DUP1 10D4 51 MLOAD 10D5 60 PUSH1 0x80 10D7 81 DUP2 10D8 01 ADD 10D9 91 SWAP2 10DA 82 DUP3 10DB 90 SWAP1 10DC 52 MSTORE 10DD 60 PUSH1 0x7f 10DF 01 ADD 10E0 90 SWAP1 10E1 82 DUP3 10E2 60 PUSH1 0x30 10E4 60 PUSH1 0x0a 10E6 82 DUP3 10E7 06 MOD 10E8 01 ADD 10E9 83 DUP4 10EA 53 MSTORE8 10EB 60 PUSH1 0x0a 10ED 90 SWAP1 10EE 04 DIV 10EF 5B JUMPDEST 10F0 80 DUP1 10F1 15 ISZERO 10F2 61 PUSH2 0x110d 10F5 57 *JUMPI 10F6 60 PUSH1 0x01 10F8 83 DUP4 10F9 03 SUB 10FA 92 SWAP3 10FB 50 POP 10FC 60 PUSH1 0x0a 10FE 81 DUP2 10FF 06 MOD 1100 60 PUSH1 0x30 1102 01 ADD 1103 83 DUP4 1104 53 MSTORE8 1105 60 PUSH1 0x0a 1107 90 SWAP1 1108 04 DIV 1109 61 PUSH2 0x10ef 110C 56 *JUMP 110D 5B JUMPDEST 110E 50 POP 110F 81 DUP2 1110 90 SWAP1 1111 03 SUB 1112 60 PUSH1 0x1f 1114 19 NOT 1115 90 SWAP1 1116 91 SWAP2 1117 01 ADD 1118 90 SWAP1 1119 81 DUP2 111A 52 MSTORE 111B 91 SWAP2 111C 90 SWAP1 111D 50 POP 111E 56 *JUMP label_111F: // Incoming call from 0x1151, returns to 0x0C01 // Incoming call from 0x1703, returns to 0x0C01 // Inputs[1] { @1129 stack[-1] } 111F 5B JUMPDEST 1120 60 PUSH1 0x01 1122 60 PUSH1 0x01 1124 60 PUSH1 0xe0 1126 1B SHL 1127 03 SUB 1128 19 NOT 1129 81 DUP2 112A 16 AND 112B 81 DUP2 112C 14 EQ 112D 61 PUSH2 0x0aa2 1130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0aa2, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1131: // Incoming jump from 0x1130, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1134 memory[0x00:0x00] } 1131 60 PUSH1 0x00 1133 80 DUP1 1134 FD *REVERT // Stack delta = +0 // Outputs[1] { @1134 revert(memory[0x00:0x00]); } // Block terminates label_1135: // Incoming call from 0x016A, returns to 0x016B // Inputs[2] // { // @113A stack[-1] // @113B stack[-2] // } 1135 5B JUMPDEST 1136 60 PUSH1 0x00 1138 60 PUSH1 0x20 113A 82 DUP3 113B 84 DUP5 113C 03 SUB 113D 12 SLT 113E 15 ISZERO 113F 61 PUSH2 0x1147 1142 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1136 stack[0] = 0x00 } // Block ends with conditional jump to 0x1147, if !(stack[-2] - stack[-1] i< 0x20) label_1143: // Incoming jump from 0x1142, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1146 memory[0x00:0x00] } 1143 60 PUSH1 0x00 1145 80 DUP1 1146 FD *REVERT // Stack delta = +0 // Outputs[1] { @1146 revert(memory[0x00:0x00]); } // Block terminates label_1147: // Incoming jump from 0x1142, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1148 stack[-2] // @1149 msg.data[stack[-2]:stack[-2] + 0x20] // } 1147 5B JUMPDEST 1148 81 DUP2 1149 35 CALLDATALOAD 114A 61 PUSH2 0x0c01 114D 81 DUP2 114E 61 PUSH2 0x111f 1151 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1149 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @114A stack[1] = 0x0c01 // @114D stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x111f, returns to 0x0C01 label_1152: // Incoming jump from 0x1182 // Incoming jump from 0x1541 // Incoming jump from 0x11AA // Inputs[1] { @1167 memory[0x00:0x24] } 1152 5B JUMPDEST 1153 63 PUSH4 0x4e487b71 1158 60 PUSH1 0xe0 115A 1B SHL 115B 60 PUSH1 0x00 115D 52 MSTORE 115E 60 PUSH1 0x41 1160 60 PUSH1 0x04 1162 52 MSTORE 1163 60 PUSH1 0x24 1165 60 PUSH1 0x00 1167 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @115D memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1162 memory[0x04:0x24] = 0x41 // @1167 revert(memory[0x00:0x24]); // } // Block terminates label_1168: // Incoming call from 0x1226, returns to 0x10B9 // Incoming call from 0x1468, returns to 0x1469 // Inputs[1] { @1175 stack[-2] } 1168 5B JUMPDEST 1169 60 PUSH1 0x00 116B 67 PUSH8 0xffffffffffffffff 1174 80 DUP1 1175 84 DUP5 1176 11 GT 1177 15 ISZERO 1178 61 PUSH2 0x1183 117B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1169 stack[0] = 0x00 // @116B stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1183, if !(stack[-2] > 0xffffffffffffffff) label_117C: // Incoming jump from 0x117B, if not !(stack[-2] > 0xffffffffffffffff) 117C 61 PUSH2 0x1183 117F 61 PUSH2 0x1152 1182 56 *JUMP // Stack delta = +1 // Outputs[1] { @117C stack[0] = 0x1183 } // Block ends with unconditional jump to 0x1152 label_1183: // Incoming jump from 0x117B, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @1186 memory[0x40:0x60] // @1189 stack[-4] // @1198 stack[-1] // } 1183 5B JUMPDEST 1184 60 PUSH1 0x40 1186 51 MLOAD 1187 60 PUSH1 0x1f 1189 85 DUP6 118A 01 ADD 118B 60 PUSH1 0x1f 118D 19 NOT 118E 90 SWAP1 118F 81 DUP2 1190 16 AND 1191 60 PUSH1 0x3f 1193 01 ADD 1194 16 AND 1195 81 DUP2 1196 01 ADD 1197 90 SWAP1 1198 82 DUP3 1199 82 DUP3 119A 11 GT 119B 81 DUP2 119C 83 DUP4 119D 10 LT 119E 17 OR 119F 15 ISZERO 11A0 61 PUSH2 0x11ab 11A3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1197 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @1197 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x11ab, 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_11A4: // Incoming jump from 0x11A3, 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])) 11A4 61 PUSH2 0x11ab 11A7 61 PUSH2 0x1152 11AA 56 *JUMP // Stack delta = +1 // Outputs[1] { @11A4 stack[0] = 0x11ab } // Block ends with unconditional jump to 0x1152 label_11AB: // Incoming jump from 0x11A3, 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] // { // @11AC stack[-2] // @11B0 stack[-1] // @11B1 stack[-4] // @11B3 stack[-6] // @11B6 stack[-7] // @11B8 stack[-5] // } 11AB 5B JUMPDEST 11AC 81 DUP2 11AD 60 PUSH1 0x40 11AF 52 MSTORE 11B0 80 DUP1 11B1 93 SWAP4 11B2 50 POP 11B3 85 DUP6 11B4 81 DUP2 11B5 52 MSTORE 11B6 86 DUP7 11B7 86 DUP7 11B8 86 DUP7 11B9 01 ADD 11BA 11 GT 11BB 15 ISZERO 11BC 61 PUSH2 0x11c4 11BF 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @11AF memory[0x40:0x60] = stack[-2] // @11B1 stack[-4] = stack[-1] // @11B5 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x11c4, if !(stack[-5] + stack[-6] > stack[-7]) label_11C0: // Incoming jump from 0x11BF, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @11C3 memory[0x00:0x00] } 11C0 60 PUSH1 0x00 11C2 80 DUP1 11C3 FD *REVERT // Stack delta = +0 // Outputs[1] { @11C3 revert(memory[0x00:0x00]); } // Block terminates label_11C4: // Incoming jump from 0x11BF, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @11C5 stack[-6] // @11C6 stack[-5] // @11C9 stack[-1] // @11CB msg.data[stack[-5]:stack[-5] + stack[-6]] // @11D8 stack[-4] // @11D8 stack[-8] // @11D9 stack[-7] // } 11C4 5B JUMPDEST 11C5 85 DUP6 11C6 85 DUP6 11C7 60 PUSH1 0x20 11C9 83 DUP4 11CA 01 ADD 11CB 37 CALLDATACOPY 11CC 60 PUSH1 0x00 11CE 60 PUSH1 0x20 11D0 87 DUP8 11D1 83 DUP4 11D2 01 ADD 11D3 01 ADD 11D4 52 MSTORE 11D5 50 POP 11D6 50 POP 11D7 50 POP 11D8 93 SWAP4 11D9 92 SWAP3 11DA 50 POP 11DB 50 POP 11DC 50 POP 11DD 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @11CB memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @11D4 memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @11D8 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_11DE: // Incoming call from 0x019F, returns to 0x01A0 // Inputs[2] // { // @11E3 stack[-1] // @11E4 stack[-2] // } 11DE 5B JUMPDEST 11DF 60 PUSH1 0x00 11E1 60 PUSH1 0x20 11E3 82 DUP3 11E4 84 DUP5 11E5 03 SUB 11E6 12 SLT 11E7 15 ISZERO 11E8 61 PUSH2 0x11f0 11EB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @11DF stack[0] = 0x00 } // Block ends with conditional jump to 0x11f0, if !(stack[-2] - stack[-1] i< 0x20) label_11EC: // Incoming jump from 0x11EB, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @11EF memory[0x00:0x00] } 11EC 60 PUSH1 0x00 11EE 80 DUP1 11EF FD *REVERT // Stack delta = +0 // Outputs[1] { @11EF revert(memory[0x00:0x00]); } // Block terminates label_11F0: // Incoming jump from 0x11EB, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @11F1 stack[-2] // @11F2 msg.data[stack[-2]:stack[-2] + 0x20] // } 11F0 5B JUMPDEST 11F1 81 DUP2 11F2 35 CALLDATALOAD 11F3 67 PUSH8 0xffffffffffffffff 11FC 81 DUP2 11FD 11 GT 11FE 15 ISZERO 11FF 61 PUSH2 0x1207 1202 57 *JUMPI // Stack delta = +1 // Outputs[1] { @11F2 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1207, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1203: // Incoming jump from 0x1202, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1206 memory[0x00:0x00] } 1203 60 PUSH1 0x00 1205 80 DUP1 1206 FD *REVERT // Stack delta = +0 // Outputs[1] { @1206 revert(memory[0x00:0x00]); } // Block terminates label_1207: // Incoming jump from 0x1202, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1208 stack[-3] // @1209 stack[-1] // @120E stack[-4] // } 1207 5B JUMPDEST 1208 82 DUP3 1209 01 ADD 120A 60 PUSH1 0x1f 120C 81 DUP2 120D 01 ADD 120E 84 DUP5 120F 13 SGT 1210 61 PUSH2 0x1218 1213 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1209 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1218, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_1214: // Incoming jump from 0x1213, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @1217 memory[0x00:0x00] } 1214 60 PUSH1 0x00 1216 80 DUP1 1217 FD *REVERT // Stack delta = +0 // Outputs[1] { @1217 revert(memory[0x00:0x00]); } // Block terminates label_1218: // Incoming jump from 0x1213, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @121C stack[-4] // @121D stack[-1] // @121E msg.data[stack[-1]:stack[-1] + 0x20] // } 1218 5B JUMPDEST 1219 61 PUSH2 0x10b9 121C 84 DUP5 121D 82 DUP3 121E 35 CALLDATALOAD 121F 60 PUSH1 0x20 1221 84 DUP5 1222 01 ADD 1223 61 PUSH2 0x1168 1226 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1219 stack[0] = 0x10b9 // @121C stack[1] = stack[-4] // @121E stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1222 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1168, returns to 0x10B9 label_1227: // Incoming call from 0x126A, returns to 0x126B // Inputs[1] { @122B stack[-3] } 1227 5B JUMPDEST 1228 60 PUSH1 0x00 122A 5B JUMPDEST 122B 83 DUP4 122C 81 DUP2 122D 10 LT 122E 15 ISZERO 122F 61 PUSH2 0x1242 1232 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1228 stack[0] = 0x00 } // Block ends with conditional jump to 0x1242, if !(0x00 < stack[-3]) label_1233: // Incoming jump from 0x1232, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1232, if not !(0x00 < stack[-3]) // Inputs[4] // { // @1233 stack[-2] // @1234 stack[-1] // @1236 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1237 stack[-3] // } 1233 81 DUP2 1234 81 DUP2 1235 01 ADD 1236 51 MLOAD 1237 83 DUP4 1238 82 DUP3 1239 01 ADD 123A 52 MSTORE 123B 60 PUSH1 0x20 123D 01 ADD 123E 61 PUSH2 0x122a 1241 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @123A memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @123D stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x122a label_1242: // Incoming jump from 0x1232, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1232, if !(0x00 < stack[-3]) // Inputs[2] // { // @1243 stack[-4] // @1244 stack[-1] // } 1242 5B JUMPDEST 1243 83 DUP4 1244 81 DUP2 1245 11 GT 1246 15 ISZERO 1247 61 PUSH2 0x0b7e 124A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b7e, if !(stack[-1] > stack[-4]) label_124B: // Incoming jump from 0x124A, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @124F stack[-4] // @1250 stack[-3] // @1252 stack[-5] // } 124B 50 POP 124C 50 POP 124D 60 PUSH1 0x00 124F 91 SWAP2 1250 01 ADD 1251 52 MSTORE 1252 56 *JUMP // Stack delta = -5 // Outputs[1] { @1251 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1253: // Incoming call from 0x1291, returns to 0x0C01 // Incoming call from 0x16DC, returns to 0x16DD // Inputs[3] // { // @1256 stack[-1] // @1257 memory[stack[-1]:stack[-1] + 0x20] // @1259 stack[-2] // } 1253 5B JUMPDEST 1254 60 PUSH1 0x00 1256 81 DUP2 1257 51 MLOAD 1258 80 DUP1 1259 84 DUP5 125A 52 MSTORE 125B 61 PUSH2 0x126b 125E 81 DUP2 125F 60 PUSH1 0x20 1261 86 DUP7 1262 01 ADD 1263 60 PUSH1 0x20 1265 86 DUP7 1266 01 ADD 1267 61 PUSH2 0x1227 126A 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1254 stack[0] = 0x00 // @1257 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @125A memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @125B stack[2] = 0x126b // @125E stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1262 stack[4] = stack[-2] + 0x20 // @1266 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x1227, returns to 0x126B label_126B: // Incoming return from call to 0x1227 at 0x126A // Inputs[4] // { // @126E stack[-1] // @1273 stack[-4] // @1274 stack[-2] // @127A stack[-5] // } 126B 5B JUMPDEST 126C 60 PUSH1 0x1f 126E 01 ADD 126F 60 PUSH1 0x1f 1271 19 NOT 1272 16 AND 1273 92 SWAP3 1274 90 SWAP1 1275 92 SWAP3 1276 01 ADD 1277 60 PUSH1 0x20 1279 01 ADD 127A 92 SWAP3 127B 91 SWAP2 127C 50 POP 127D 50 POP 127E 56 *JUMP // Stack delta = -4 // Outputs[1] { @127A stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_127F: // Incoming jump from 0x01C8 // Inputs[2] // { // @1282 stack[-1] // @128D stack[-2] // } 127F 5B JUMPDEST 1280 60 PUSH1 0x20 1282 81 DUP2 1283 52 MSTORE 1284 60 PUSH1 0x00 1286 61 PUSH2 0x0c01 1289 60 PUSH1 0x20 128B 83 DUP4 128C 01 ADD 128D 84 DUP5 128E 61 PUSH2 0x1253 1291 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1283 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1284 stack[0] = 0x00 // @1286 stack[1] = 0x0c01 // @128C stack[2] = stack[-1] + 0x20 // @128D stack[3] = stack[-2] // } // Block ends with call to 0x1253, returns to 0x0C01 label_1292: // Incoming call from 0x037D, returns to 0x037E // Incoming call from 0x01E3, returns to 0x01E4 // Incoming call from 0x03DD, returns to 0x03DE // Incoming call from 0x02E2, returns to 0x02E3 // Inputs[2] // { // @1297 stack[-1] // @1298 stack[-2] // } 1292 5B JUMPDEST 1293 60 PUSH1 0x00 1295 60 PUSH1 0x20 1297 82 DUP3 1298 84 DUP5 1299 03 SUB 129A 12 SLT 129B 15 ISZERO 129C 61 PUSH2 0x12a4 129F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1293 stack[0] = 0x00 } // Block ends with conditional jump to 0x12a4, if !(stack[-2] - stack[-1] i< 0x20) label_12A0: // Incoming jump from 0x129F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @12A3 memory[0x00:0x00] } 12A0 60 PUSH1 0x00 12A2 80 DUP1 12A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @12A3 revert(memory[0x00:0x00]); } // Block terminates label_12A4: // Incoming jump from 0x129F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @12A6 stack[-2] // @12A6 msg.data[stack[-2]:stack[-2] + 0x20] // @12A7 stack[-4] // @12A8 stack[-3] // } 12A4 5B JUMPDEST 12A5 50 POP 12A6 35 CALLDATALOAD 12A7 91 SWAP2 12A8 90 SWAP1 12A9 50 POP 12AA 56 *JUMP // Stack delta = -3 // Outputs[1] { @12A7 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_12AB: // Incoming call from 0x130E, returns to 0x130F // Incoming call from 0x1417, returns to 0x1418 // Incoming call from 0x131C, returns to 0x131D // Incoming call from 0x1490, returns to 0x1491 // Incoming call from 0x1347, returns to 0x0C01 // Incoming call from 0x1425, returns to 0x1426 // Incoming call from 0x149E, returns to 0x149F // Incoming call from 0x12E2, returns to 0x12E3 // Incoming call from 0x13D8, returns to 0x13D9 // Inputs[2] // { // @12AC stack[-1] // @12AD msg.data[stack[-1]:stack[-1] + 0x20] // } 12AB 5B JUMPDEST 12AC 80 DUP1 12AD 35 CALLDATALOAD 12AE 60 PUSH1 0x01 12B0 60 PUSH1 0x01 12B2 60 PUSH1 0xa0 12B4 1B SHL 12B5 03 SUB 12B6 81 DUP2 12B7 16 AND 12B8 81 DUP2 12B9 14 EQ 12BA 61 PUSH2 0x12c2 12BD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12AD stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x12c2, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_12BE: // Incoming jump from 0x12BD, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @12C1 memory[0x00:0x00] } 12BE 60 PUSH1 0x00 12C0 80 DUP1 12C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @12C1 revert(memory[0x00:0x00]); } // Block terminates label_12C2: // Incoming jump from 0x12BD, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @12C3 stack[-1] // @12C3 stack[-3] // @12C4 stack[-2] // } 12C2 5B JUMPDEST 12C3 91 SWAP2 12C4 90 SWAP1 12C5 50 POP 12C6 56 *JUMP // Stack delta = -2 // Outputs[1] { @12C3 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_12C7: // Incoming call from 0x03FD, returns to 0x03FE // Incoming call from 0x049B, returns to 0x049C // Incoming call from 0x021B, returns to 0x021C // Inputs[2] // { // @12CD stack[-1] // @12CE stack[-2] // } 12C7 5B JUMPDEST 12C8 60 PUSH1 0x00 12CA 80 DUP1 12CB 60 PUSH1 0x40 12CD 83 DUP4 12CE 85 DUP6 12CF 03 SUB 12D0 12 SLT 12D1 15 ISZERO 12D2 61 PUSH2 0x12da 12D5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @12C8 stack[0] = 0x00 // @12CA stack[1] = 0x00 // } // Block ends with conditional jump to 0x12da, if !(stack[-2] - stack[-1] i< 0x40) label_12D6: // Incoming jump from 0x12D5, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @12D9 memory[0x00:0x00] } 12D6 60 PUSH1 0x00 12D8 80 DUP1 12D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @12D9 revert(memory[0x00:0x00]); } // Block terminates label_12DA: // Incoming jump from 0x12D5, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @12DE stack[-3] } 12DA 5B JUMPDEST 12DB 61 PUSH2 0x12e3 12DE 83 DUP4 12DF 61 PUSH2 0x12ab 12E2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @12DB stack[0] = 0x12e3 // @12DE stack[1] = stack[-3] // } // Block ends with call to 0x12ab, returns to 0x12E3 label_12E3: // Incoming return from call to 0x12AB at 0x12E2 // Inputs[5] // { // @12E4 stack[-1] // @12E4 stack[-6] // @12E7 stack[-4] // @12EB msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @12EC stack[-5] // } 12E3 5B JUMPDEST 12E4 94 SWAP5 12E5 60 PUSH1 0x20 12E7 93 SWAP4 12E8 90 SWAP1 12E9 93 SWAP4 12EA 01 ADD 12EB 35 CALLDATALOAD 12EC 93 SWAP4 12ED 50 POP 12EE 50 POP 12EF 50 POP 12F0 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @12E4 stack[-6] = stack[-1] // @12EC stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_12F1: // Incoming call from 0x027E, returns to 0x027F // Incoming call from 0x025E, returns to 0x025F // Inputs[2] // { // @12F9 stack[-1] // @12FA stack[-2] // } 12F1 5B JUMPDEST 12F2 60 PUSH1 0x00 12F4 80 DUP1 12F5 60 PUSH1 0x00 12F7 60 PUSH1 0x60 12F9 84 DUP5 12FA 86 DUP7 12FB 03 SUB 12FC 12 SLT 12FD 15 ISZERO 12FE 61 PUSH2 0x1306 1301 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @12F2 stack[0] = 0x00 // @12F4 stack[1] = 0x00 // @12F5 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1306, if !(stack[-2] - stack[-1] i< 0x60) label_1302: // Incoming jump from 0x1301, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1305 memory[0x00:0x00] } 1302 60 PUSH1 0x00 1304 80 DUP1 1305 FD *REVERT // Stack delta = +0 // Outputs[1] { @1305 revert(memory[0x00:0x00]); } // Block terminates label_1306: // Incoming jump from 0x1301, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @130A stack[-4] } 1306 5B JUMPDEST 1307 61 PUSH2 0x130f 130A 84 DUP5 130B 61 PUSH2 0x12ab 130E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1307 stack[0] = 0x130f // @130A stack[1] = stack[-4] // } // Block ends with call to 0x12ab, returns to 0x130F label_130F: // Incoming return from call to 0x12AB at 0x130E // Inputs[3] // { // @1310 stack[-4] // @1310 stack[-1] // @1317 stack[-5] // } 130F 5B JUMPDEST 1310 92 SWAP3 1311 50 POP 1312 61 PUSH2 0x131d 1315 60 PUSH1 0x20 1317 85 DUP6 1318 01 ADD 1319 61 PUSH2 0x12ab 131C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1310 stack[-4] = stack[-1] // @1312 stack[-1] = 0x131d // @1318 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x12ab, returns to 0x131D label_131D: // Incoming return from call to 0x12AB at 0x131C // Inputs[8] // { // @131E stack[-3] // @131E stack[-1] // @1322 stack[-5] // @1324 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1325 stack[-2] // @1329 stack[-6] // @132B stack[-7] // @132B stack[-4] // } 131D 5B JUMPDEST 131E 91 SWAP2 131F 50 POP 1320 60 PUSH1 0x40 1322 84 DUP5 1323 01 ADD 1324 35 CALLDATALOAD 1325 90 SWAP1 1326 50 POP 1327 92 SWAP3 1328 50 POP 1329 92 SWAP3 132A 50 POP 132B 92 SWAP3 132C 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1327 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1329 stack[-6] = stack[-1] // @132B stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_132D: // Incoming call from 0x094B, returns to 0x094C // Incoming call from 0x0302, returns to 0x0303 // Incoming call from 0x047B, returns to 0x047C // Inputs[2] // { // @1332 stack[-1] // @1333 stack[-2] // } 132D 5B JUMPDEST 132E 60 PUSH1 0x00 1330 60 PUSH1 0x20 1332 82 DUP3 1333 84 DUP5 1334 03 SUB 1335 12 SLT 1336 15 ISZERO 1337 61 PUSH2 0x133f 133A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @132E stack[0] = 0x00 } // Block ends with conditional jump to 0x133f, if !(stack[-2] - stack[-1] i< 0x20) label_133B: // Incoming jump from 0x133A, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @133E memory[0x00:0x00] } 133B 60 PUSH1 0x00 133D 80 DUP1 133E FD *REVERT // Stack delta = +0 // Outputs[1] { @133E revert(memory[0x00:0x00]); } // Block terminates label_133F: // Incoming jump from 0x133A, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1343 stack[-2] } 133F 5B JUMPDEST 1340 61 PUSH2 0x0c01 1343 82 DUP3 1344 61 PUSH2 0x12ab 1347 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1340 stack[0] = 0x0c01 // @1343 stack[1] = stack[-2] // } // Block ends with call to 0x12ab, returns to 0x0C01 label_1348: // Incoming call from 0x0337, returns to 0x0338 // Inputs[2] // { // @134E stack[-1] // @134F stack[-2] // } 1348 5B JUMPDEST 1349 60 PUSH1 0x00 134B 80 DUP1 134C 60 PUSH1 0x20 134E 83 DUP4 134F 85 DUP6 1350 03 SUB 1351 12 SLT 1352 15 ISZERO 1353 61 PUSH2 0x135b 1356 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1349 stack[0] = 0x00 // @134B stack[1] = 0x00 // } // Block ends with conditional jump to 0x135b, if !(stack[-2] - stack[-1] i< 0x20) label_1357: // Incoming jump from 0x1356, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @135A memory[0x00:0x00] } 1357 60 PUSH1 0x00 1359 80 DUP1 135A FD *REVERT // Stack delta = +0 // Outputs[1] { @135A revert(memory[0x00:0x00]); } // Block terminates label_135B: // Incoming jump from 0x1356, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @135C stack[-3] // @135D msg.data[stack[-3]:stack[-3] + 0x20] // } 135B 5B JUMPDEST 135C 82 DUP3 135D 35 CALLDATALOAD 135E 67 PUSH8 0xffffffffffffffff 1367 80 DUP1 1368 82 DUP3 1369 11 GT 136A 15 ISZERO 136B 61 PUSH2 0x1373 136E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @135D stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @135E stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1373, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_136F: // Incoming jump from 0x136E, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1372 memory[0x00:0x00] } 136F 60 PUSH1 0x00 1371 80 DUP1 1372 FD *REVERT // Stack delta = +0 // Outputs[1] { @1372 revert(memory[0x00:0x00]); } // Block terminates label_1373: // Incoming jump from 0x136E, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1374 stack[-2] // @1375 stack[-5] // @1379 stack[-6] // } 1373 5B JUMPDEST 1374 81 DUP2 1375 85 DUP6 1376 01 ADD 1377 91 SWAP2 1378 50 POP 1379 85 DUP6 137A 60 PUSH1 0x1f 137C 83 DUP4 137D 01 ADD 137E 12 SLT 137F 61 PUSH2 0x1387 1382 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1377 stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x1387, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_1383: // Incoming jump from 0x1382, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @1386 memory[0x00:0x00] } 1383 60 PUSH1 0x00 1385 80 DUP1 1386 FD *REVERT // Stack delta = +0 // Outputs[1] { @1386 revert(memory[0x00:0x00]); } // Block terminates label_1387: // Incoming jump from 0x1382, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @1388 stack[-2] // @1389 msg.data[stack[-2]:stack[-2] + 0x20] // @138A stack[-1] // } 1387 5B JUMPDEST 1388 81 DUP2 1389 35 CALLDATALOAD 138A 81 DUP2 138B 81 DUP2 138C 11 GT 138D 15 ISZERO 138E 61 PUSH2 0x1396 1391 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1389 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1396, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_1392: // Incoming jump from 0x1391, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @1395 memory[0x00:0x00] } 1392 60 PUSH1 0x00 1394 80 DUP1 1395 FD *REVERT // Stack delta = +0 // Outputs[1] { @1395 revert(memory[0x00:0x00]); } // Block terminates label_1396: // Incoming jump from 0x1391, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @1397 stack[-7] // @139A stack[-1] // @139E stack[-3] // } 1396 5B JUMPDEST 1397 86 DUP7 1398 60 PUSH1 0x20 139A 82 DUP3 139B 60 PUSH1 0x05 139D 1B SHL 139E 85 DUP6 139F 01 ADD 13A0 01 ADD 13A1 11 GT 13A2 15 ISZERO 13A3 61 PUSH2 0x13ab 13A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13ab, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-7]) label_13A7: // Incoming jump from 0x13A6, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-7]) // Inputs[1] { @13AA memory[0x00:0x00] } 13A7 60 PUSH1 0x00 13A9 80 DUP1 13AA FD *REVERT // Stack delta = +0 // Outputs[1] { @13AA revert(memory[0x00:0x00]); } // Block terminates label_13AB: // Incoming jump from 0x13A6, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-7]) // Inputs[6] // { // @13AE stack[-3] // @13AF stack[-1] // @13B2 stack[-8] // @13B4 stack[-7] // @13B6 stack[-2] // @13B7 stack[-6] // } 13AB 5B JUMPDEST 13AC 60 PUSH1 0x20 13AE 92 SWAP3 13AF 90 SWAP1 13B0 92 SWAP3 13B1 01 ADD 13B2 96 SWAP7 13B3 91 SWAP2 13B4 95 SWAP6 13B5 50 POP 13B6 90 SWAP1 13B7 93 SWAP4 13B8 50 POP 13B9 50 POP 13BA 50 POP 13BB 50 POP 13BC 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @13B2 stack[-8] = 0x20 + stack[-3] // @13B4 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_13BD: // Incoming call from 0x039D, returns to 0x039E // Inputs[2] // { // @13C3 stack[-1] // @13C4 stack[-2] // } 13BD 5B JUMPDEST 13BE 60 PUSH1 0x00 13C0 80 DUP1 13C1 60 PUSH1 0x40 13C3 83 DUP4 13C4 85 DUP6 13C5 03 SUB 13C6 12 SLT 13C7 15 ISZERO 13C8 61 PUSH2 0x13d0 13CB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @13BE stack[0] = 0x00 // @13C0 stack[1] = 0x00 // } // Block ends with conditional jump to 0x13d0, if !(stack[-2] - stack[-1] i< 0x40) label_13CC: // Incoming jump from 0x13CB, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @13CF memory[0x00:0x00] } 13CC 60 PUSH1 0x00 13CE 80 DUP1 13CF FD *REVERT // Stack delta = +0 // Outputs[1] { @13CF revert(memory[0x00:0x00]); } // Block terminates label_13D0: // Incoming jump from 0x13CB, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @13D4 stack[-3] } 13D0 5B JUMPDEST 13D1 61 PUSH2 0x13d9 13D4 83 DUP4 13D5 61 PUSH2 0x12ab 13D8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @13D1 stack[0] = 0x13d9 // @13D4 stack[1] = stack[-3] // } // Block ends with call to 0x12ab, returns to 0x13D9 label_13D9: // Incoming return from call to 0x12AB at 0x13D8 // Inputs[4] // { // @13DA stack[-1] // @13DA stack[-3] // @13DE stack[-4] // @13E0 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 13D9 5B JUMPDEST 13DA 91 SWAP2 13DB 50 POP 13DC 60 PUSH1 0x20 13DE 83 DUP4 13DF 01 ADD 13E0 35 CALLDATALOAD 13E1 80 DUP1 13E2 15 ISZERO 13E3 15 ISZERO 13E4 81 DUP2 13E5 14 EQ 13E6 61 PUSH2 0x13ee 13E9 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @13DA stack[-3] = stack[-1] // @13E0 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x13ee, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_13EA: // Incoming jump from 0x13E9, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[1] { @13ED memory[0x00:0x00] } 13EA 60 PUSH1 0x00 13EC 80 DUP1 13ED FD *REVERT // Stack delta = +0 // Outputs[1] { @13ED revert(memory[0x00:0x00]); } // Block terminates label_13EE: // Incoming jump from 0x13E9, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @13EF stack[-1] // @13F0 stack[-2] // @13F3 stack[-5] // @13F5 stack[-6] // @13F5 stack[-3] // @13F6 stack[-4] // } 13EE 5B JUMPDEST 13EF 80 DUP1 13F0 91 SWAP2 13F1 50 POP 13F2 50 POP 13F3 92 SWAP3 13F4 50 POP 13F5 92 SWAP3 13F6 90 SWAP1 13F7 50 POP 13F8 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @13F3 stack[-5] = stack[-1] // @13F5 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_13F9: // Incoming call from 0x03BD, returns to 0x03BE // Inputs[2] // { // @1402 stack[-1] // @1403 stack[-2] // } 13F9 5B JUMPDEST 13FA 60 PUSH1 0x00 13FC 80 DUP1 13FD 60 PUSH1 0x00 13FF 80 DUP1 1400 60 PUSH1 0x80 1402 85 DUP6 1403 87 DUP8 1404 03 SUB 1405 12 SLT 1406 15 ISZERO 1407 61 PUSH2 0x140f 140A 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @13FA stack[0] = 0x00 // @13FC stack[1] = 0x00 // @13FD stack[2] = 0x00 // @13FF stack[3] = 0x00 // } // Block ends with conditional jump to 0x140f, if !(stack[-2] - stack[-1] i< 0x80) label_140B: // Incoming jump from 0x140A, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @140E memory[0x00:0x00] } 140B 60 PUSH1 0x00 140D 80 DUP1 140E FD *REVERT // Stack delta = +0 // Outputs[1] { @140E revert(memory[0x00:0x00]); } // Block terminates label_140F: // Incoming jump from 0x140A, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1413 stack[-5] } 140F 5B JUMPDEST 1410 61 PUSH2 0x1418 1413 85 DUP6 1414 61 PUSH2 0x12ab 1417 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1410 stack[0] = 0x1418 // @1413 stack[1] = stack[-5] // } // Block ends with call to 0x12ab, returns to 0x1418 label_1418: // Incoming return from call to 0x12AB at 0x1417 // Inputs[3] // { // @1419 stack[-5] // @1419 stack[-1] // @1420 stack[-6] // } 1418 5B JUMPDEST 1419 93 SWAP4 141A 50 POP 141B 61 PUSH2 0x1426 141E 60 PUSH1 0x20 1420 86 DUP7 1421 01 ADD 1422 61 PUSH2 0x12ab 1425 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1419 stack[-5] = stack[-1] // @141B stack[-1] = 0x1426 // @1421 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x12ab, returns to 0x1426 label_1426: // Incoming return from call to 0x12AB at 0x1425 // Inputs[6] // { // @1427 stack[-1] // @1427 stack[-4] // @142B stack[-6] // @142D msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @142E stack[-3] // @1434 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 1426 5B JUMPDEST 1427 92 SWAP3 1428 50 POP 1429 60 PUSH1 0x40 142B 85 DUP6 142C 01 ADD 142D 35 CALLDATALOAD 142E 91 SWAP2 142F 50 POP 1430 60 PUSH1 0x60 1432 85 DUP6 1433 01 ADD 1434 35 CALLDATALOAD 1435 67 PUSH8 0xffffffffffffffff 143E 81 DUP2 143F 11 GT 1440 15 ISZERO 1441 61 PUSH2 0x1449 1444 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1427 stack[-4] = stack[-1] // @142E stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1434 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x1449, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_1445: // Incoming jump from 0x1444, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1448 memory[0x00:0x00] } 1445 60 PUSH1 0x00 1447 80 DUP1 1448 FD *REVERT // Stack delta = +0 // Outputs[1] { @1448 revert(memory[0x00:0x00]); } // Block terminates label_1449: // Incoming jump from 0x1444, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @144A stack[-6] // @144B stack[-1] // @1450 stack[-7] // } 1449 5B JUMPDEST 144A 85 DUP6 144B 01 ADD 144C 60 PUSH1 0x1f 144E 81 DUP2 144F 01 ADD 1450 87 DUP8 1451 13 SGT 1452 61 PUSH2 0x145a 1455 57 *JUMPI // Stack delta = +0 // Outputs[1] { @144B stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x145a, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_1456: // Incoming jump from 0x1455, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @1459 memory[0x00:0x00] } 1456 60 PUSH1 0x00 1458 80 DUP1 1459 FD *REVERT // Stack delta = +0 // Outputs[1] { @1459 revert(memory[0x00:0x00]); } // Block terminates label_145A: // Incoming jump from 0x1455, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @145E stack[-7] // @145F stack[-1] // @1460 msg.data[stack[-1]:stack[-1] + 0x20] // } 145A 5B JUMPDEST 145B 61 PUSH2 0x1469 145E 87 DUP8 145F 82 DUP3 1460 35 CALLDATALOAD 1461 60 PUSH1 0x20 1463 84 DUP5 1464 01 ADD 1465 61 PUSH2 0x1168 1468 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @145B stack[0] = 0x1469 // @145E stack[1] = stack[-7] // @1460 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1464 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1168, returns to 0x1469 label_1469: // Incoming return from call to 0x1168 at 0x1468 // Inputs[8] // { // @146A stack[-1] // @146A stack[-3] // @146D stack[-6] // @146E stack[-9] // @146F stack[-5] // @1470 stack[-8] // @1472 stack[-4] // @1472 stack[-7] // } 1469 5B JUMPDEST 146A 91 SWAP2 146B 50 POP 146C 50 POP 146D 92 SWAP3 146E 95 SWAP6 146F 91 SWAP2 1470 94 SWAP5 1471 50 POP 1472 92 SWAP3 1473 50 POP 1474 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @146D stack[-6] = stack[-1] // @146E stack[-9] = stack[-6] // @1470 stack[-8] = stack[-5] // @1472 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_1475: // Incoming call from 0x041D, returns to 0x041E // Inputs[2] // { // @147B stack[-1] // @147C stack[-2] // } 1475 5B JUMPDEST 1476 60 PUSH1 0x00 1478 80 DUP1 1479 60 PUSH1 0x40 147B 83 DUP4 147C 85 DUP6 147D 03 SUB 147E 12 SLT 147F 15 ISZERO 1480 61 PUSH2 0x1488 1483 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1476 stack[0] = 0x00 // @1478 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1488, if !(stack[-2] - stack[-1] i< 0x40) label_1484: // Incoming jump from 0x1483, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1487 memory[0x00:0x00] } 1484 60 PUSH1 0x00 1486 80 DUP1 1487 FD *REVERT // Stack delta = +0 // Outputs[1] { @1487 revert(memory[0x00:0x00]); } // Block terminates label_1488: // Incoming jump from 0x1483, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @148C stack[-3] } 1488 5B JUMPDEST 1489 61 PUSH2 0x1491 148C 83 DUP4 148D 61 PUSH2 0x12ab 1490 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1489 stack[0] = 0x1491 // @148C stack[1] = stack[-3] // } // Block ends with call to 0x12ab, returns to 0x1491 label_1491: // Incoming return from call to 0x12AB at 0x1490 // Inputs[3] // { // @1492 stack[-1] // @1492 stack[-3] // @1499 stack[-4] // } 1491 5B JUMPDEST 1492 91 SWAP2 1493 50 POP 1494 61 PUSH2 0x149f 1497 60 PUSH1 0x20 1499 84 DUP5 149A 01 ADD 149B 61 PUSH2 0x12ab 149E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1492 stack[-3] = stack[-1] // @1494 stack[-1] = 0x149f // @149A stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x12ab, returns to 0x149F label_149F: // Incoming return from call to 0x12AB at 0x149E // Inputs[6] // { // @14A0 stack[-1] // @14A0 stack[-2] // @14A2 stack[-5] // @14A4 stack[-3] // @14A4 stack[-6] // @14A5 stack[-4] // } 149F 5B JUMPDEST 14A0 90 SWAP1 14A1 50 POP 14A2 92 SWAP3 14A3 50 POP 14A4 92 SWAP3 14A5 90 SWAP1 14A6 50 POP 14A7 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @14A2 stack[-5] = stack[-1] // @14A4 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_14A8: // Incoming call from 0x10CF, returns to 0x051A // Incoming call from 0x0519, returns to 0x051A // Incoming call from 0x154F, returns to 0x1550 // Incoming call from 0x0973, returns to 0x051A // Incoming call from 0x0545, returns to 0x0546 // Inputs[1] { @14AB stack[-1] } 14A8 5B JUMPDEST 14A9 60 PUSH1 0x01 14AB 81 DUP2 14AC 81 DUP2 14AD 1C SHR 14AE 90 SWAP1 14AF 82 DUP3 14B0 16 AND 14B1 80 DUP1 14B2 61 PUSH2 0x14bc 14B5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14AE stack[0] = stack[-1] >> 0x01 // @14B0 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x14bc, if stack[-1] & 0x01 label_14B6: // Incoming jump from 0x14B5, if not stack[-1] & 0x01 // Inputs[2] // { // @14B8 stack[-2] // @14C1 stack[-1] // } 14B6 60 PUSH1 0x7f 14B8 82 DUP3 14B9 16 AND 14BA 91 SWAP2 14BB 50 POP 14BC 5B JUMPDEST 14BD 60 PUSH1 0x20 14BF 82 DUP3 14C0 10 LT 14C1 81 DUP2 14C2 03 SUB 14C3 61 PUSH2 0x14dc 14C6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @14BA stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x14dc, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_14C7: // Incoming jump from 0x14C6, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Incoming jump from 0x14C6, if not stack[-1] - (stack[-2] < 0x20) // Inputs[1] { @14DB memory[0x00:0x24] } 14C7 63 PUSH4 0x4e487b71 14CC 60 PUSH1 0xe0 14CE 1B SHL 14CF 60 PUSH1 0x00 14D1 52 MSTORE 14D2 60 PUSH1 0x22 14D4 60 PUSH1 0x04 14D6 52 MSTORE 14D7 60 PUSH1 0x24 14D9 60 PUSH1 0x00 14DB FD *REVERT // Stack delta = +0 // Outputs[3] // { // @14D1 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @14D6 memory[0x04:0x24] = 0x22 // @14DB revert(memory[0x00:0x24]); // } // Block terminates label_14DC: // Incoming jump from 0x14C6, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Incoming jump from 0x14C6, if stack[-1] - (stack[-2] < 0x20) // Inputs[3] // { // @14DE stack[-4] // @14DE stack[-2] // @14DF stack[-3] // } 14DC 5B JUMPDEST 14DD 50 POP 14DE 91 SWAP2 14DF 90 SWAP1 14E0 50 POP 14E1 56 *JUMP // Stack delta = -3 // Outputs[1] { @14DE stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_14E2: // Incoming jump from 0x1555 // Inputs[1] { @14E5 stack[-2] } 14E2 5B JUMPDEST 14E3 60 PUSH1 0x1f 14E5 82 DUP3 14E6 11 GT 14E7 15 ISZERO 14E8 61 PUSH2 0x0835 14EB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0835, if !(stack[-2] > 0x1f) label_14EC: // Incoming jump from 0x14EB, if not !(stack[-2] > 0x1f) // Inputs[3] // { // @14EE stack[-1] // @14F4 memory[0x00:0x20] // @14F7 stack[-3] // } 14EC 60 PUSH1 0x00 14EE 81 DUP2 14EF 81 DUP2 14F0 52 MSTORE 14F1 60 PUSH1 0x20 14F3 81 DUP2 14F4 20 SHA3 14F5 60 PUSH1 0x1f 14F7 85 DUP6 14F8 01 ADD 14F9 60 PUSH1 0x05 14FB 1C SHR 14FC 81 DUP2 14FD 01 ADD 14FE 60 PUSH1 0x20 1500 86 DUP7 1501 10 LT 1502 15 ISZERO 1503 61 PUSH2 0x1509 1506 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @14EC stack[0] = 0x00 // @14F0 memory[0x00:0x20] = stack[-1] // @14F4 stack[1] = keccak256(memory[0x00:0x20]) // @14FD stack[2] = keccak256(memory[0x00:0x20]) + (stack[-3] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x1509, if !(stack[-3] < 0x20) label_1507: // Incoming jump from 0x1506, if not !(stack[-3] < 0x20) // Inputs[2] // { // @1508 stack[-2] // @150C stack[-5] // } 1507 50 POP 1508 80 DUP1 1509 5B JUMPDEST 150A 60 PUSH1 0x1f 150C 85 DUP6 150D 01 ADD 150E 60 PUSH1 0x05 1510 1C SHR 1511 82 DUP3 1512 01 ADD 1513 91 SWAP2 1514 50 POP 1515 5B JUMPDEST 1516 81 DUP2 1517 81 DUP2 1518 10 LT 1519 15 ISZERO 151A 61 PUSH2 0x0812 151D 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1508 stack[-1] = stack[-2] // @1513 stack[-2] = stack[-2] + (stack[-5] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x0812, if !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) label_151E: // Incoming jump from 0x151D, if not !(stack[-1] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x151D, if not !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x151D, if not !(stack[-1] < stack[-2]) // Inputs[2] // { // @151E stack[-3] // @151F stack[-1] // } 151E 82 DUP3 151F 81 DUP2 1520 55 SSTORE 1521 60 PUSH1 0x01 1523 01 ADD 1524 61 PUSH2 0x1515 1527 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1520 storage[stack[-1]] = stack[-3] // @1523 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1515 label_1528: // Incoming call from 0x0506, returns to 0x0507 // Inputs[2] // { // @1529 stack[-2] // @152A memory[stack[-2]:stack[-2] + 0x20] // } 1528 5B JUMPDEST 1529 81 DUP2 152A 51 MLOAD 152B 67 PUSH8 0xffffffffffffffff 1534 81 DUP2 1535 11 GT 1536 15 ISZERO 1537 61 PUSH2 0x1542 153A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @152A stack[0] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1542, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_153B: // Incoming jump from 0x153A, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) 153B 61 PUSH2 0x1542 153E 61 PUSH2 0x1152 1541 56 *JUMP // Stack delta = +1 // Outputs[1] { @153B stack[0] = 0x1542 } // Block ends with unconditional jump to 0x1152 label_1542: // Incoming jump from 0x153A, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1546 stack[-1] // @154A stack[-2] // @154B storage[stack[-2]] // } 1542 5B JUMPDEST 1543 61 PUSH2 0x1556 1546 81 DUP2 1547 61 PUSH2 0x1550 154A 84 DUP5 154B 54 SLOAD 154C 61 PUSH2 0x14a8 154F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1543 stack[0] = 0x1556 // @1546 stack[1] = stack[-1] // @1547 stack[2] = 0x1550 // @154B stack[3] = storage[stack[-2]] // } // Block ends with call to 0x14a8, returns to 0x1550 label_1550: // Incoming return from call to 0x14A8 at 0x154F // Inputs[1] { @1551 stack[-5] } 1550 5B JUMPDEST 1551 84 DUP5 1552 61 PUSH2 0x14e2 1555 56 *JUMP // Stack delta = +1 // Outputs[1] { @1551 stack[0] = stack[-5] } // Block ends with unconditional jump to 0x14e2 label_1556: // Incoming return from call to 0x1550 at 0x154F // Inputs[1] { @155C stack[-1] } 1556 5B JUMPDEST 1557 60 PUSH1 0x20 1559 80 DUP1 155A 60 PUSH1 0x1f 155C 83 DUP4 155D 11 GT 155E 60 PUSH1 0x01 1560 81 DUP2 1561 14 EQ 1562 61 PUSH2 0x158b 1565 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1557 stack[0] = 0x20 // @1559 stack[1] = 0x20 // @155D stack[2] = stack[-1] > 0x1f // } // Block ends with conditional jump to 0x158b, if (stack[-1] > 0x1f) == 0x01 label_1566: // Incoming jump from 0x1565, if not (stack[-1] > 0x1f) == 0x01 // Inputs[1] { @1568 stack[-4] } 1566 60 PUSH1 0x00 1568 84 DUP5 1569 15 ISZERO 156A 61 PUSH2 0x1573 156D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1566 stack[0] = 0x00 } // Block ends with conditional jump to 0x1573, if !stack[-4] label_156E: // Incoming jump from 0x156D, if not !stack[-4] // Inputs[5] // { // @156F stack[-7] // @1570 stack[-4] // @1572 memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20] // @1579 stack[-5] // @1585 stack[-6] // } 156E 50 POP 156F 85 DUP6 1570 83 DUP4 1571 01 ADD 1572 51 MLOAD 1573 5B JUMPDEST 1574 60 PUSH1 0x00 1576 19 NOT 1577 60 PUSH1 0x03 1579 86 DUP7 157A 90 SWAP1 157B 1B SHL 157C 1C SHR 157D 19 NOT 157E 16 AND 157F 60 PUSH1 0x01 1581 85 DUP6 1582 90 SWAP1 1583 1B SHL 1584 17 OR 1585 85 DUP6 1586 55 SSTORE 1587 61 PUSH2 0x0812 158A 56 *JUMP // Stack delta = -1 // Outputs[1] { @1586 storage[stack[-6]] = (stack[-5] << 0x01) | (~(~0x00 >> (stack[-5] << 0x03)) & memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20]) } // Block ends with unconditional jump to 0x0812 label_158B: // Incoming jump from 0x1565, if (stack[-1] > 0x1f) == 0x01 // Inputs[3] // { // @158E stack[-5] // @1594 memory[0x00:0x20] // @1598 stack[-4] // } 158B 5B JUMPDEST 158C 60 PUSH1 0x00 158E 85 DUP6 158F 81 DUP2 1590 52 MSTORE 1591 60 PUSH1 0x20 1593 81 DUP2 1594 20 SHA3 1595 60 PUSH1 0x1f 1597 19 NOT 1598 86 DUP7 1599 16 AND 159A 91 SWAP2 159B 5B JUMPDEST 159C 82 DUP3 159D 81 DUP2 159E 10 LT 159F 15 ISZERO 15A0 61 PUSH2 0x15ba 15A3 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @1590 memory[0x00:0x20] = stack[-5] // @1594 stack[1] = keccak256(memory[0x00:0x20]) // @159A stack[0] = stack[-4] & ~0x1f // @159A stack[2] = 0x00 // } // Block ends with conditional jump to 0x15ba, if !(0x00 < stack[-4] & ~0x1f) label_15A4: // Incoming jump from 0x15A3, if not !(stack[-1] < stack[-3]) // Incoming jump from 0x15A3, if not !(0x00 < stack[-4] & ~0x1f) // Inputs[6] // { // @15A4 stack[-9] // @15A5 stack[-6] // @15A7 memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @15A8 stack[-2] // @15AA stack[-1] // @15AB stack[-5] // } 15A4 88 DUP9 15A5 86 DUP7 15A6 01 ADD 15A7 51 MLOAD 15A8 82 DUP3 15A9 55 SSTORE 15AA 94 SWAP5 15AB 84 DUP5 15AC 01 ADD 15AD 94 SWAP5 15AE 60 PUSH1 0x01 15B0 90 SWAP1 15B1 91 SWAP2 15B2 01 ADD 15B3 90 SWAP1 15B4 84 DUP5 15B5 01 ADD 15B6 61 PUSH2 0x159b 15B9 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @15A9 storage[stack[-2]] = memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @15AD stack[-6] = stack[-5] + stack[-6] // @15B3 stack[-2] = stack[-2] + 0x01 // @15B5 stack[-1] = stack[-5] + stack[-1] // } // Block ends with unconditional jump to 0x159b label_15BA: // Incoming jump from 0x15A3, if !(stack[-1] < stack[-3]) // Incoming jump from 0x15A3, if !(0x00 < stack[-4] & ~0x1f) // Inputs[2] // { // @15BC stack[-7] // @15BD stack[-3] // } 15BA 5B JUMPDEST 15BB 50 POP 15BC 85 DUP6 15BD 82 DUP3 15BE 10 LT 15BF 15 ISZERO 15C0 61 PUSH2 0x15d8 15C3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x15d8, if !(stack[-3] < stack[-7]) label_15C4: // Incoming jump from 0x15C3, if not !(stack[-3] < stack[-7]) // Inputs[7] // { // @15C4 stack[-8] // @15C5 stack[-5] // @15C7 memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @15CD stack[-6] // @15D6 stack[-1] // @15E4 stack[-7] // @15E7 stack[-9] // } 15C4 87 DUP8 15C5 85 DUP6 15C6 01 ADD 15C7 51 MLOAD 15C8 60 PUSH1 0x00 15CA 19 NOT 15CB 60 PUSH1 0x03 15CD 88 DUP9 15CE 90 SWAP1 15CF 1B SHL 15D0 60 PUSH1 0xf8 15D2 16 AND 15D3 1C SHR 15D4 19 NOT 15D5 16 AND 15D6 81 DUP2 15D7 55 SSTORE 15D8 5B JUMPDEST 15D9 50 POP 15DA 50 POP 15DB 50 POP 15DC 50 POP 15DD 50 POP 15DE 60 PUSH1 0x01 15E0 90 SWAP1 15E1 81 DUP2 15E2 1B SHL 15E3 01 ADD 15E4 90 SWAP1 15E5 55 SSTORE 15E6 50 POP 15E7 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @15D7 storage[stack[-1]] = ~(~0x00 >> (0xf8 & (stack[-6] << 0x03))) & memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @15E5 storage[stack[-7]] = (stack[-6] << 0x01) + 0x01 // } // Block ends with unconditional jump to stack[-9] label_15E8: // Incoming jump from 0x160F // Incoming jump from 0x163C // Incoming jump from 0x1656 // Incoming jump from 0x1675 // Inputs[1] { @15FD memory[0x00:0x24] } 15E8 5B JUMPDEST 15E9 63 PUSH4 0x4e487b71 15EE 60 PUSH1 0xe0 15F0 1B SHL 15F1 60 PUSH1 0x00 15F3 52 MSTORE 15F4 60 PUSH1 0x11 15F6 60 PUSH1 0x04 15F8 52 MSTORE 15F9 60 PUSH1 0x24 15FB 60 PUSH1 0x00 15FD FD *REVERT // Stack delta = +0 // Outputs[3] // { // @15F3 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @15F8 memory[0x04:0x24] = 0x11 // @15FD revert(memory[0x00:0x24]); // } // Block terminates label_15FE: // Incoming call from 0x0C68, returns to 0x0C69 // Incoming call from 0x0910, returns to 0x0911 // Inputs[2] // { // @1601 stack[-2] // @1602 stack[-1] // } 15FE 5B JUMPDEST 15FF 60 PUSH1 0x00 1601 82 DUP3 1602 82 DUP3 1603 10 LT 1604 15 ISZERO 1605 61 PUSH2 0x1610 1608 57 *JUMPI // Stack delta = +1 // Outputs[1] { @15FF stack[0] = 0x00 } // Block ends with conditional jump to 0x1610, if !(stack[-1] < stack[-2]) label_1609: // Incoming jump from 0x1608, if not !(stack[-1] < stack[-2]) 1609 61 PUSH2 0x1610 160C 61 PUSH2 0x15e8 160F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1609 stack[0] = 0x1610 } // Block ends with unconditional jump to 0x15e8 label_1610: // Incoming jump from 0x1608, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @1612 stack[-3] // @1612 stack[-2] // @1613 stack[-4] // } 1610 5B JUMPDEST 1611 50 POP 1612 03 SUB 1613 90 SWAP1 1614 56 *JUMP // Stack delta = -3 // Outputs[1] { @1613 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_1615: // Incoming jump from 0x0936 // Inputs[1] { @162A memory[0x00:0x24] } 1615 5B JUMPDEST 1616 63 PUSH4 0x4e487b71 161B 60 PUSH1 0xe0 161D 1B SHL 161E 60 PUSH1 0x00 1620 52 MSTORE 1621 60 PUSH1 0x32 1623 60 PUSH1 0x04 1625 52 MSTORE 1626 60 PUSH1 0x24 1628 60 PUSH1 0x00 162A FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1620 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1625 memory[0x04:0x24] = 0x32 // @162A revert(memory[0x00:0x24]); // } // Block terminates label_162B: // Incoming call from 0x095C, returns to 0x095D // Inputs[1] { @1630 stack[-1] } 162B 5B JUMPDEST 162C 60 PUSH1 0x00 162E 60 PUSH1 0x01 1630 82 DUP3 1631 01 ADD 1632 61 PUSH2 0x163d 1635 57 *JUMPI // Stack delta = +1 // Outputs[1] { @162C stack[0] = 0x00 } // Block ends with conditional jump to 0x163d, if stack[-1] + 0x01 label_1636: // Incoming jump from 0x1635, if not stack[-1] + 0x01 1636 61 PUSH2 0x163d 1639 61 PUSH2 0x15e8 163C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1636 stack[0] = 0x163d } // Block ends with unconditional jump to 0x15e8 label_163D: // Incoming jump from 0x1635, if stack[-1] + 0x01 // Inputs[2] // { // @1641 stack[-2] // @1642 stack[-3] // } 163D 5B JUMPDEST 163E 50 POP 163F 60 PUSH1 0x01 1641 01 ADD 1642 90 SWAP1 1643 56 *JUMP // Stack delta = -2 // Outputs[1] { @1642 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_1644: // Incoming call from 0x0A91, returns to 0x0A92 // Incoming call from 0x09D5, returns to 0x09D6 // Inputs[2] // { // @1647 stack[-2] // @1649 stack[-1] // } 1644 5B JUMPDEST 1645 60 PUSH1 0x00 1647 82 DUP3 1648 19 NOT 1649 82 DUP3 164A 11 GT 164B 15 ISZERO 164C 61 PUSH2 0x1657 164F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1645 stack[0] = 0x00 } // Block ends with conditional jump to 0x1657, if !(stack[-1] > ~stack[-2]) label_1650: // Incoming jump from 0x164F, if not !(stack[-1] > ~stack[-2]) 1650 61 PUSH2 0x1657 1653 61 PUSH2 0x15e8 1656 56 *JUMP // Stack delta = +1 // Outputs[1] { @1650 stack[0] = 0x1657 } // Block ends with unconditional jump to 0x15e8 label_1657: // Incoming jump from 0x164F, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @1659 stack[-3] // @1659 stack[-2] // @165A stack[-4] // } 1657 5B JUMPDEST 1658 50 POP 1659 01 ADD 165A 90 SWAP1 165B 56 *JUMP // Stack delta = -3 // Outputs[1] { @165A stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_165C: // Incoming call from 0x0A32, returns to 0x0A33 // Inputs[2] // { // @165F stack[-1] // @1664 stack[-2] // } 165C 5B JUMPDEST 165D 60 PUSH1 0x00 165F 81 DUP2 1660 60 PUSH1 0x00 1662 19 NOT 1663 04 DIV 1664 83 DUP4 1665 11 GT 1666 82 DUP3 1667 15 ISZERO 1668 15 ISZERO 1669 16 AND 166A 15 ISZERO 166B 61 PUSH2 0x1676 166E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @165D stack[0] = 0x00 } // Block ends with conditional jump to 0x1676, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_166F: // Incoming jump from 0x166E, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 166F 61 PUSH2 0x1676 1672 61 PUSH2 0x15e8 1675 56 *JUMP // Stack delta = +1 // Outputs[1] { @166F stack[0] = 0x1676 } // Block ends with unconditional jump to 0x15e8 label_1676: // Incoming jump from 0x166E, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @1678 stack[-2] // @1678 stack[-3] // @1679 stack[-4] // } 1676 5B JUMPDEST 1677 50 POP 1678 02 MUL 1679 90 SWAP1 167A 56 *JUMP // Stack delta = -3 // Outputs[1] { @1679 stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] 167B 5B JUMPDEST 167C 60 PUSH1 0x00 167E 83 DUP4 167F 51 MLOAD 1680 61 PUSH2 0x168d 1683 81 DUP2 1684 84 DUP5 1685 60 PUSH1 0x20 1687 88 DUP9 1688 01 ADD 1689 61 PUSH2 0x1227 168C 56 *JUMP 168D 5B JUMPDEST 168E 83 DUP4 168F 51 MLOAD 1690 90 SWAP1 1691 83 DUP4 1692 01 ADD 1693 90 SWAP1 1694 61 PUSH2 0x16a1 1697 81 DUP2 1698 83 DUP4 1699 60 PUSH1 0x20 169B 88 DUP9 169C 01 ADD 169D 61 PUSH2 0x1227 16A0 56 *JUMP 16A1 5B JUMPDEST 16A2 01 ADD 16A3 94 SWAP5 16A4 93 SWAP4 16A5 50 POP 16A6 50 POP 16A7 50 POP 16A8 50 POP 16A9 56 *JUMP label_16AA: // Incoming call from 0x1009, returns to 0x100A // Inputs[5] // { // @16B3 stack[-5] // @16B6 stack[-1] // @16B8 stack[-4] // @16C3 stack[-3] // @16D8 stack[-2] // } 16AA 5B JUMPDEST 16AB 60 PUSH1 0x01 16AD 60 PUSH1 0x01 16AF 60 PUSH1 0xa0 16B1 1B SHL 16B2 03 SUB 16B3 85 DUP6 16B4 81 DUP2 16B5 16 AND 16B6 82 DUP3 16B7 52 MSTORE 16B8 84 DUP5 16B9 16 AND 16BA 60 PUSH1 0x20 16BC 82 DUP3 16BD 01 ADD 16BE 52 MSTORE 16BF 60 PUSH1 0x40 16C1 81 DUP2 16C2 01 ADD 16C3 83 DUP4 16C4 90 SWAP1 16C5 52 MSTORE 16C6 60 PUSH1 0x80 16C8 60 PUSH1 0x60 16CA 82 DUP3 16CB 01 ADD 16CC 81 DUP2 16CD 90 SWAP1 16CE 52 MSTORE 16CF 60 PUSH1 0x00 16D1 90 SWAP1 16D2 61 PUSH2 0x16dd 16D5 90 SWAP1 16D6 83 DUP4 16D7 01 ADD 16D8 84 DUP5 16D9 61 PUSH2 0x1253 16DC 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @16B7 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @16BE memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @16C5 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @16CE memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @16D1 stack[0] = 0x00 // @16D5 stack[1] = 0x16dd // @16D7 stack[2] = stack[-1] + 0x80 // @16D8 stack[3] = stack[-2] // } // Block ends with call to 0x1253, returns to 0x16DD label_16DD: // Incoming return from call to 0x1253 at 0x16DC // Inputs[3] // { // @16DE stack[-8] // @16DE stack[-1] // @16DF stack[-7] // } 16DD 5B JUMPDEST 16DE 96 SWAP7 16DF 95 SWAP6 16E0 50 POP 16E1 50 POP 16E2 50 POP 16E3 50 POP 16E4 50 POP 16E5 50 POP 16E6 56 *JUMP // Stack delta = -7 // Outputs[1] { @16DE stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_16E7: // Incoming jump from 0x1041 // Inputs[2] // { // @16EC stack[-1] // @16ED stack[-2] // } 16E7 5B JUMPDEST 16E8 60 PUSH1 0x00 16EA 60 PUSH1 0x20 16EC 82 DUP3 16ED 84 DUP5 16EE 03 SUB 16EF 12 SLT 16F0 15 ISZERO 16F1 61 PUSH2 0x16f9 16F4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @16E8 stack[0] = 0x00 } // Block ends with conditional jump to 0x16f9, if !(stack[-2] - stack[-1] i< 0x20) label_16F5: // Incoming jump from 0x16F4, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @16F8 memory[0x00:0x00] } 16F5 60 PUSH1 0x00 16F7 80 DUP1 16F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @16F8 revert(memory[0x00:0x00]); } // Block terminates label_16F9: // Incoming jump from 0x16F4, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @16FA stack[-2] // @16FB memory[stack[-2]:stack[-2] + 0x20] // } 16F9 5B JUMPDEST 16FA 81 DUP2 16FB 51 MLOAD 16FC 61 PUSH2 0x0c01 16FF 81 DUP2 1700 61 PUSH2 0x111f 1703 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @16FB stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @16FC stack[1] = 0x0c01 // @16FF stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x111f, returns to 0x0C01 1704 FE *ASSERT 1705 A2 LOG2 1706 64 PUSH5 0x6970667358 170C 22 22 170D 12 SLT 170E 20 SHA3 170F 87 DUP8 1710 03 SUB 1711 A7 A7 1712 D8 D8 1713 BD BD 1714 3C EXTCODECOPY 1715 9B SWAP12 1716 0C 0C 1717 B7 B7 1718 FB FB 1719 99 SWAP10 171A CA CA 171B 19 NOT 171C A2 LOG2 171D FD *REVERT 171E 5D 5D 171F 8D DUP14 1720 8A DUP11 1721 14 EQ 1722 B0 PUSH 1723 9B SWAP12 1724 E7 E7 1725 BC BC 1726 5C 5C 1727 DD DD 1728 81 DUP2 1729 58 PC 172A A4 LOG4 172B F6 F6 172C B0 PUSH 172D 3F EXTCODEHASH 172E 89 DUP10 172F 64 PUSH5 0x736f6c6343 1735 00 *STOP 1736 08 ADDMOD 1737 0F 0F 1738 00 *STOP 1739 33 CALLER