Online Solidity Decompiler

label_0000: // Incoming return from call to 0x1843 at 0x1842 // 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 0x01cd 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x01cd, 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 0x715018a6 0019 11 GT 001A 61 PUSH2 0x00f7 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00f7, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xa22cb465 0024 11 GT 0025 61 PUSH2 0x0095 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0095, if 0xa22cb465 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xa22cb465 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xd519f39b 002F 11 GT 0030 61 PUSH2 0x0064 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0064, if 0xd519f39b > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xd519f39b > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xd519f39b 003A 14 EQ 003B 61 PUSH2 0x04fa 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04fa, if 0xd519f39b == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xd519f39b == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe985e9c5 0045 14 EQ 0046 61 PUSH2 0x051a 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x051a, 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 0xed64da9f 0050 14 EQ 0051 61 PUSH2 0x0563 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0563, if 0xed64da9f == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xed64da9f == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x0578 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0578, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0063 memory[0x00:0x00] } 0060 60 PUSH1 0x00 0062 80 DUP1 0063 FD *REVERT // Stack delta = +0 // Outputs[1] { @0063 revert(memory[0x00:0x00]); } // Block terminates label_0064: // Incoming jump from 0x0033, if 0xd519f39b > stack[-1] // Inputs[1] { @0065 stack[-1] } 0064 5B JUMPDEST 0065 80 DUP1 0066 63 PUSH4 0xa22cb465 006B 14 EQ 006C 61 PUSH2 0x0484 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0484, if 0xa22cb465 == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xb88d4fde 0076 14 EQ 0077 61 PUSH2 0x04a4 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a4, if 0xb88d4fde == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xb88d4fde == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xc87b56dd 0081 14 EQ 0082 61 PUSH2 0x04c4 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c4, if 0xc87b56dd == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xced33bc4 008C 14 EQ 008D 61 PUSH2 0x04e4 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e4, if 0xced33bc4 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xced33bc4 == stack[-1] // Inputs[1] { @0094 memory[0x00:0x00] } 0091 60 PUSH1 0x00 0093 80 DUP1 0094 FD *REVERT // Stack delta = +0 // Outputs[1] { @0094 revert(memory[0x00:0x00]); } // Block terminates label_0095: // Incoming jump from 0x0028, if 0xa22cb465 > stack[-1] // Inputs[1] { @0096 stack[-1] } 0095 5B JUMPDEST 0096 80 DUP1 0097 63 PUSH4 0x8d80854e 009C 11 GT 009D 61 PUSH2 0x00d1 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d1, if 0x8d80854e > stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0x8d80854e > stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0x8d80854e 00A7 14 EQ 00A8 61 PUSH2 0x0417 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0417, if 0x8d80854e == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x8d80854e == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x8da5cb5b 00B2 14 EQ 00B3 61 PUSH2 0x0437 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0437, if 0x8da5cb5b == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x95d89b41 00BD 14 EQ 00BE 61 PUSH2 0x0455 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0455, if 0x95d89b41 == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0xa01ffdff 00C8 14 EQ 00C9 61 PUSH2 0x046a 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x046a, if 0xa01ffdff == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0xa01ffdff == stack[-1] // Inputs[1] { @00D0 memory[0x00:0x00] } 00CD 60 PUSH1 0x00 00CF 80 DUP1 00D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D0 revert(memory[0x00:0x00]); } // Block terminates label_00D1: // Incoming jump from 0x00A0, if 0x8d80854e > stack[-1] // Inputs[1] { @00D2 stack[-1] } 00D1 5B JUMPDEST 00D2 80 DUP1 00D3 63 PUSH4 0x715018a6 00D8 14 EQ 00D9 61 PUSH2 0x03b5 00DC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b5, if 0x715018a6 == stack[-1] label_00DD: // Incoming jump from 0x00DC, if not 0x715018a6 == stack[-1] // Inputs[1] { @00DD stack[-1] } 00DD 80 DUP1 00DE 63 PUSH4 0x75d2a90e 00E3 14 EQ 00E4 61 PUSH2 0x03ca 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ca, if 0x75d2a90e == stack[-1] label_00E8: // Incoming jump from 0x00E7, if not 0x75d2a90e == stack[-1] // Inputs[1] { @00E8 stack[-1] } 00E8 80 DUP1 00E9 63 PUSH4 0x83ae807b 00EE 14 EQ 00EF 61 PUSH2 0x03ea 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ea, if 0x83ae807b == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x83ae807b == stack[-1] // Inputs[1] { @00F6 memory[0x00:0x00] } 00F3 60 PUSH1 0x00 00F5 80 DUP1 00F6 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F6 revert(memory[0x00:0x00]); } // Block terminates label_00F7: // Incoming jump from 0x001D, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00F8 stack[-1] } 00F7 5B JUMPDEST 00F8 80 DUP1 00F9 63 PUSH4 0x2f745c59 00FE 11 GT 00FF 61 PUSH2 0x016f 0102 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x016f, if 0x2f745c59 > stack[-1] label_0103: // Incoming jump from 0x0102, if not 0x2f745c59 > stack[-1] // Inputs[1] { @0103 stack[-1] } 0103 80 DUP1 0104 63 PUSH4 0x4f6ccce7 0109 11 GT 010A 61 PUSH2 0x013e 010D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x013e, if 0x4f6ccce7 > stack[-1] label_010E: // Incoming jump from 0x010D, if not 0x4f6ccce7 > stack[-1] // Inputs[1] { @010E stack[-1] } 010E 80 DUP1 010F 63 PUSH4 0x4f6ccce7 0114 14 EQ 0115 61 PUSH2 0x0335 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0335, if 0x4f6ccce7 == stack[-1] label_0119: // Incoming jump from 0x0118, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @0119 stack[-1] } 0119 80 DUP1 011A 63 PUSH4 0x6352211e 011F 14 EQ 0120 61 PUSH2 0x0355 0123 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0355, if 0x6352211e == stack[-1] label_0124: // Incoming jump from 0x0123, if not 0x6352211e == stack[-1] // Inputs[1] { @0124 stack[-1] } 0124 80 DUP1 0125 63 PUSH4 0x6e63b104 012A 14 EQ 012B 61 PUSH2 0x0375 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0375, if 0x6e63b104 == stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x6e63b104 == stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x70a08231 0135 14 EQ 0136 61 PUSH2 0x0395 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0395, if 0x70a08231 == stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x70a08231 == stack[-1] // Inputs[1] { @013D memory[0x00:0x00] } 013A 60 PUSH1 0x00 013C 80 DUP1 013D FD *REVERT // Stack delta = +0 // Outputs[1] { @013D revert(memory[0x00:0x00]); } // Block terminates label_013E: // Incoming jump from 0x010D, if 0x4f6ccce7 > stack[-1] // Inputs[1] { @013F stack[-1] } 013E 5B JUMPDEST 013F 80 DUP1 0140 63 PUSH4 0x2f745c59 0145 14 EQ 0146 61 PUSH2 0x02d8 0149 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d8, if 0x2f745c59 == stack[-1] label_014A: // Incoming jump from 0x0149, if not 0x2f745c59 == stack[-1] // Inputs[1] { @014A stack[-1] } 014A 80 DUP1 014B 63 PUSH4 0x3232deeb 0150 14 EQ 0151 61 PUSH2 0x02f8 0154 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f8, if 0x3232deeb == stack[-1] label_0155: // Incoming jump from 0x0154, if not 0x3232deeb == stack[-1] // Inputs[1] { @0155 stack[-1] } 0155 80 DUP1 0156 63 PUSH4 0x33958a18 015B 14 EQ 015C 61 PUSH2 0x030d 015F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x030d, if 0x33958a18 == stack[-1] label_0160: // Incoming jump from 0x015F, if not 0x33958a18 == stack[-1] // Inputs[1] { @0160 stack[-1] } 0160 80 DUP1 0161 63 PUSH4 0x42842e0e 0166 14 EQ 0167 61 PUSH2 0x0315 016A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0315, if 0x42842e0e == stack[-1] label_016B: // Incoming jump from 0x016A, if not 0x42842e0e == stack[-1] // Inputs[1] { @016E memory[0x00:0x00] } 016B 60 PUSH1 0x00 016D 80 DUP1 016E FD *REVERT // Stack delta = +0 // Outputs[1] { @016E revert(memory[0x00:0x00]); } // Block terminates label_016F: // Incoming jump from 0x0102, if 0x2f745c59 > stack[-1] // Inputs[1] { @0170 stack[-1] } 016F 5B JUMPDEST 0170 80 DUP1 0171 63 PUSH4 0x095ea7b3 0176 11 GT 0177 61 PUSH2 0x01ab 017A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ab, if 0x095ea7b3 > stack[-1] label_017B: // Incoming jump from 0x017A, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @017B stack[-1] } 017B 80 DUP1 017C 63 PUSH4 0x095ea7b3 0181 14 EQ 0182 61 PUSH2 0x0261 0185 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0261, if 0x095ea7b3 == stack[-1] label_0186: // Incoming jump from 0x0185, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0186 stack[-1] } 0186 80 DUP1 0187 63 PUSH4 0x18160ddd 018C 14 EQ 018D 61 PUSH2 0x0283 0190 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0283, if 0x18160ddd == stack[-1] label_0191: // Incoming jump from 0x0190, if not 0x18160ddd == stack[-1] // Inputs[1] { @0191 stack[-1] } 0191 80 DUP1 0192 63 PUSH4 0x23b872dd 0197 14 EQ 0198 61 PUSH2 0x02a2 019B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a2, if 0x23b872dd == stack[-1] label_019C: // Incoming jump from 0x019B, if not 0x23b872dd == stack[-1] // Inputs[1] { @019C stack[-1] } 019C 80 DUP1 019D 63 PUSH4 0x25f08cf2 01A2 14 EQ 01A3 61 PUSH2 0x02c2 01A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c2, if 0x25f08cf2 == stack[-1] label_01A7: // Incoming jump from 0x01A6, if not 0x25f08cf2 == stack[-1] // Inputs[1] { @01AA memory[0x00:0x00] } 01A7 60 PUSH1 0x00 01A9 80 DUP1 01AA FD *REVERT // Stack delta = +0 // Outputs[1] { @01AA revert(memory[0x00:0x00]); } // Block terminates label_01AB: // Incoming jump from 0x017A, if 0x095ea7b3 > stack[-1] // Inputs[1] { @01AC stack[-1] } 01AB 5B JUMPDEST 01AC 80 DUP1 01AD 63 PUSH4 0x01ffc9a7 01B2 14 EQ 01B3 61 PUSH2 0x01d2 01B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d2, if 0x01ffc9a7 == stack[-1] label_01B7: // Incoming jump from 0x01B6, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01B7 stack[-1] } 01B7 80 DUP1 01B8 63 PUSH4 0x06fdde03 01BD 14 EQ 01BE 61 PUSH2 0x0207 01C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0207, if 0x06fdde03 == stack[-1] label_01C2: // Incoming jump from 0x01C1, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01C2 stack[-1] } 01C2 80 DUP1 01C3 63 PUSH4 0x081812fc 01C8 14 EQ 01C9 61 PUSH2 0x0229 01CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0229, if 0x081812fc == stack[-1] label_01CD: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x01CC, if not 0x081812fc == stack[-1] // Inputs[1] { @01D1 memory[0x00:0x00] } 01CD 5B JUMPDEST 01CE 60 PUSH1 0x00 01D0 80 DUP1 01D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D1 revert(memory[0x00:0x00]); } // Block terminates label_01D2: // Incoming jump from 0x01B6, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01D3 msg.value } 01D2 5B JUMPDEST 01D3 34 CALLVALUE 01D4 80 DUP1 01D5 15 ISZERO 01D6 61 PUSH2 0x01de 01D9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01D3 stack[0] = msg.value } // Block ends with conditional jump to 0x01de, if !msg.value label_01DA: // Incoming jump from 0x01D9, if not !msg.value // Inputs[1] { @01DD memory[0x00:0x00] } 01DA 60 PUSH1 0x00 01DC 80 DUP1 01DD FD *REVERT // Stack delta = +0 // Outputs[1] { @01DD revert(memory[0x00:0x00]); } // Block terminates label_01DE: // Incoming jump from 0x01D9, if !msg.value // Inputs[1] { @01E6 msg.data.length } 01DE 5B JUMPDEST 01DF 50 POP 01E0 61 PUSH2 0x01f2 01E3 61 PUSH2 0x01ed 01E6 36 CALLDATASIZE 01E7 60 PUSH1 0x04 01E9 61 PUSH2 0x1964 01EC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @01E0 stack[-1] = 0x01f2 // @01E3 stack[0] = 0x01ed // @01E6 stack[1] = msg.data.length // @01E7 stack[2] = 0x04 // } // Block ends with call to 0x1964, returns to 0x01ED label_01ED: // Incoming return from call to 0x1964 at 0x01EC 01ED 5B JUMPDEST 01EE 61 PUSH2 0x0598 01F1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0598 label_01F2: // Incoming jump from 0x0483 // Incoming return from call to 0x0535 at 0x0534 // Incoming return from call to 0x01ED at 0x01EC // Inputs[2] // { // @01F5 memory[0x40:0x60] // @01F6 stack[-1] // } 01F2 5B JUMPDEST 01F3 60 PUSH1 0x40 01F5 51 MLOAD 01F6 90 SWAP1 01F7 15 ISZERO 01F8 15 ISZERO 01F9 81 DUP2 01FA 52 MSTORE 01FB 60 PUSH1 0x20 01FD 01 ADD // Stack delta = +0 // Outputs[2] // { // @01FA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @01FD stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_01FE: // Incoming jump from 0x01FD // Incoming jump from 0x02A1 // Incoming jump from 0x0260 // Inputs[3] // { // @0201 memory[0x40:0x60] // @0203 stack[-1] // @0206 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01FE 5B JUMPDEST 01FF 60 PUSH1 0x40 0201 51 MLOAD 0202 80 DUP1 0203 91 SWAP2 0204 03 SUB 0205 90 SWAP1 0206 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0206 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0207: // Incoming jump from 0x01C1, if 0x06fdde03 == stack[-1] // Inputs[1] { @0208 msg.value } 0207 5B JUMPDEST 0208 34 CALLVALUE 0209 80 DUP1 020A 15 ISZERO 020B 61 PUSH2 0x0213 020E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0208 stack[0] = msg.value } // Block ends with conditional jump to 0x0213, if !msg.value label_020F: // Incoming jump from 0x020E, if not !msg.value // Inputs[1] { @0212 memory[0x00:0x00] } 020F 60 PUSH1 0x00 0211 80 DUP1 0212 FD *REVERT // Stack delta = +0 // Outputs[1] { @0212 revert(memory[0x00:0x00]); } // Block terminates label_0213: // Incoming jump from 0x020E, if !msg.value 0213 5B JUMPDEST 0214 50 POP 0215 61 PUSH2 0x021c 0218 61 PUSH2 0x0605 021B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0215 stack[-1] = 0x021c } // Block ends with call to 0x0605, returns to 0x021C label_021C: // Incoming return from call to 0x0CB7 at 0x0469 // Incoming return from call to 0x09A4 at 0x030C // Incoming return from call to 0x04DF at 0x04DE // Incoming return from call to 0x0605 at 0x021B // Inputs[2] // { // @021F memory[0x40:0x60] // @0223 stack[-1] // } 021C 5B JUMPDEST 021D 60 PUSH1 0x40 021F 51 MLOAD 0220 61 PUSH2 0x01fe 0223 91 SWAP2 0224 90 SWAP1 0225 61 PUSH2 0x19d9 0228 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0223 stack[-1] = 0x01fe // @0224 stack[1] = memory[0x40:0x60] // @0224 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x19d9 label_0229: // Incoming jump from 0x01CC, if 0x081812fc == stack[-1] // Inputs[1] { @022A msg.value } 0229 5B JUMPDEST 022A 34 CALLVALUE 022B 80 DUP1 022C 15 ISZERO 022D 61 PUSH2 0x0235 0230 57 *JUMPI // Stack delta = +1 // Outputs[1] { @022A stack[0] = msg.value } // Block ends with conditional jump to 0x0235, if !msg.value label_0231: // Incoming jump from 0x0230, if not !msg.value // Inputs[1] { @0234 memory[0x00:0x00] } 0231 60 PUSH1 0x00 0233 80 DUP1 0234 FD *REVERT // Stack delta = +0 // Outputs[1] { @0234 revert(memory[0x00:0x00]); } // Block terminates label_0235: // Incoming jump from 0x0230, if !msg.value // Inputs[1] { @023D msg.data.length } 0235 5B JUMPDEST 0236 50 POP 0237 61 PUSH2 0x0249 023A 61 PUSH2 0x0244 023D 36 CALLDATASIZE 023E 60 PUSH1 0x04 0240 61 PUSH2 0x19ec 0243 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0237 stack[-1] = 0x0249 // @023A stack[0] = 0x0244 // @023D stack[1] = msg.data.length // @023E stack[2] = 0x04 // } // Block ends with call to 0x19ec, returns to 0x0244 label_0244: // Incoming return from call to 0x19EC at 0x0243 0244 5B JUMPDEST 0245 61 PUSH2 0x0697 0248 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0697 label_0249: // Incoming jump from 0x0454 // Incoming return from call to 0x0370 at 0x036F // Incoming return from call to 0x0244 at 0x0243 // Inputs[2] // { // @024C memory[0x40:0x60] // @0256 stack[-1] // } 0249 5B JUMPDEST 024A 60 PUSH1 0x40 024C 51 MLOAD 024D 60 PUSH1 0x01 024F 60 PUSH1 0x01 0251 60 PUSH1 0xa0 0253 1B SHL 0254 03 SUB 0255 90 SWAP1 0256 91 SWAP2 0257 16 AND 0258 81 DUP2 0259 52 MSTORE 025A 60 PUSH1 0x20 025C 01 ADD 025D 61 PUSH2 0x01fe 0260 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0259 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @025C stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01fe label_0261: // Incoming jump from 0x0185, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0262 msg.value } 0261 5B JUMPDEST 0262 34 CALLVALUE 0263 80 DUP1 0264 15 ISZERO 0265 61 PUSH2 0x026d 0268 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0262 stack[0] = msg.value } // Block ends with conditional jump to 0x026d, if !msg.value label_0269: // Incoming jump from 0x0268, if not !msg.value // Inputs[1] { @026C memory[0x00:0x00] } 0269 60 PUSH1 0x00 026B 80 DUP1 026C FD *REVERT // Stack delta = +0 // Outputs[1] { @026C revert(memory[0x00:0x00]); } // Block terminates label_026D: // Incoming jump from 0x0268, if !msg.value // Inputs[1] { @0275 msg.data.length } 026D 5B JUMPDEST 026E 50 POP 026F 61 PUSH2 0x0281 0272 61 PUSH2 0x027c 0275 36 CALLDATASIZE 0276 60 PUSH1 0x04 0278 61 PUSH2 0x1a21 027B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @026F stack[-1] = 0x0281 // @0272 stack[0] = 0x027c // @0275 stack[1] = msg.data.length // @0276 stack[2] = 0x04 // } // Block ends with call to 0x1a21, returns to 0x027C label_027C: // Incoming return from call to 0x1A21 at 0x027B 027C 5B JUMPDEST 027D 61 PUSH2 0x0727 0280 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0727 label_0281: // Incoming return from call to 0x0A32 at 0x0314 // Incoming return from call to 0x049F at 0x049E // Incoming return from call to 0x0432 at 0x0431 // Incoming return from call to 0x03E5 at 0x03E4 // Incoming return from call to 0x0EDF at 0x0577 // Incoming return from call to 0x0C15 at 0x03C9 0281 5B JUMPDEST 0282 00 *STOP // Stack delta = +0 // Outputs[1] { @0282 stop(); } // Block terminates label_0283: // Incoming jump from 0x0190, if 0x18160ddd == stack[-1] // Inputs[1] { @0284 msg.value } 0283 5B JUMPDEST 0284 34 CALLVALUE 0285 80 DUP1 0286 15 ISZERO 0287 61 PUSH2 0x028f 028A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0284 stack[0] = msg.value } // Block ends with conditional jump to 0x028f, if !msg.value label_028B: // Incoming jump from 0x028A, if not !msg.value // Inputs[1] { @028E memory[0x00:0x00] } 028B 60 PUSH1 0x00 028D 80 DUP1 028E FD *REVERT // Stack delta = +0 // Outputs[1] { @028E revert(memory[0x00:0x00]); } // Block terminates label_028F: // Incoming jump from 0x028A, if !msg.value // Inputs[1] { @0293 storage[0x00] } 028F 5B JUMPDEST 0290 50 POP 0291 60 PUSH1 0x00 0293 54 SLOAD // Stack delta = +0 // Outputs[1] { @0293 stack[-1] = storage[0x00] } // Block continues label_0294: // Incoming jump from 0x04F9 // Incoming return from call to 0x03B0 at 0x03AF // Incoming jump from 0x02D7 // Incoming return from call to 0x0350 at 0x034F // Incoming return from call to 0x02F3 at 0x02F2 // Incoming return from call to 0x0405 at 0x0404 // Incoming jump from 0x0293 // Inputs[2] // { // @0297 memory[0x40:0x60] // @0298 stack[-1] // } 0294 5B JUMPDEST 0295 60 PUSH1 0x40 0297 51 MLOAD 0298 90 SWAP1 0299 81 DUP2 029A 52 MSTORE 029B 60 PUSH1 0x20 029D 01 ADD 029E 61 PUSH2 0x01fe 02A1 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @029A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @029D stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01fe label_02A2: // Incoming jump from 0x019B, if 0x23b872dd == stack[-1] // Inputs[1] { @02A3 msg.value } 02A2 5B JUMPDEST 02A3 34 CALLVALUE 02A4 80 DUP1 02A5 15 ISZERO 02A6 61 PUSH2 0x02ae 02A9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02A3 stack[0] = msg.value } // Block ends with conditional jump to 0x02ae, if !msg.value label_02AA: // Incoming jump from 0x02A9, if not !msg.value // Inputs[1] { @02AD memory[0x00:0x00] } 02AA 60 PUSH1 0x00 02AC 80 DUP1 02AD FD *REVERT // Stack delta = +0 // Outputs[1] { @02AD revert(memory[0x00:0x00]); } // Block terminates label_02AE: // Incoming jump from 0x02A9, if !msg.value // Inputs[1] { @02B6 msg.data.length } 02AE 5B JUMPDEST 02AF 50 POP 02B0 61 PUSH2 0x0281 02B3 61 PUSH2 0x02bd 02B6 36 CALLDATASIZE 02B7 60 PUSH1 0x04 02B9 61 PUSH2 0x1a4b 02BC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02B0 stack[-1] = 0x0281 // @02B3 stack[0] = 0x02bd // @02B6 stack[1] = msg.data.length // @02B7 stack[2] = 0x04 // } // Block ends with call to 0x1a4b, returns to 0x02BD label_02BD: // Incoming return from call to 0x1A4B at 0x02BC 02BD 5B JUMPDEST 02BE 61 PUSH2 0x083e 02C1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x083e label_02C2: // Incoming jump from 0x01A6, if 0x25f08cf2 == stack[-1] // Inputs[1] { @02C3 msg.value } 02C2 5B JUMPDEST 02C3 34 CALLVALUE 02C4 80 DUP1 02C5 15 ISZERO 02C6 61 PUSH2 0x02ce 02C9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C3 stack[0] = msg.value } // Block ends with conditional jump to 0x02ce, if !msg.value label_02CA: // Incoming jump from 0x02C9, if not !msg.value // Inputs[1] { @02CD memory[0x00:0x00] } 02CA 60 PUSH1 0x00 02CC 80 DUP1 02CD FD *REVERT // Stack delta = +0 // Outputs[1] { @02CD revert(memory[0x00:0x00]); } // Block terminates label_02CE: // Incoming jump from 0x02C9, if !msg.value // Inputs[1] { @02D5 storage[0x0c] } 02CE 5B JUMPDEST 02CF 50 POP 02D0 61 PUSH2 0x0294 02D3 60 PUSH1 0x0c 02D5 54 SLOAD 02D6 81 DUP2 02D7 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @02D0 stack[-1] = 0x0294 // @02D5 stack[0] = storage[0x0c] // } // Block ends with unconditional jump to 0x0294 label_02D8: // Incoming jump from 0x0149, if 0x2f745c59 == stack[-1] // Inputs[1] { @02D9 msg.value } 02D8 5B JUMPDEST 02D9 34 CALLVALUE 02DA 80 DUP1 02DB 15 ISZERO 02DC 61 PUSH2 0x02e4 02DF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02D9 stack[0] = msg.value } // Block ends with conditional jump to 0x02e4, if !msg.value label_02E0: // Incoming jump from 0x02DF, if not !msg.value // Inputs[1] { @02E3 memory[0x00:0x00] } 02E0 60 PUSH1 0x00 02E2 80 DUP1 02E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @02E3 revert(memory[0x00:0x00]); } // Block terminates label_02E4: // Incoming jump from 0x02DF, if !msg.value // Inputs[1] { @02EC msg.data.length } 02E4 5B JUMPDEST 02E5 50 POP 02E6 61 PUSH2 0x0294 02E9 61 PUSH2 0x02f3 02EC 36 CALLDATASIZE 02ED 60 PUSH1 0x04 02EF 61 PUSH2 0x1a21 02F2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02E6 stack[-1] = 0x0294 // @02E9 stack[0] = 0x02f3 // @02EC stack[1] = msg.data.length // @02ED stack[2] = 0x04 // } // Block ends with call to 0x1a21, returns to 0x02F3 label_02F3: // Incoming return from call to 0x1A21 at 0x02F2 02F3 5B JUMPDEST 02F4 61 PUSH2 0x0849 02F7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0849 label_02F8: // Incoming jump from 0x0154, if 0x3232deeb == stack[-1] // Inputs[1] { @02F9 msg.value } 02F8 5B JUMPDEST 02F9 34 CALLVALUE 02FA 80 DUP1 02FB 15 ISZERO 02FC 61 PUSH2 0x0304 02FF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F9 stack[0] = msg.value } // Block ends with conditional jump to 0x0304, if !msg.value label_0300: // Incoming jump from 0x02FF, if not !msg.value // Inputs[1] { @0303 memory[0x00:0x00] } 0300 60 PUSH1 0x00 0302 80 DUP1 0303 FD *REVERT // Stack delta = +0 // Outputs[1] { @0303 revert(memory[0x00:0x00]); } // Block terminates label_0304: // Incoming jump from 0x02FF, if !msg.value 0304 5B JUMPDEST 0305 50 POP 0306 61 PUSH2 0x021c 0309 61 PUSH2 0x09a4 030C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0306 stack[-1] = 0x021c } // Block ends with call to 0x09a4, returns to 0x021C label_030D: // Incoming jump from 0x015F, if 0x33958a18 == stack[-1] 030D 5B JUMPDEST 030E 61 PUSH2 0x0281 0311 61 PUSH2 0x0a32 0314 56 *JUMP // Stack delta = +1 // Outputs[1] { @030E stack[0] = 0x0281 } // Block ends with call to 0x0a32, returns to 0x0281 label_0315: // Incoming jump from 0x016A, if 0x42842e0e == stack[-1] // Inputs[1] { @0316 msg.value } 0315 5B JUMPDEST 0316 34 CALLVALUE 0317 80 DUP1 0318 15 ISZERO 0319 61 PUSH2 0x0321 031C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0316 stack[0] = msg.value } // Block ends with conditional jump to 0x0321, if !msg.value label_031D: // Incoming jump from 0x031C, if not !msg.value // Inputs[1] { @0320 memory[0x00:0x00] } 031D 60 PUSH1 0x00 031F 80 DUP1 0320 FD *REVERT // Stack delta = +0 // Outputs[1] { @0320 revert(memory[0x00:0x00]); } // Block terminates label_0321: // Incoming jump from 0x031C, if !msg.value // Inputs[1] { @0329 msg.data.length } 0321 5B JUMPDEST 0322 50 POP 0323 61 PUSH2 0x0281 0326 61 PUSH2 0x0330 0329 36 CALLDATASIZE 032A 60 PUSH1 0x04 032C 61 PUSH2 0x1a4b 032F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0323 stack[-1] = 0x0281 // @0326 stack[0] = 0x0330 // @0329 stack[1] = msg.data.length // @032A stack[2] = 0x04 // } // Block ends with call to 0x1a4b, returns to 0x0330 label_0330: // Incoming return from call to 0x1A4B at 0x032F 0330 5B JUMPDEST 0331 61 PUSH2 0x0ab4 0334 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ab4 label_0335: // Incoming jump from 0x0118, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @0336 msg.value } 0335 5B JUMPDEST 0336 34 CALLVALUE 0337 80 DUP1 0338 15 ISZERO 0339 61 PUSH2 0x0341 033C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0336 stack[0] = msg.value } // Block ends with conditional jump to 0x0341, if !msg.value label_033D: // Incoming jump from 0x033C, if not !msg.value // Inputs[1] { @0340 memory[0x00:0x00] } 033D 60 PUSH1 0x00 033F 80 DUP1 0340 FD *REVERT // Stack delta = +0 // Outputs[1] { @0340 revert(memory[0x00:0x00]); } // Block terminates label_0341: // Incoming jump from 0x033C, if !msg.value // Inputs[1] { @0349 msg.data.length } 0341 5B JUMPDEST 0342 50 POP 0343 61 PUSH2 0x0294 0346 61 PUSH2 0x0350 0349 36 CALLDATASIZE 034A 60 PUSH1 0x04 034C 61 PUSH2 0x19ec 034F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0343 stack[-1] = 0x0294 // @0346 stack[0] = 0x0350 // @0349 stack[1] = msg.data.length // @034A stack[2] = 0x04 // } // Block ends with call to 0x19ec, returns to 0x0350 label_0350: // Incoming return from call to 0x19EC at 0x034F 0350 5B JUMPDEST 0351 61 PUSH2 0x0acf 0354 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0acf label_0355: // Incoming jump from 0x0123, if 0x6352211e == stack[-1] // Inputs[1] { @0356 msg.value } 0355 5B JUMPDEST 0356 34 CALLVALUE 0357 80 DUP1 0358 15 ISZERO 0359 61 PUSH2 0x0361 035C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0356 stack[0] = msg.value } // Block ends with conditional jump to 0x0361, if !msg.value label_035D: // Incoming jump from 0x035C, if not !msg.value // Inputs[1] { @0360 memory[0x00:0x00] } 035D 60 PUSH1 0x00 035F 80 DUP1 0360 FD *REVERT // Stack delta = +0 // Outputs[1] { @0360 revert(memory[0x00:0x00]); } // Block terminates label_0361: // Incoming jump from 0x035C, if !msg.value // Inputs[1] { @0369 msg.data.length } 0361 5B JUMPDEST 0362 50 POP 0363 61 PUSH2 0x0249 0366 61 PUSH2 0x0370 0369 36 CALLDATASIZE 036A 60 PUSH1 0x04 036C 61 PUSH2 0x19ec 036F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0363 stack[-1] = 0x0249 // @0366 stack[0] = 0x0370 // @0369 stack[1] = msg.data.length // @036A stack[2] = 0x04 // } // Block ends with call to 0x19ec, returns to 0x0370 label_0370: // Incoming return from call to 0x19EC at 0x036F 0370 5B JUMPDEST 0371 61 PUSH2 0x0b31 0374 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b31 label_0375: // Incoming jump from 0x012E, if 0x6e63b104 == stack[-1] // Inputs[1] { @0376 msg.value } 0375 5B JUMPDEST 0376 34 CALLVALUE 0377 80 DUP1 0378 15 ISZERO 0379 61 PUSH2 0x0381 037C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0376 stack[0] = msg.value } // Block ends with conditional jump to 0x0381, if !msg.value label_037D: // Incoming jump from 0x037C, if not !msg.value // Inputs[1] { @0380 memory[0x00:0x00] } 037D 60 PUSH1 0x00 037F 80 DUP1 0380 FD *REVERT // Stack delta = +0 // Outputs[1] { @0380 revert(memory[0x00:0x00]); } // Block terminates label_0381: // Incoming jump from 0x037C, if !msg.value // Inputs[1] { @0389 msg.data.length } 0381 5B JUMPDEST 0382 50 POP 0383 61 PUSH2 0x0281 0386 61 PUSH2 0x0390 0389 36 CALLDATASIZE 038A 60 PUSH1 0x04 038C 61 PUSH2 0x1b13 038F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0383 stack[-1] = 0x0281 // @0386 stack[0] = 0x0390 // @0389 stack[1] = msg.data.length // @038A stack[2] = 0x04 // } // Block ends with call to 0x1b13, returns to 0x0390 label_0390: // Incoming return from call to 0x1B13 at 0x038F 0390 5B JUMPDEST 0391 61 PUSH2 0x0b43 0394 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b43 label_0395: // Incoming jump from 0x0139, if 0x70a08231 == stack[-1] // Inputs[1] { @0396 msg.value } 0395 5B JUMPDEST 0396 34 CALLVALUE 0397 80 DUP1 0398 15 ISZERO 0399 61 PUSH2 0x03a1 039C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0396 stack[0] = msg.value } // Block ends with conditional jump to 0x03a1, if !msg.value label_039D: // Incoming jump from 0x039C, if not !msg.value // Inputs[1] { @03A0 memory[0x00:0x00] } 039D 60 PUSH1 0x00 039F 80 DUP1 03A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A0 revert(memory[0x00:0x00]); } // Block terminates label_03A1: // Incoming jump from 0x039C, if !msg.value // Inputs[1] { @03A9 msg.data.length } 03A1 5B JUMPDEST 03A2 50 POP 03A3 61 PUSH2 0x0294 03A6 61 PUSH2 0x03b0 03A9 36 CALLDATASIZE 03AA 60 PUSH1 0x04 03AC 61 PUSH2 0x1b5c 03AF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03A3 stack[-1] = 0x0294 // @03A6 stack[0] = 0x03b0 // @03A9 stack[1] = msg.data.length // @03AA stack[2] = 0x04 // } // Block ends with call to 0x1b5c, returns to 0x03B0 label_03B0: // Incoming return from call to 0x1B5C at 0x03AF 03B0 5B JUMPDEST 03B1 61 PUSH2 0x0b84 03B4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b84 label_03B5: // Incoming jump from 0x00DC, if 0x715018a6 == stack[-1] // Inputs[1] { @03B6 msg.value } 03B5 5B JUMPDEST 03B6 34 CALLVALUE 03B7 80 DUP1 03B8 15 ISZERO 03B9 61 PUSH2 0x03c1 03BC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03B6 stack[0] = msg.value } // Block ends with conditional jump to 0x03c1, if !msg.value label_03BD: // Incoming jump from 0x03BC, if not !msg.value // Inputs[1] { @03C0 memory[0x00:0x00] } 03BD 60 PUSH1 0x00 03BF 80 DUP1 03C0 FD *REVERT // Stack delta = +0 // Outputs[1] { @03C0 revert(memory[0x00:0x00]); } // Block terminates label_03C1: // Incoming jump from 0x03BC, if !msg.value 03C1 5B JUMPDEST 03C2 50 POP 03C3 61 PUSH2 0x0281 03C6 61 PUSH2 0x0c15 03C9 56 *JUMP // Stack delta = +0 // Outputs[1] { @03C3 stack[-1] = 0x0281 } // Block ends with call to 0x0c15, returns to 0x0281 label_03CA: // Incoming jump from 0x00E7, if 0x75d2a90e == stack[-1] // Inputs[1] { @03CB msg.value } 03CA 5B JUMPDEST 03CB 34 CALLVALUE 03CC 80 DUP1 03CD 15 ISZERO 03CE 61 PUSH2 0x03d6 03D1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03CB stack[0] = msg.value } // Block ends with conditional jump to 0x03d6, if !msg.value label_03D2: // Incoming jump from 0x03D1, if not !msg.value // Inputs[1] { @03D5 memory[0x00:0x00] } 03D2 60 PUSH1 0x00 03D4 80 DUP1 03D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D5 revert(memory[0x00:0x00]); } // Block terminates label_03D6: // Incoming jump from 0x03D1, if !msg.value // Inputs[1] { @03DE msg.data.length } 03D6 5B JUMPDEST 03D7 50 POP 03D8 61 PUSH2 0x0281 03DB 61 PUSH2 0x03e5 03DE 36 CALLDATASIZE 03DF 60 PUSH1 0x04 03E1 61 PUSH2 0x19ec 03E4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03D8 stack[-1] = 0x0281 // @03DB stack[0] = 0x03e5 // @03DE stack[1] = msg.data.length // @03DF stack[2] = 0x04 // } // Block ends with call to 0x19ec, returns to 0x03E5 label_03E5: // Incoming return from call to 0x19EC at 0x03E4 03E5 5B JUMPDEST 03E6 61 PUSH2 0x0c4b 03E9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c4b label_03EA: // Incoming jump from 0x00F2, if 0x83ae807b == stack[-1] // Inputs[1] { @03EB msg.value } 03EA 5B JUMPDEST 03EB 34 CALLVALUE 03EC 80 DUP1 03ED 15 ISZERO 03EE 61 PUSH2 0x03f6 03F1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03EB stack[0] = msg.value } // Block ends with conditional jump to 0x03f6, if !msg.value label_03F2: // Incoming jump from 0x03F1, if not !msg.value // Inputs[1] { @03F5 memory[0x00:0x00] } 03F2 60 PUSH1 0x00 03F4 80 DUP1 03F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F5 revert(memory[0x00:0x00]); } // Block terminates label_03F6: // Incoming jump from 0x03F1, if !msg.value // Inputs[1] { @03FE msg.data.length } 03F6 5B JUMPDEST 03F7 50 POP 03F8 61 PUSH2 0x0294 03FB 61 PUSH2 0x0405 03FE 36 CALLDATASIZE 03FF 60 PUSH1 0x04 0401 61 PUSH2 0x1b5c 0404 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03F8 stack[-1] = 0x0294 // @03FB stack[0] = 0x0405 // @03FE stack[1] = msg.data.length // @03FF stack[2] = 0x04 // } // Block ends with call to 0x1b5c, returns to 0x0405 label_0405: // Incoming return from call to 0x1B5C at 0x0404 // Inputs[4] // { // @040D stack[-1] // @0413 memory[0x00:0x40] // @0414 storage[keccak256(memory[0x00:0x40])] // @0415 stack[-2] // } 0405 5B JUMPDEST 0406 60 PUSH1 0x0d 0408 60 PUSH1 0x20 040A 52 MSTORE 040B 60 PUSH1 0x00 040D 90 SWAP1 040E 81 DUP2 040F 52 MSTORE 0410 60 PUSH1 0x40 0412 90 SWAP1 0413 20 SHA3 0414 54 SLOAD 0415 81 DUP2 0416 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @040A memory[0x20:0x40] = 0x0d // @040F memory[0x00:0x20] = stack[-1] // @0414 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0417: // Incoming jump from 0x00AB, if 0x8d80854e == stack[-1] // Inputs[1] { @0418 msg.value } 0417 5B JUMPDEST 0418 34 CALLVALUE 0419 80 DUP1 041A 15 ISZERO 041B 61 PUSH2 0x0423 041E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0418 stack[0] = msg.value } // Block ends with conditional jump to 0x0423, if !msg.value label_041F: // Incoming jump from 0x041E, if not !msg.value // Inputs[1] { @0422 memory[0x00:0x00] } 041F 60 PUSH1 0x00 0421 80 DUP1 0422 FD *REVERT // Stack delta = +0 // Outputs[1] { @0422 revert(memory[0x00:0x00]); } // Block terminates label_0423: // Incoming jump from 0x041E, if !msg.value // Inputs[1] { @042B msg.data.length } 0423 5B JUMPDEST 0424 50 POP 0425 61 PUSH2 0x0281 0428 61 PUSH2 0x0432 042B 36 CALLDATASIZE 042C 60 PUSH1 0x04 042E 61 PUSH2 0x1b87 0431 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0425 stack[-1] = 0x0281 // @0428 stack[0] = 0x0432 // @042B stack[1] = msg.data.length // @042C stack[2] = 0x04 // } // Block ends with call to 0x1b87, returns to 0x0432 label_0432: // Incoming return from call to 0x1B87 at 0x0431 0432 5B JUMPDEST 0433 61 PUSH2 0x0c7a 0436 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c7a label_0437: // Incoming jump from 0x00B6, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0438 msg.value } 0437 5B JUMPDEST 0438 34 CALLVALUE 0439 80 DUP1 043A 15 ISZERO 043B 61 PUSH2 0x0443 043E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0438 stack[0] = msg.value } // Block ends with conditional jump to 0x0443, if !msg.value label_043F: // Incoming jump from 0x043E, if not !msg.value // Inputs[1] { @0442 memory[0x00:0x00] } 043F 60 PUSH1 0x00 0441 80 DUP1 0442 FD *REVERT // Stack delta = +0 // Outputs[1] { @0442 revert(memory[0x00:0x00]); } // Block terminates label_0443: // Incoming jump from 0x043E, if !msg.value // Inputs[1] { @0447 storage[0x07] } 0443 5B JUMPDEST 0444 50 POP 0445 60 PUSH1 0x07 0447 54 SLOAD 0448 60 PUSH1 0x01 044A 60 PUSH1 0x01 044C 60 PUSH1 0xa0 044E 1B SHL 044F 03 SUB 0450 16 AND 0451 61 PUSH2 0x0249 0454 56 *JUMP // Stack delta = +0 // Outputs[1] { @0450 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x07] } // Block ends with unconditional jump to 0x0249 label_0455: // Incoming jump from 0x00C1, if 0x95d89b41 == stack[-1] // Inputs[1] { @0456 msg.value } 0455 5B JUMPDEST 0456 34 CALLVALUE 0457 80 DUP1 0458 15 ISZERO 0459 61 PUSH2 0x0461 045C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0456 stack[0] = msg.value } // Block ends with conditional jump to 0x0461, if !msg.value label_045D: // Incoming jump from 0x045C, if not !msg.value // Inputs[1] { @0460 memory[0x00:0x00] } 045D 60 PUSH1 0x00 045F 80 DUP1 0460 FD *REVERT // Stack delta = +0 // Outputs[1] { @0460 revert(memory[0x00:0x00]); } // Block terminates label_0461: // Incoming jump from 0x045C, if !msg.value 0461 5B JUMPDEST 0462 50 POP 0463 61 PUSH2 0x021c 0466 61 PUSH2 0x0cb7 0469 56 *JUMP // Stack delta = +0 // Outputs[1] { @0463 stack[-1] = 0x021c } // Block ends with call to 0x0cb7, returns to 0x021C label_046A: // Incoming jump from 0x00CC, if 0xa01ffdff == stack[-1] // Inputs[1] { @046B msg.value } 046A 5B JUMPDEST 046B 34 CALLVALUE 046C 80 DUP1 046D 15 ISZERO 046E 61 PUSH2 0x0476 0471 57 *JUMPI // Stack delta = +1 // Outputs[1] { @046B stack[0] = msg.value } // Block ends with conditional jump to 0x0476, if !msg.value label_0472: // Incoming jump from 0x0471, if not !msg.value // Inputs[1] { @0475 memory[0x00:0x00] } 0472 60 PUSH1 0x00 0474 80 DUP1 0475 FD *REVERT // Stack delta = +0 // Outputs[1] { @0475 revert(memory[0x00:0x00]); } // Block terminates label_0476: // Incoming jump from 0x0471, if !msg.value // Inputs[1] { @047A storage[0x0a] } 0476 5B JUMPDEST 0477 50 POP 0478 60 PUSH1 0x0a 047A 54 SLOAD 047B 61 PUSH2 0x01f2 047E 90 SWAP1 047F 60 PUSH1 0xff 0481 16 AND 0482 81 DUP2 0483 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @047E stack[-1] = 0x01f2 // @0481 stack[0] = 0xff & storage[0x0a] // } // Block ends with unconditional jump to 0x01f2 label_0484: // Incoming jump from 0x006F, if 0xa22cb465 == stack[-1] // Inputs[1] { @0485 msg.value } 0484 5B JUMPDEST 0485 34 CALLVALUE 0486 80 DUP1 0487 15 ISZERO 0488 61 PUSH2 0x0490 048B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0485 stack[0] = msg.value } // Block ends with conditional jump to 0x0490, if !msg.value label_048C: // Incoming jump from 0x048B, if not !msg.value // Inputs[1] { @048F memory[0x00:0x00] } 048C 60 PUSH1 0x00 048E 80 DUP1 048F FD *REVERT // Stack delta = +0 // Outputs[1] { @048F revert(memory[0x00:0x00]); } // Block terminates label_0490: // Incoming jump from 0x048B, if !msg.value // Inputs[1] { @0498 msg.data.length } 0490 5B JUMPDEST 0491 50 POP 0492 61 PUSH2 0x0281 0495 61 PUSH2 0x049f 0498 36 CALLDATASIZE 0499 60 PUSH1 0x04 049B 61 PUSH2 0x1ba2 049E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0492 stack[-1] = 0x0281 // @0495 stack[0] = 0x049f // @0498 stack[1] = msg.data.length // @0499 stack[2] = 0x04 // } // Block ends with call to 0x1ba2, returns to 0x049F label_049F: // Incoming return from call to 0x1BA2 at 0x049E 049F 5B JUMPDEST 04A0 61 PUSH2 0x0cc6 04A3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cc6 label_04A4: // Incoming jump from 0x007A, if 0xb88d4fde == stack[-1] // Inputs[1] { @04A5 msg.value } 04A4 5B JUMPDEST 04A5 34 CALLVALUE 04A6 80 DUP1 04A7 15 ISZERO 04A8 61 PUSH2 0x04b0 04AB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04A5 stack[0] = msg.value } // Block ends with conditional jump to 0x04b0, if !msg.value label_04AC: // Incoming jump from 0x04AB, if not !msg.value // Inputs[1] { @04AF memory[0x00:0x00] } 04AC 60 PUSH1 0x00 04AE 80 DUP1 04AF FD *REVERT // Stack delta = +0 // Outputs[1] { @04AF revert(memory[0x00:0x00]); } // Block terminates label_04B0: // Incoming jump from 0x04AB, if !msg.value // Inputs[1] { @04B8 msg.data.length } 04B0 5B JUMPDEST 04B1 50 POP 04B2 61 PUSH2 0x0281 04B5 61 PUSH2 0x04bf 04B8 36 CALLDATASIZE 04B9 60 PUSH1 0x04 04BB 61 PUSH2 0x1bd5 04BE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04B2 stack[-1] = 0x0281 // @04B5 stack[0] = 0x04bf // @04B8 stack[1] = msg.data.length // @04B9 stack[2] = 0x04 // } // Block ends with call to 0x1bd5, returns to 0x04BF label_04BF: // Incoming return from call to 0x1BD5 at 0x04BE 04BF 5B JUMPDEST 04C0 61 PUSH2 0x0d8a 04C3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d8a label_04C4: // Incoming jump from 0x0085, if 0xc87b56dd == stack[-1] // Inputs[1] { @04C5 msg.value } 04C4 5B JUMPDEST 04C5 34 CALLVALUE 04C6 80 DUP1 04C7 15 ISZERO 04C8 61 PUSH2 0x04d0 04CB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04C5 stack[0] = msg.value } // Block ends with conditional jump to 0x04d0, if !msg.value label_04CC: // Incoming jump from 0x04CB, if not !msg.value // Inputs[1] { @04CF memory[0x00:0x00] } 04CC 60 PUSH1 0x00 04CE 80 DUP1 04CF FD *REVERT // Stack delta = +0 // Outputs[1] { @04CF revert(memory[0x00:0x00]); } // Block terminates label_04D0: // Incoming jump from 0x04CB, if !msg.value // Inputs[1] { @04D8 msg.data.length } 04D0 5B JUMPDEST 04D1 50 POP 04D2 61 PUSH2 0x021c 04D5 61 PUSH2 0x04df 04D8 36 CALLDATASIZE 04D9 60 PUSH1 0x04 04DB 61 PUSH2 0x19ec 04DE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04D2 stack[-1] = 0x021c // @04D5 stack[0] = 0x04df // @04D8 stack[1] = msg.data.length // @04D9 stack[2] = 0x04 // } // Block ends with call to 0x19ec, returns to 0x04DF label_04DF: // Incoming return from call to 0x19EC at 0x04DE 04DF 5B JUMPDEST 04E0 61 PUSH2 0x0dc3 04E3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dc3 label_04E4: // Incoming jump from 0x0090, if 0xced33bc4 == stack[-1] // Inputs[1] { @04E5 msg.value } 04E4 5B JUMPDEST 04E5 34 CALLVALUE 04E6 80 DUP1 04E7 15 ISZERO 04E8 61 PUSH2 0x04f0 04EB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04E5 stack[0] = msg.value } // Block ends with conditional jump to 0x04f0, if !msg.value label_04EC: // Incoming jump from 0x04EB, if not !msg.value // Inputs[1] { @04EF memory[0x00:0x00] } 04EC 60 PUSH1 0x00 04EE 80 DUP1 04EF FD *REVERT // Stack delta = +0 // Outputs[1] { @04EF revert(memory[0x00:0x00]); } // Block terminates label_04F0: // Incoming jump from 0x04EB, if !msg.value // Inputs[1] { @04F7 storage[0x0b] } 04F0 5B JUMPDEST 04F1 50 POP 04F2 61 PUSH2 0x0294 04F5 60 PUSH1 0x0b 04F7 54 SLOAD 04F8 81 DUP2 04F9 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04F2 stack[-1] = 0x0294 // @04F7 stack[0] = storage[0x0b] // } // Block ends with unconditional jump to 0x0294 label_04FA: // Incoming jump from 0x003E, if 0xd519f39b == stack[-1] // Inputs[1] { @04FB msg.value } 04FA 5B JUMPDEST 04FB 34 CALLVALUE 04FC 80 DUP1 04FD 15 ISZERO 04FE 61 PUSH2 0x0506 0501 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04FB stack[0] = msg.value } // Block ends with conditional jump to 0x0506, if !msg.value label_0502: // Incoming jump from 0x0501, if not !msg.value // Inputs[1] { @0505 memory[0x00:0x00] } 0502 60 PUSH1 0x00 0504 80 DUP1 0505 FD *REVERT // Stack delta = +0 // Outputs[1] { @0505 revert(memory[0x00:0x00]); } // Block terminates label_0506: // Incoming jump from 0x0501, if !msg.value // Inputs[1] { @050E msg.data.length } 0506 5B JUMPDEST 0507 50 POP 0508 61 PUSH2 0x0281 050B 61 PUSH2 0x0515 050E 36 CALLDATASIZE 050F 60 PUSH1 0x04 0511 61 PUSH2 0x1a21 0514 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0508 stack[-1] = 0x0281 // @050B stack[0] = 0x0515 // @050E stack[1] = msg.data.length // @050F stack[2] = 0x04 // } // Block ends with call to 0x1a21, returns to 0x0515 label_0515: // Incoming return from call to 0x1A21 at 0x0514 0515 5B JUMPDEST 0516 61 PUSH2 0x0e90 0519 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e90 label_051A: // Incoming jump from 0x0049, if 0xe985e9c5 == stack[-1] // Inputs[1] { @051B msg.value } 051A 5B JUMPDEST 051B 34 CALLVALUE 051C 80 DUP1 051D 15 ISZERO 051E 61 PUSH2 0x0526 0521 57 *JUMPI // Stack delta = +1 // Outputs[1] { @051B stack[0] = msg.value } // Block ends with conditional jump to 0x0526, if !msg.value label_0522: // Incoming jump from 0x0521, if not !msg.value // Inputs[1] { @0525 memory[0x00:0x00] } 0522 60 PUSH1 0x00 0524 80 DUP1 0525 FD *REVERT // Stack delta = +0 // Outputs[1] { @0525 revert(memory[0x00:0x00]); } // Block terminates label_0526: // Incoming jump from 0x0521, if !msg.value // Inputs[1] { @052E msg.data.length } 0526 5B JUMPDEST 0527 50 POP 0528 61 PUSH2 0x01f2 052B 61 PUSH2 0x0535 052E 36 CALLDATASIZE 052F 60 PUSH1 0x04 0531 61 PUSH2 0x1c51 0534 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0528 stack[-1] = 0x01f2 // @052B stack[0] = 0x0535 // @052E stack[1] = msg.data.length // @052F stack[2] = 0x04 // } // Block ends with call to 0x1c51, returns to 0x0535 label_0535: // Incoming return from call to 0x1C51 at 0x0534 // Incoming call from 0x07BB, returns to 0x07BC // Incoming call from 0x110E, returns to 0x110F // Inputs[6] // { // @053E stack[-2] // @0551 memory[0x00:0x40] // @0552 stack[-1] // @055C memory[0x00:0x40] // @055D storage[keccak256(memory[0x00:0x40])] // @0561 stack[-3] // } 0535 5B JUMPDEST 0536 60 PUSH1 0x01 0538 60 PUSH1 0x01 053A 60 PUSH1 0xa0 053C 1B SHL 053D 03 SUB 053E 91 SWAP2 053F 82 DUP3 0540 16 AND 0541 60 PUSH1 0x00 0543 90 SWAP1 0544 81 DUP2 0545 52 MSTORE 0546 60 PUSH1 0x06 0548 60 PUSH1 0x20 054A 90 SWAP1 054B 81 DUP2 054C 52 MSTORE 054D 60 PUSH1 0x40 054F 80 DUP1 0550 83 DUP4 0551 20 SHA3 0552 93 SWAP4 0553 90 SWAP1 0554 94 SWAP5 0555 16 AND 0556 82 DUP3 0557 52 MSTORE 0558 91 SWAP2 0559 90 SWAP1 055A 91 SWAP2 055B 52 MSTORE 055C 20 SHA3 055D 54 SLOAD 055E 60 PUSH1 0xff 0560 16 AND 0561 90 SWAP1 0562 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0545 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @054C memory[0x20:0x40] = 0x06 // @0557 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @055B memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0561 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0563: // Incoming jump from 0x0054, if 0xed64da9f == stack[-1] // Inputs[1] { @0564 msg.value } 0563 5B JUMPDEST 0564 34 CALLVALUE 0565 80 DUP1 0566 15 ISZERO 0567 61 PUSH2 0x056f 056A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0564 stack[0] = msg.value } // Block ends with conditional jump to 0x056f, if !msg.value label_056B: // Incoming jump from 0x056A, if not !msg.value // Inputs[1] { @056E memory[0x00:0x00] } 056B 60 PUSH1 0x00 056D 80 DUP1 056E FD *REVERT // Stack delta = +0 // Outputs[1] { @056E revert(memory[0x00:0x00]); } // Block terminates label_056F: // Incoming jump from 0x056A, if !msg.value 056F 5B JUMPDEST 0570 50 POP 0571 61 PUSH2 0x0281 0574 61 PUSH2 0x0edf 0577 56 *JUMP // Stack delta = +0 // Outputs[1] { @0571 stack[-1] = 0x0281 } // Block ends with call to 0x0edf, returns to 0x0281 label_0578: // Incoming jump from 0x005F, if 0xf2fde38b == stack[-1] // Inputs[1] { @0579 msg.value } 0578 5B JUMPDEST 0579 34 CALLVALUE 057A 80 DUP1 057B 15 ISZERO 057C 61 PUSH2 0x0584 057F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0579 stack[0] = msg.value } // Block ends with conditional jump to 0x0584, if !msg.value label_0580: // Incoming jump from 0x057F, if not !msg.value // Inputs[1] { @0583 memory[0x00:0x00] } 0580 60 PUSH1 0x00 0582 80 DUP1 0583 FD *REVERT // Stack delta = +0 // Outputs[1] { @0583 revert(memory[0x00:0x00]); } // Block terminates label_0584: // Incoming jump from 0x057F, if !msg.value // Inputs[1] { @058C msg.data.length } 0584 5B JUMPDEST 0585 50 POP 0586 61 PUSH2 0x0281 0589 61 PUSH2 0x0593 058C 36 CALLDATASIZE 058D 60 PUSH1 0x04 058F 61 PUSH2 0x1b5c 0592 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0586 stack[-1] = 0x0281 // @0589 stack[0] = 0x0593 // @058C stack[1] = msg.data.length // @058D stack[2] = 0x04 // } // Block ends with call to 0x1b5c, returns to 0x0593 label_0593: // Incoming return from call to 0x1B5C at 0x0592 0593 5B JUMPDEST 0594 61 PUSH2 0x0fc7 0597 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fc7 label_0598: // Incoming jump from 0x01F1 // Inputs[1] { @05A4 stack[-1] } 0598 5B JUMPDEST 0599 60 PUSH1 0x00 059B 60 PUSH1 0x01 059D 60 PUSH1 0x01 059F 60 PUSH1 0xe0 05A1 1B SHL 05A2 03 SUB 05A3 19 NOT 05A4 82 DUP3 05A5 16 AND 05A6 63 PUSH4 0x80ac58cd 05AB 60 PUSH1 0xe0 05AD 1B SHL 05AE 14 EQ 05AF 80 DUP1 05B0 61 PUSH2 0x05c9 05B3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0599 stack[0] = 0x00 // @05AE stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x05c9, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_05B4: // Incoming jump from 0x05B3, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @05BE stack[-3] } 05B4 50 POP 05B5 60 PUSH1 0x01 05B7 60 PUSH1 0x01 05B9 60 PUSH1 0xe0 05BB 1B SHL 05BC 03 SUB 05BD 19 NOT 05BE 82 DUP3 05BF 16 AND 05C0 63 PUSH4 0x5b5e139f 05C5 60 PUSH1 0xe0 05C7 1B SHL 05C8 14 EQ 05C9 5B JUMPDEST 05CA 80 DUP1 05CB 61 PUSH2 0x05e4 05CE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @05C8 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x05e4, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_05CF: // Incoming jump from 0x05CE, if not stack[-1] // Incoming jump from 0x05CE, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @05D9 stack[-3] } 05CF 50 POP 05D0 60 PUSH1 0x01 05D2 60 PUSH1 0x01 05D4 60 PUSH1 0xe0 05D6 1B SHL 05D7 03 SUB 05D8 19 NOT 05D9 82 DUP3 05DA 16 AND 05DB 63 PUSH4 0x780e9d63 05E0 60 PUSH1 0xe0 05E2 1B SHL 05E3 14 EQ 05E4 5B JUMPDEST 05E5 80 DUP1 05E6 61 PUSH2 0x05ff 05E9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @05E3 stack[-1] = 0x780e9d63 << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x05ff, if 0x780e9d63 << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_05EA: // Incoming jump from 0x05E9, if not 0x780e9d63 << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x05E9, if not stack[-1] // Inputs[2] // { // @05FC stack[-3] // @0600 stack[-4] // } 05EA 50 POP 05EB 63 PUSH4 0x01ffc9a7 05F0 60 PUSH1 0xe0 05F2 1B SHL 05F3 60 PUSH1 0x01 05F5 60 PUSH1 0x01 05F7 60 PUSH1 0xe0 05F9 1B SHL 05FA 03 SUB 05FB 19 NOT 05FC 83 DUP4 05FD 16 AND 05FE 14 EQ 05FF 5B JUMPDEST 0600 92 SWAP3 0601 91 SWAP2 0602 50 POP 0603 50 POP 0604 56 *JUMP // Stack delta = -3 // Outputs[1] { @0600 stack[-4] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to stack[-4] label_0605: // Incoming call from 0x021B, returns to 0x021C // Inputs[1] { @060B storage[0x01] } 0605 5B JUMPDEST 0606 60 PUSH1 0x60 0608 60 PUSH1 0x01 060A 80 DUP1 060B 54 SLOAD 060C 61 PUSH2 0x0614 060F 90 SWAP1 0610 61 PUSH2 0x1c7b 0613 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0606 stack[0] = 0x60 // @0608 stack[1] = 0x01 // @060F stack[2] = 0x0614 // @060F stack[3] = storage[0x01] // } // Block ends with call to 0x1c7b, returns to 0x0614 label_0614: // Incoming return from call to 0x1C7B at 0x0613 // Incoming return from call to 0x1C7B at 0x15D9 // Incoming return from call to 0x1C7B at 0x0CC5 // Inputs[4] // { // @0615 stack[-1] // @0624 memory[0x40:0x60] // @062C stack[-2] // @0637 storage[stack[-2]] // } 0614 5B JUMPDEST 0615 80 DUP1 0616 60 PUSH1 0x1f 0618 01 ADD 0619 60 PUSH1 0x20 061B 80 DUP1 061C 91 SWAP2 061D 04 DIV 061E 02 MUL 061F 60 PUSH1 0x20 0621 01 ADD 0622 60 PUSH1 0x40 0624 51 MLOAD 0625 90 SWAP1 0626 81 DUP2 0627 01 ADD 0628 60 PUSH1 0x40 062A 52 MSTORE 062B 80 DUP1 062C 92 SWAP3 062D 91 SWAP2 062E 90 SWAP1 062F 81 DUP2 0630 81 DUP2 0631 52 MSTORE 0632 60 PUSH1 0x20 0634 01 ADD 0635 82 DUP3 0636 80 DUP1 0637 54 SLOAD 0638 61 PUSH2 0x0640 063B 90 SWAP1 063C 61 PUSH2 0x1c7b 063F 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @062A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @062C stack[-2] = memory[0x40:0x60] // @062D stack[-1] = stack[-2] // @062E stack[0] = stack[-1] // @0631 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0634 stack[1] = 0x20 + memory[0x40:0x60] // @0635 stack[2] = stack[-2] // @063B stack[4] = storage[stack[-2]] // @063B stack[3] = 0x0640 // } // Block ends with call to 0x1c7b, returns to 0x0640 label_0640: // Incoming return from call to 0x1C7B at 0x063F // Inputs[1] { @0641 stack[-1] } 0640 5B JUMPDEST 0641 80 DUP1 0642 15 ISZERO 0643 61 PUSH2 0x068d 0646 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x068d, if !stack[-1] label_0647: // Incoming jump from 0x0646, if not !stack[-1] // Inputs[1] { @0647 stack[-1] } 0647 80 DUP1 0648 60 PUSH1 0x1f 064A 10 LT 064B 61 PUSH2 0x0662 064E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0662, if 0x1f < stack[-1] label_064F: // Incoming jump from 0x064E, if not 0x1f < stack[-1] // Inputs[4] // { // @0653 stack[-2] // @0654 storage[stack[-2]] // @0657 stack[-3] // @0659 stack[-1] // } 064F 61 PUSH2 0x0100 0652 80 DUP1 0653 83 DUP4 0654 54 SLOAD 0655 04 DIV 0656 02 MUL 0657 83 DUP4 0658 52 MSTORE 0659 91 SWAP2 065A 60 PUSH1 0x20 065C 01 ADD 065D 91 SWAP2 065E 61 PUSH2 0x068d 0661 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0658 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @065D stack[-1] = stack[-1] // @065D stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x068d label_0662: // Incoming jump from 0x064E, if 0x1f < stack[-1] // Inputs[5] // { // @0663 stack[-3] // @0664 stack[-1] // @0666 stack[-2] // @066E memory[0x00:0x20] // @0672 storage[keccak256(memory[0x00:0x20])] // } 0662 5B JUMPDEST 0663 82 DUP3 0664 01 ADD 0665 91 SWAP2 0666 90 SWAP1 0667 60 PUSH1 0x00 0669 52 MSTORE 066A 60 PUSH1 0x20 066C 60 PUSH1 0x00 066E 20 SHA3 066F 90 SWAP1 0670 5B JUMPDEST 0671 81 DUP2 0672 54 SLOAD 0673 81 DUP2 0674 52 MSTORE 0675 90 SWAP1 0676 60 PUSH1 0x01 0678 01 ADD 0679 90 SWAP1 067A 60 PUSH1 0x20 067C 01 ADD 067D 80 DUP1 067E 83 DUP4 067F 11 GT 0680 61 PUSH2 0x0670 0683 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0665 stack[-3] = stack[-3] + stack[-1] // @0669 memory[0x00:0x20] = stack[-2] // @0674 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0679 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @067C stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0670, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0684: // Incoming jump from 0x0683, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0683, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0684 stack[-3] // @0685 stack[-1] // } 0684 82 DUP3 0685 90 SWAP1 0686 03 SUB 0687 60 PUSH1 0x1f 0689 16 AND 068A 82 DUP3 068B 01 ADD 068C 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @068C stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @068C stack[-1] = stack[-3] // } // Block continues label_068D: // Incoming jump from 0x0646, if !stack[-1] // Incoming jump from 0x0661 // Incoming jump from 0x068C // Inputs[3] // { // @0693 stack[-7] // @0693 stack[-6] // @0695 stack[-8] // } 068D 5B JUMPDEST 068E 50 POP 068F 50 POP 0690 50 POP 0691 50 POP 0692 50 POP 0693 90 SWAP1 0694 50 POP 0695 90 SWAP1 0696 56 *JUMP // Stack delta = -7 // Outputs[1] { @0695 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0697: // Incoming call from 0x10F1, returns to 0x10F2 // Incoming jump from 0x0248 // Inputs[2] // { // @069D stack[-1] // @06A0 storage[0x00] // } 0697 5B JUMPDEST 0698 60 PUSH1 0x00 069A 61 PUSH2 0x06a4 069D 82 DUP3 069E 60 PUSH1 0x00 06A0 54 SLOAD 06A1 11 GT 06A2 90 SWAP1 06A3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0698 stack[0] = 0x00 // @06A2 stack[1] = storage[0x00] > stack[-1] // } // Block ends with unconditional jump to 0x06a4 label_06A4: // Incoming jump from 0x06A3 // Inputs[1] { @06A8 stack[-1] } 06A4 5B JUMPDEST 06A5 61 PUSH2 0x070b 06A8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x070b, if stack[-1] label_06A9: // Incoming jump from 0x06A8, if not stack[-1] // Inputs[1] { @06AB memory[0x40:0x60] } 06A9 60 PUSH1 0x40 06AB 51 MLOAD 06AC 62 PUSH3 0x461bcd 06B0 60 PUSH1 0xe5 06B2 1B SHL 06B3 81 DUP2 06B4 52 MSTORE 06B5 60 PUSH1 0x20 06B7 60 PUSH1 0x04 06B9 82 DUP3 06BA 01 ADD 06BB 52 MSTORE 06BC 60 PUSH1 0x2d 06BE 60 PUSH1 0x24 06C0 82 DUP3 06C1 01 ADD 06C2 52 MSTORE 06C3 7F PUSH32 0x455243373231413a20617070726f76656420717565727920666f72206e6f6e65 06E4 60 PUSH1 0x44 06E6 82 DUP3 06E7 01 ADD 06E8 52 MSTORE 06E9 6C PUSH13 0x3c34b9ba32b73a103a37b5b2b7 06F7 60 PUSH1 0x99 06F9 1B SHL 06FA 60 PUSH1 0x64 06FC 82 DUP3 06FD 01 ADD 06FE 52 MSTORE 06FF 60 PUSH1 0x84 0701 01 ADD // Stack delta = +1 // Outputs[6] // { // @06B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @06BB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @06C2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2d // @06E8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a20617070726f76656420717565727920666f72206e6f6e65 // @06FE memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3c34b9ba32b73a103a37b5b2b7 << 0x99 // @0701 stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_0702: // Incoming jump from 0x09A3 // Incoming jump from 0x141D // Incoming jump from 0x175A // Incoming return from call to 0x1CB5 at 0x0EB9 // Incoming jump from 0x11EC // Incoming return from call to 0x1CEA at 0x18A8 // Incoming jump from 0x0BEF // Incoming jump from 0x08AC // Incoming return from call to 0x1CEA at 0x159C // Incoming return from call to 0x1CB5 at 0x0C74 // Incoming jump from 0x1178 // Incoming jump from 0x1250 // Incoming jump from 0x1055 // Incoming jump from 0x082D // Incoming jump from 0x0B2C // Incoming jump from 0x0E33 // Incoming jump from 0x0D1D // Incoming jump from 0x079F // Incoming return from call to 0x1CB5 at 0x0B6C // Incoming return from call to 0x1CB5 at 0x0FF0 // Incoming return from call to 0x1CB5 at 0x0A5B // Incoming jump from 0x0701 // Incoming return from call to 0x1CB5 at 0x0CA3 // Incoming jump from 0x17BB // Incoming return from call to 0x1CB5 at 0x0C3E // Incoming jump from 0x0F30 // Inputs[3] // { // @0705 memory[0x40:0x60] // @0707 stack[-1] // @070A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0702 5B JUMPDEST 0703 60 PUSH1 0x40 0705 51 MLOAD 0706 80 DUP1 0707 91 SWAP2 0708 03 SUB 0709 90 SWAP1 070A FD *REVERT // Stack delta = -1 // Outputs[1] { @070A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_070B: // Incoming jump from 0x06A8, if stack[-1] // Inputs[4] // { // @070F stack[-2] // @071A memory[0x00:0x40] // @071B storage[keccak256(memory[0x00:0x40])] // @0725 stack[-3] // } 070B 5B JUMPDEST 070C 50 POP 070D 60 PUSH1 0x00 070F 90 SWAP1 0710 81 DUP2 0711 52 MSTORE 0712 60 PUSH1 0x05 0714 60 PUSH1 0x20 0716 52 MSTORE 0717 60 PUSH1 0x40 0719 90 SWAP1 071A 20 SHA3 071B 54 SLOAD 071C 60 PUSH1 0x01 071E 60 PUSH1 0x01 0720 60 PUSH1 0xa0 0722 1B SHL 0723 03 SUB 0724 16 AND 0725 90 SWAP1 0726 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0711 memory[0x00:0x20] = stack[-2] // @0716 memory[0x20:0x40] = 0x05 // @0725 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0727: // Incoming jump from 0x0280 // Inputs[1] { @072D stack[-1] } 0727 5B JUMPDEST 0728 60 PUSH1 0x00 072A 61 PUSH2 0x0732 072D 82 DUP3 072E 61 PUSH2 0x0b31 0731 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0728 stack[0] = 0x00 // @072A stack[1] = 0x0732 // @072D stack[2] = stack[-1] // } // Block ends with call to 0x0b31, returns to 0x0732 label_0732: // Incoming return from call to 0x0B31 at 0x0731 // Inputs[3] // { // @0733 stack[-2] // @0733 stack[-1] // @073F stack[-4] // } 0732 5B JUMPDEST 0733 90 SWAP1 0734 50 POP 0735 80 DUP1 0736 60 PUSH1 0x01 0738 60 PUSH1 0x01 073A 60 PUSH1 0xa0 073C 1B SHL 073D 03 SUB 073E 16 AND 073F 83 DUP4 0740 60 PUSH1 0x01 0742 60 PUSH1 0x01 0744 60 PUSH1 0xa0 0746 1B SHL 0747 03 SUB 0748 16 AND 0749 03 SUB 074A 61 PUSH2 0x07a0 074D 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0733 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x07a0, if ((0x01 << 0xa0) - 0x01 & stack[-4]) - ((0x01 << 0xa0) - 0x01 & stack[-1]) label_074E: // Incoming jump from 0x074D, if not ((0x01 << 0xa0) - 0x01 & stack[-4]) - ((0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @0750 memory[0x40:0x60] } 074E 60 PUSH1 0x40 0750 51 MLOAD 0751 62 PUSH3 0x461bcd 0755 60 PUSH1 0xe5 0757 1B SHL 0758 81 DUP2 0759 52 MSTORE 075A 60 PUSH1 0x20 075C 60 PUSH1 0x04 075E 82 DUP3 075F 01 ADD 0760 52 MSTORE 0761 60 PUSH1 0x22 0763 60 PUSH1 0x24 0765 82 DUP3 0766 01 ADD 0767 52 MSTORE 0768 7F PUSH32 0x455243373231413a20617070726f76616c20746f2063757272656e74206f776e 0789 60 PUSH1 0x44 078B 82 DUP3 078C 01 ADD 078D 52 MSTORE 078E 61 PUSH2 0x32b9 0791 60 PUSH1 0xf1 0793 1B SHL 0794 60 PUSH1 0x64 0796 82 DUP3 0797 01 ADD 0798 52 MSTORE 0799 60 PUSH1 0x84 079B 01 ADD 079C 61 PUSH2 0x0702 079F 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0759 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0760 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0767 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @078D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a20617070726f76616c20746f2063757272656e74206f776e // @0798 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x32b9 << 0xf1 // @079B stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0702 label_07A0: // Incoming jump from 0x074D, if ((0x01 << 0xa0) - 0x01 & stack[-4]) - ((0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @07A1 msg.sender // @07AA stack[-1] // } 07A0 5B JUMPDEST 07A1 33 CALLER 07A2 60 PUSH1 0x01 07A4 60 PUSH1 0x01 07A6 60 PUSH1 0xa0 07A8 1B SHL 07A9 03 SUB 07AA 82 DUP3 07AB 16 AND 07AC 14 EQ 07AD 80 DUP1 07AE 61 PUSH2 0x07bc 07B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07AC stack[0] = stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender } // Block ends with conditional jump to 0x07bc, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_07B2: // Incoming jump from 0x07B1, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @07B6 stack[-2] // @07B7 msg.sender // } 07B2 50 POP 07B3 61 PUSH2 0x07bc 07B6 81 DUP2 07B7 33 CALLER 07B8 61 PUSH2 0x0535 07BB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @07B3 stack[-1] = 0x07bc // @07B6 stack[0] = stack[-2] // @07B7 stack[1] = msg.sender // } // Block ends with call to 0x0535, returns to 0x07BC label_07BC: // Incoming return from call to 0x0535 at 0x07BB // Incoming jump from 0x07B1, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @07C0 stack[-1] } 07BC 5B JUMPDEST 07BD 61 PUSH2 0x082e 07C0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x082e, if stack[-1] label_07C1: // Incoming jump from 0x07C0, if not stack[-1] // Inputs[1] { @07C3 memory[0x40:0x60] } 07C1 60 PUSH1 0x40 07C3 51 MLOAD 07C4 62 PUSH3 0x461bcd 07C8 60 PUSH1 0xe5 07CA 1B SHL 07CB 81 DUP2 07CC 52 MSTORE 07CD 60 PUSH1 0x20 07CF 60 PUSH1 0x04 07D1 82 DUP3 07D2 01 ADD 07D3 52 MSTORE 07D4 60 PUSH1 0x39 07D6 60 PUSH1 0x24 07D8 82 DUP3 07D9 01 ADD 07DA 52 MSTORE 07DB 7F PUSH32 0x455243373231413a20617070726f76652063616c6c6572206973206e6f74206f 07FC 60 PUSH1 0x44 07FE 82 DUP3 07FF 01 ADD 0800 52 MSTORE 0801 7F PUSH32 0x776e6572206e6f7220617070726f76656420666f7220616c6c00000000000000 0822 60 PUSH1 0x64 0824 82 DUP3 0825 01 ADD 0826 52 MSTORE 0827 60 PUSH1 0x84 0829 01 ADD 082A 61 PUSH2 0x0702 082D 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @07CC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @07D3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @07DA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x39 // @0800 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a20617070726f76652063616c6c6572206973206e6f74206f // @0826 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x776e6572206e6f7220617070726f76656420666f7220616c6c00000000000000 // @0829 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0702 label_082E: // Incoming jump from 0x07C0, if stack[-1] // Inputs[3] // { // @0832 stack[-3] // @0833 stack[-2] // @0834 stack[-1] // } 082E 5B JUMPDEST 082F 61 PUSH2 0x0839 0832 83 DUP4 0833 83 DUP4 0834 83 DUP4 0835 61 PUSH2 0x105f 0838 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @082F stack[0] = 0x0839 // @0832 stack[1] = stack[-3] // @0833 stack[2] = stack[-2] // @0834 stack[3] = stack[-1] // } // Block ends with call to 0x105f, returns to 0x0839 label_0839: // Incoming return from call to 0x175B at 0x1709 // Incoming return from call to 0x105F at 0x0838 // Incoming return from call to 0x16DB at 0x0EDE // Inputs[1] { @083D stack[-4] } 0839 5B JUMPDEST 083A 50 POP 083B 50 POP 083C 50 POP 083D 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_083E: // Incoming jump from 0x02C1 // Inputs[3] // { // @0842 stack[-3] // @0843 stack[-2] // @0844 stack[-1] // } 083E 5B JUMPDEST 083F 61 PUSH2 0x0839 0842 83 DUP4 0843 83 DUP4 0844 83 DUP4 0845 61 PUSH2 0x10bb 0848 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @083F stack[0] = 0x0839 // @0842 stack[1] = stack[-3] // @0843 stack[2] = stack[-2] // @0844 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x10bb label_0849: // Incoming jump from 0x02F7 // Inputs[1] { @084F stack[-2] } 0849 5B JUMPDEST 084A 60 PUSH1 0x00 084C 61 PUSH2 0x0854 084F 83 DUP4 0850 61 PUSH2 0x0b84 0853 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @084A stack[0] = 0x00 // @084C stack[1] = 0x0854 // @084F stack[2] = stack[-2] // } // Block ends with call to 0x0b84, returns to 0x0854 label_0854: // Incoming return from call to 0x0B84 at 0x0853 // Inputs[2] // { // @0855 stack[-3] // @0856 stack[-1] // } 0854 5B JUMPDEST 0855 82 DUP3 0856 10 LT 0857 61 PUSH2 0x08ad 085A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x08ad, if stack[-3] < stack[-1] label_085B: // Incoming jump from 0x085A, if not stack[-3] < stack[-1] // Inputs[1] { @085D memory[0x40:0x60] } 085B 60 PUSH1 0x40 085D 51 MLOAD 085E 62 PUSH3 0x461bcd 0862 60 PUSH1 0xe5 0864 1B SHL 0865 81 DUP2 0866 52 MSTORE 0867 60 PUSH1 0x20 0869 60 PUSH1 0x04 086B 82 DUP3 086C 01 ADD 086D 52 MSTORE 086E 60 PUSH1 0x22 0870 60 PUSH1 0x24 0872 82 DUP3 0873 01 ADD 0874 52 MSTORE 0875 7F PUSH32 0x455243373231413a206f776e657220696e646578206f7574206f6620626f756e 0896 60 PUSH1 0x44 0898 82 DUP3 0899 01 ADD 089A 52 MSTORE 089B 61 PUSH2 0x6473 089E 60 PUSH1 0xf0 08A0 1B SHL 08A1 60 PUSH1 0x64 08A3 82 DUP3 08A4 01 ADD 08A5 52 MSTORE 08A6 60 PUSH1 0x84 08A8 01 ADD 08A9 61 PUSH2 0x0702 08AC 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0866 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @086D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0874 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @089A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a206f776e657220696e646578206f7574206f6620626f756e // @08A5 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6473 << 0xf0 // @08A8 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0702 label_08AD: // Incoming jump from 0x085A, if stack[-3] < stack[-1] // Inputs[1] { @08B1 storage[0x00] } 08AD 5B JUMPDEST 08AE 60 PUSH1 0x00 08B0 80 DUP1 08B1 54 SLOAD 08B2 90 SWAP1 08B3 80 DUP1 08B4 80 DUP1 08B5 5B JUMPDEST 08B6 83 DUP4 08B7 81 DUP2 08B8 10 LT 08B9 15 ISZERO 08BA 61 PUSH2 0x0944 08BD 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @08B2 stack[0] = storage[0x00] // @08B2 stack[1] = 0x00 // @08B3 stack[2] = 0x00 // @08B4 stack[3] = 0x00 // } // Block ends with conditional jump to 0x0944, if !(0x00 < storage[0x00]) label_08BE: // Incoming jump from 0x08BD, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x08BD, if not !(0x00 < storage[0x00]) // Inputs[4] // { // @08C0 stack[-1] // @08CF memory[0x00:0x40] // @08D1 memory[0x40:0x60] // @08D8 storage[keccak256(memory[0x00:0x40])] // } 08BE 60 PUSH1 0x00 08C0 81 DUP2 08C1 81 DUP2 08C2 52 MSTORE 08C3 60 PUSH1 0x03 08C5 60 PUSH1 0x20 08C7 90 SWAP1 08C8 81 DUP2 08C9 52 MSTORE 08CA 60 PUSH1 0x40 08CC 91 SWAP2 08CD 82 DUP3 08CE 90 SWAP1 08CF 20 SHA3 08D0 82 DUP3 08D1 51 MLOAD 08D2 80 DUP1 08D3 84 DUP5 08D4 01 ADD 08D5 90 SWAP1 08D6 93 SWAP4 08D7 52 MSTORE 08D8 54 SLOAD 08D9 60 PUSH1 0x01 08DB 60 PUSH1 0x01 08DD 60 PUSH1 0xa0 08DF 1B SHL 08E0 03 SUB 08E1 81 DUP2 08E2 16 AND 08E3 80 DUP1 08E4 84 DUP5 08E5 52 MSTORE 08E6 60 PUSH1 0x01 08E8 60 PUSH1 0xa0 08EA 1B SHL 08EB 90 SWAP1 08EC 91 SWAP2 08ED 04 DIV 08EE 67 PUSH8 0xffffffffffffffff 08F7 16 AND 08F8 91 SWAP2 08F9 83 DUP4 08FA 01 ADD 08FB 91 SWAP2 08FC 90 SWAP1 08FD 91 SWAP2 08FE 52 MSTORE 08FF 15 ISZERO 0900 61 PUSH2 0x0908 0903 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @08C2 memory[0x00:0x20] = stack[-1] // @08C9 memory[0x20:0x40] = 0x03 // @08D6 stack[0] = memory[0x40:0x60] // @08D7 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @08E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @08FE memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // } // Block ends with conditional jump to 0x0908, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_0904: // Incoming jump from 0x0903, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[4] // { // @0904 stack[-1] // @0905 memory[stack[-1]:stack[-1] + 0x20] // @0906 stack[-3] // @0909 stack[-8] // } 0904 80 DUP1 0905 51 MLOAD 0906 92 SWAP3 0907 50 POP 0908 5B JUMPDEST 0909 87 DUP8 090A 60 PUSH1 0x01 090C 60 PUSH1 0x01 090E 60 PUSH1 0xa0 0910 1B SHL 0911 03 SUB 0912 16 AND 0913 83 DUP4 0914 60 PUSH1 0x01 0916 60 PUSH1 0x01 0918 60 PUSH1 0xa0 091A 1B SHL 091B 03 SUB 091C 16 AND 091D 03 SUB 091E 61 PUSH2 0x093b 0921 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0906 stack[-3] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x093b, if ((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) - ((0x01 << 0xa0) - 0x01 & stack[-8]) label_0922: // Incoming jump from 0x0921, if not ((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) - ((0x01 << 0xa0) - 0x01 & stack[-8]) // Incoming jump from 0x0921, if not ((0x01 << 0xa0) - 0x01 & stack[-3]) - ((0x01 << 0xa0) - 0x01 & stack[-8]) // Inputs[2] // { // @0922 stack[-7] // @0923 stack[-4] // } 0922 86 DUP7 0923 84 DUP5 0924 03 SUB 0925 61 PUSH2 0x0934 0928 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0934, if stack[-4] - stack[-7] label_0929: // Incoming jump from 0x0928, if not stack[-4] - stack[-7] // Inputs[3] // { // @092A stack[-6] // @092A stack[-2] // @092F stack[-5] // } 0929 50 POP 092A 93 SWAP4 092B 50 POP 092C 61 PUSH2 0x05ff 092F 92 SWAP3 0930 50 POP 0931 50 POP 0932 50 POP 0933 56 *JUMP // Stack delta = -5 // Outputs[1] { @092A stack[-6] = stack[-2] } // Block ends with unconditional jump to 0x05ff label_0934: // Incoming jump from 0x0928, if stack[-4] - stack[-7] // Inputs[2] // { // @0937 stack[-1] // @0938 stack[-4] // } 0934 5B JUMPDEST 0935 60 PUSH1 0x01 0937 90 SWAP1 0938 93 SWAP4 0939 01 ADD 093A 92 SWAP3 // Stack delta = +0 // Outputs[2] // { // @093A stack[-4] = stack[-4] + 0x01 // @093A stack[-1] = stack[-1] // } // Block continues label_093B: // Incoming jump from 0x0921, if ((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) - ((0x01 << 0xa0) - 0x01 & stack[-8]) // Incoming jump from 0x093A // Incoming jump from 0x0921, if ((0x01 << 0xa0) - 0x01 & stack[-3]) - ((0x01 << 0xa0) - 0x01 & stack[-8]) // Inputs[1] { @093F stack[-2] } 093B 5B JUMPDEST 093C 50 POP 093D 60 PUSH1 0x01 093F 01 ADD 0940 61 PUSH2 0x08b5 0943 56 *JUMP // Stack delta = -1 // Outputs[1] { @093F stack[-2] = 0x01 + stack[-2] } // Block ends with unconditional jump to 0x08b5 label_0944: // Incoming jump from 0x08BD, if !(stack[-1] < stack[-4]) // Incoming jump from 0x08BD, if !(0x00 < storage[0x00]) // Inputs[1] { @0948 memory[0x40:0x60] } 0944 5B JUMPDEST 0945 50 POP 0946 60 PUSH1 0x40 0948 51 MLOAD 0949 62 PUSH3 0x461bcd 094D 60 PUSH1 0xe5 094F 1B SHL 0950 81 DUP2 0951 52 MSTORE 0952 60 PUSH1 0x20 0954 60 PUSH1 0x04 0956 82 DUP3 0957 01 ADD 0958 52 MSTORE 0959 60 PUSH1 0x2e 095B 60 PUSH1 0x24 095D 82 DUP3 095E 01 ADD 095F 52 MSTORE 0960 7F PUSH32 0x455243373231413a20756e61626c6520746f2067657420746f6b656e206f6620 0981 60 PUSH1 0x44 0983 82 DUP3 0984 01 ADD 0985 52 MSTORE 0986 6D PUSH14 0x0deeedccae440c4f240d2dcc8caf 0995 60 PUSH1 0x93 0997 1B SHL 0998 60 PUSH1 0x64 099A 82 DUP3 099B 01 ADD 099C 52 MSTORE 099D 60 PUSH1 0x84 099F 01 ADD 09A0 61 PUSH2 0x0702 09A3 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @0951 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0958 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @095F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2e // @0985 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a20756e61626c6520746f2067657420746f6b656e206f6620 // @099C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x0deeedccae440c4f240d2dcc8caf << 0x93 // @099F stack[-1] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0702 label_09A4: // Incoming call from 0x030C, returns to 0x021C // Inputs[1] { @09A8 storage[0x09] } 09A4 5B JUMPDEST 09A5 60 PUSH1 0x09 09A7 80 DUP1 09A8 54 SLOAD 09A9 61 PUSH2 0x09b1 09AC 90 SWAP1 09AD 61 PUSH2 0x1c7b 09B0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09A5 stack[0] = 0x09 // @09AC stack[1] = 0x09b1 // @09AC stack[2] = storage[0x09] // } // Block ends with call to 0x1c7b, returns to 0x09B1 label_09B1: // Incoming return from call to 0x1C7B at 0x09B0 // Inputs[4] // { // @09B2 stack[-1] // @09C1 memory[0x40:0x60] // @09C9 stack[-2] // @09D4 storage[stack[-2]] // } 09B1 5B JUMPDEST 09B2 80 DUP1 09B3 60 PUSH1 0x1f 09B5 01 ADD 09B6 60 PUSH1 0x20 09B8 80 DUP1 09B9 91 SWAP2 09BA 04 DIV 09BB 02 MUL 09BC 60 PUSH1 0x20 09BE 01 ADD 09BF 60 PUSH1 0x40 09C1 51 MLOAD 09C2 90 SWAP1 09C3 81 DUP2 09C4 01 ADD 09C5 60 PUSH1 0x40 09C7 52 MSTORE 09C8 80 DUP1 09C9 92 SWAP3 09CA 91 SWAP2 09CB 90 SWAP1 09CC 81 DUP2 09CD 81 DUP2 09CE 52 MSTORE 09CF 60 PUSH1 0x20 09D1 01 ADD 09D2 82 DUP3 09D3 80 DUP1 09D4 54 SLOAD 09D5 61 PUSH2 0x09dd 09D8 90 SWAP1 09D9 61 PUSH2 0x1c7b 09DC 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @09C7 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @09C9 stack[-2] = memory[0x40:0x60] // @09CA stack[-1] = stack[-2] // @09CB stack[0] = stack[-1] // @09CE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @09D1 stack[1] = 0x20 + memory[0x40:0x60] // @09D2 stack[2] = stack[-2] // @09D8 stack[4] = storage[stack[-2]] // @09D8 stack[3] = 0x09dd // } // Block ends with call to 0x1c7b, returns to 0x09DD label_09DD: // Incoming return from call to 0x1C7B at 0x09DC // Inputs[1] { @09DE stack[-1] } 09DD 5B JUMPDEST 09DE 80 DUP1 09DF 15 ISZERO 09E0 61 PUSH2 0x0a2a 09E3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a2a, if !stack[-1] label_09E4: // Incoming jump from 0x09E3, if not !stack[-1] // Inputs[1] { @09E4 stack[-1] } 09E4 80 DUP1 09E5 60 PUSH1 0x1f 09E7 10 LT 09E8 61 PUSH2 0x09ff 09EB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09ff, if 0x1f < stack[-1] label_09EC: // Incoming jump from 0x09EB, if not 0x1f < stack[-1] // Inputs[4] // { // @09F0 stack[-2] // @09F1 storage[stack[-2]] // @09F4 stack[-3] // @09F6 stack[-1] // } 09EC 61 PUSH2 0x0100 09EF 80 DUP1 09F0 83 DUP4 09F1 54 SLOAD 09F2 04 DIV 09F3 02 MUL 09F4 83 DUP4 09F5 52 MSTORE 09F6 91 SWAP2 09F7 60 PUSH1 0x20 09F9 01 ADD 09FA 91 SWAP2 09FB 61 PUSH2 0x0a2a 09FE 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @09F5 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @09FA stack[-1] = stack[-1] // @09FA stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0a2a label_09FF: // Incoming jump from 0x09EB, if 0x1f < stack[-1] // Inputs[5] // { // @0A00 stack[-3] // @0A01 stack[-1] // @0A03 stack[-2] // @0A0B memory[0x00:0x20] // @0A0F storage[keccak256(memory[0x00:0x20])] // } 09FF 5B JUMPDEST 0A00 82 DUP3 0A01 01 ADD 0A02 91 SWAP2 0A03 90 SWAP1 0A04 60 PUSH1 0x00 0A06 52 MSTORE 0A07 60 PUSH1 0x20 0A09 60 PUSH1 0x00 0A0B 20 SHA3 0A0C 90 SWAP1 0A0D 5B JUMPDEST 0A0E 81 DUP2 0A0F 54 SLOAD 0A10 81 DUP2 0A11 52 MSTORE 0A12 90 SWAP1 0A13 60 PUSH1 0x01 0A15 01 ADD 0A16 90 SWAP1 0A17 60 PUSH1 0x20 0A19 01 ADD 0A1A 80 DUP1 0A1B 83 DUP4 0A1C 11 GT 0A1D 61 PUSH2 0x0a0d 0A20 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0A02 stack[-3] = stack[-3] + stack[-1] // @0A06 memory[0x00:0x20] = stack[-2] // @0A11 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0A16 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0A19 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0a0d, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0A21: // Incoming jump from 0x0A20, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0A20, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0A21 stack[-3] // @0A22 stack[-1] // } 0A21 82 DUP3 0A22 90 SWAP1 0A23 03 SUB 0A24 60 PUSH1 0x1f 0A26 16 AND 0A27 82 DUP3 0A28 01 ADD 0A29 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0A29 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0A29 stack[-1] = stack[-3] // } // Block continues label_0A2A: // Incoming jump from 0x0A29 // Incoming jump from 0x09FE // Incoming jump from 0x09E3, if !stack[-1] // Inputs[1] { @0A30 stack[-7] } 0A2A 5B JUMPDEST 0A2B 50 POP 0A2C 50 POP 0A2D 50 POP 0A2E 50 POP 0A2F 50 POP 0A30 81 DUP2 0A31 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0A32: // Incoming call from 0x0314, returns to 0x0281 // Inputs[2] // { // @0A35 storage[0x07] // @0A3F msg.sender // } 0A32 5B JUMPDEST 0A33 60 PUSH1 0x07 0A35 54 SLOAD 0A36 60 PUSH1 0x01 0A38 60 PUSH1 0x01 0A3A 60 PUSH1 0xa0 0A3C 1B SHL 0A3D 03 SUB 0A3E 16 AND 0A3F 33 CALLER 0A40 14 EQ 0A41 61 PUSH2 0x0a5c 0A44 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a5c, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_0A45: // Incoming jump from 0x0A44, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[1] { @0A47 memory[0x40:0x60] } 0A45 60 PUSH1 0x40 0A47 51 MLOAD 0A48 62 PUSH3 0x461bcd 0A4C 60 PUSH1 0xe5 0A4E 1B SHL 0A4F 81 DUP2 0A50 52 MSTORE 0A51 60 PUSH1 0x04 0A53 01 ADD 0A54 61 PUSH2 0x0702 0A57 90 SWAP1 0A58 61 PUSH2 0x1cb5 0A5B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A50 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A57 stack[0] = 0x0702 // @0A57 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1cb5, returns to 0x0702 label_0A5C: // Incoming jump from 0x0A44, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[8] // { // @0A5F memory[0x40:0x60] // @0A63 msg.sender // @0A65 address(this).balance // @0A65 address(this) // @0A6D msg.gas // @0A6E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0A6E address(msg.sender).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0A73 returndata.length // } 0A5C 5B JUMPDEST 0A5D 60 PUSH1 0x40 0A5F 51 MLOAD 0A60 60 PUSH1 0x00 0A62 90 SWAP1 0A63 33 CALLER 0A64 90 SWAP1 0A65 47 SELFBALANCE 0A66 90 SWAP1 0A67 83 DUP4 0A68 81 DUP2 0A69 81 DUP2 0A6A 81 DUP2 0A6B 85 DUP6 0A6C 87 DUP8 0A6D 5A GAS 0A6E F1 CALL 0A6F 92 SWAP3 0A70 50 POP 0A71 50 POP 0A72 50 POP 0A73 3D RETURNDATASIZE 0A74 80 DUP1 0A75 60 PUSH1 0x00 0A77 81 DUP2 0A78 14 EQ 0A79 61 PUSH2 0x0a9e 0A7C 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @0A62 stack[0] = 0x00 // @0A6E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(msg.sender).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0A6F stack[1] = address(msg.sender).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0A73 stack[2] = returndata.length // @0A74 stack[3] = returndata.length // } // Block ends with conditional jump to 0x0a9e, if returndata.length == 0x00 label_0A7D: // Incoming jump from 0x0A7C, if not returndata.length == 0x00 // Inputs[6] // { // @0A7F memory[0x40:0x60] // @0A80 stack[-2] // @0A87 returndata.length // @0A8F returndata.length // @0A92 returndata.length // @0A99 returndata[0x00:0x00 + returndata.length] // } 0A7D 60 PUSH1 0x40 0A7F 51 MLOAD 0A80 91 SWAP2 0A81 50 POP 0A82 60 PUSH1 0x1f 0A84 19 NOT 0A85 60 PUSH1 0x3f 0A87 3D RETURNDATASIZE 0A88 01 ADD 0A89 16 AND 0A8A 82 DUP3 0A8B 01 ADD 0A8C 60 PUSH1 0x40 0A8E 52 MSTORE 0A8F 3D RETURNDATASIZE 0A90 82 DUP3 0A91 52 MSTORE 0A92 3D RETURNDATASIZE 0A93 60 PUSH1 0x00 0A95 60 PUSH1 0x20 0A97 84 DUP5 0A98 01 ADD 0A99 3E RETURNDATACOPY 0A9A 61 PUSH2 0x0aa3 0A9D 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0A80 stack[-2] = memory[0x40:0x60] // @0A8E memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0A91 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0A99 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0aa3 label_0A9E: // Incoming jump from 0x0A7C, if returndata.length == 0x00 // Inputs[3] // { // @0AA1 stack[-2] // @0AA6 stack[-3] // @0AA6 stack[-4] // } 0A9E 5B JUMPDEST 0A9F 60 PUSH1 0x60 0AA1 91 SWAP2 0AA2 50 POP 0AA3 5B JUMPDEST 0AA4 50 POP 0AA5 50 POP 0AA6 90 SWAP1 0AA7 50 POP 0AA8 80 DUP1 0AA9 61 PUSH2 0x0ab1 0AAC 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0AA6 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x0ab1, if stack[-3] label_0AAD: // Incoming jump from 0x0AAC, if not stack[-3] // Incoming jump from 0x0AAC, if not stack[-3] // Inputs[1] { @0AB0 memory[0x00:0x00] } 0AAD 60 PUSH1 0x00 0AAF 80 DUP1 0AB0 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AB0 revert(memory[0x00:0x00]); } // Block terminates label_0AB1: // Incoming jump from 0x0AAC, if stack[-3] // Incoming jump from 0x0AAC, if stack[-3] // Incoming return from call to 0x1477 at 0x105E // Incoming jump from 0x195F, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0AB3 stack[-2] } 0AB1 5B JUMPDEST 0AB2 50 POP 0AB3 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0AB4: // Incoming jump from 0x0334 // Inputs[4] // { // @0AB8 stack[-3] // @0AB9 stack[-2] // @0ABA stack[-1] // @0ABD memory[0x40:0x60] // } 0AB4 5B JUMPDEST 0AB5 61 PUSH2 0x0839 0AB8 83 DUP4 0AB9 83 DUP4 0ABA 83 DUP4 0ABB 60 PUSH1 0x40 0ABD 51 MLOAD 0ABE 80 DUP1 0ABF 60 PUSH1 0x20 0AC1 01 ADD 0AC2 60 PUSH1 0x40 0AC4 52 MSTORE 0AC5 80 DUP1 0AC6 60 PUSH1 0x00 0AC8 81 DUP2 0AC9 52 MSTORE 0ACA 50 POP 0ACB 61 PUSH2 0x0d8a 0ACE 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0AB5 stack[0] = 0x0839 // @0AB8 stack[1] = stack[-3] // @0AB9 stack[2] = stack[-2] // @0ABA stack[3] = stack[-1] // @0ABD stack[4] = memory[0x40:0x60] // @0AC4 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0AC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x0d8a label_0ACF: // Incoming jump from 0x0354 // Inputs[2] // { // @0AD3 storage[0x00] // @0AD4 stack[-1] // } 0ACF 5B JUMPDEST 0AD0 60 PUSH1 0x00 0AD2 80 DUP1 0AD3 54 SLOAD 0AD4 82 DUP3 0AD5 10 LT 0AD6 61 PUSH2 0x0b2d 0AD9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0AD0 stack[0] = 0x00 } // Block ends with conditional jump to 0x0b2d, if stack[-1] < storage[0x00] label_0ADA: // Incoming jump from 0x0AD9, if not stack[-1] < storage[0x00] // Inputs[1] { @0ADC memory[0x40:0x60] } 0ADA 60 PUSH1 0x40 0ADC 51 MLOAD 0ADD 62 PUSH3 0x461bcd 0AE1 60 PUSH1 0xe5 0AE3 1B SHL 0AE4 81 DUP2 0AE5 52 MSTORE 0AE6 60 PUSH1 0x20 0AE8 60 PUSH1 0x04 0AEA 82 DUP3 0AEB 01 ADD 0AEC 52 MSTORE 0AED 60 PUSH1 0x23 0AEF 60 PUSH1 0x24 0AF1 82 DUP3 0AF2 01 ADD 0AF3 52 MSTORE 0AF4 7F PUSH32 0x455243373231413a20676c6f62616c20696e646578206f7574206f6620626f75 0B15 60 PUSH1 0x44 0B17 82 DUP3 0B18 01 ADD 0B19 52 MSTORE 0B1A 62 PUSH3 0x6e6473 0B1E 60 PUSH1 0xe8 0B20 1B SHL 0B21 60 PUSH1 0x64 0B23 82 DUP3 0B24 01 ADD 0B25 52 MSTORE 0B26 60 PUSH1 0x84 0B28 01 ADD 0B29 61 PUSH2 0x0702 0B2C 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0AE5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AEC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0AF3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x23 // @0B19 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a20676c6f62616c20696e646578206f7574206f6620626f75 // @0B25 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6e6473 << 0xe8 // @0B28 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0702 label_0B2D: // Incoming jump from 0x0AD9, if stack[-1] < storage[0x00] // Incoming call from 0x1942, returns to 0x0B2D, if !(stack[-4] > stack[-2]) // Incoming return from call to 0x0B2D at 0x1942 // Incoming jump from 0x1942, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @0B2F stack[-3] // @0B2F stack[-2] // } 0B2D 5B JUMPDEST 0B2E 50 POP 0B2F 90 SWAP1 0B30 56 *JUMP // Stack delta = -2 // Outputs[1] { @0B2F stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_0B31: // Incoming call from 0x0731, returns to 0x0732 // Incoming jump from 0x0374 // Inputs[1] { @0B37 stack[-1] } 0B31 5B JUMPDEST 0B32 60 PUSH1 0x00 0B34 61 PUSH2 0x0b3c 0B37 82 DUP3 0B38 61 PUSH2 0x13a0 0B3B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B32 stack[0] = 0x00 // @0B34 stack[1] = 0x0b3c // @0B37 stack[2] = stack[-1] // } // Block ends with call to 0x13a0, returns to 0x0B3C label_0B3C: // Incoming return from call to 0x13A0 at 0x0B3B // Inputs[4] // { // @0B3D memory[stack[-1]:stack[-1] + 0x20] // @0B3D stack[-1] // @0B3E stack[-4] // @0B3F stack[-3] // } 0B3C 5B JUMPDEST 0B3D 51 MLOAD 0B3E 92 SWAP3 0B3F 91 SWAP2 0B40 50 POP 0B41 50 POP 0B42 56 *JUMP // Stack delta = -3 // Outputs[1] { @0B3E stack[-4] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-4] label_0B43: // Incoming jump from 0x0394 // Inputs[2] // { // @0B46 storage[0x07] // @0B50 msg.sender // } 0B43 5B JUMPDEST 0B44 60 PUSH1 0x07 0B46 54 SLOAD 0B47 60 PUSH1 0x01 0B49 60 PUSH1 0x01 0B4B 60 PUSH1 0xa0 0B4D 1B SHL 0B4E 03 SUB 0B4F 16 AND 0B50 33 CALLER 0B51 14 EQ 0B52 61 PUSH2 0x0b6d 0B55 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b6d, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_0B56: // Incoming jump from 0x0B55, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[1] { @0B58 memory[0x40:0x60] } 0B56 60 PUSH1 0x40 0B58 51 MLOAD 0B59 62 PUSH3 0x461bcd 0B5D 60 PUSH1 0xe5 0B5F 1B SHL 0B60 81 DUP2 0B61 52 MSTORE 0B62 60 PUSH1 0x04 0B64 01 ADD 0B65 61 PUSH2 0x0702 0B68 90 SWAP1 0B69 61 PUSH2 0x1cb5 0B6C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B61 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B68 stack[0] = 0x0702 // @0B68 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1cb5, returns to 0x0702 label_0B6D: // Incoming jump from 0x0B55, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[2] // { // @0B6E stack[-1] // @0B6F memory[stack[-1]:stack[-1] + 0x20] // } 0B6D 5B JUMPDEST 0B6E 80 DUP1 0B6F 51 MLOAD 0B70 61 PUSH2 0x0b80 0B73 90 SWAP1 0B74 60 PUSH1 0x09 0B76 90 SWAP1 0B77 60 PUSH1 0x20 0B79 84 DUP5 0B7A 01 ADD 0B7B 90 SWAP1 0B7C 61 PUSH2 0x18be 0B7F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B73 stack[0] = 0x0b80 // @0B76 stack[1] = 0x09 // @0B7B stack[2] = stack[-1] + 0x20 // @0B7B stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x18be label_0B80: // Incoming return from call to 0x0839 at 0x1709 // Inputs[1] { @0B83 stack[-3] } 0B80 5B JUMPDEST 0B81 50 POP 0B82 50 POP 0B83 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0B84: // Incoming call from 0x0853, returns to 0x0854 // Incoming jump from 0x03B4 // Inputs[1] { @0B8F stack[-1] } 0B84 5B JUMPDEST 0B85 60 PUSH1 0x00 0B87 60 PUSH1 0x01 0B89 60 PUSH1 0x01 0B8B 60 PUSH1 0xa0 0B8D 1B SHL 0B8E 03 SUB 0B8F 82 DUP3 0B90 16 AND 0B91 61 PUSH2 0x0bf0 0B94 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B85 stack[0] = 0x00 } // Block ends with conditional jump to 0x0bf0, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0B95: // Incoming jump from 0x0B94, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0B97 memory[0x40:0x60] } 0B95 60 PUSH1 0x40 0B97 51 MLOAD 0B98 62 PUSH3 0x461bcd 0B9C 60 PUSH1 0xe5 0B9E 1B SHL 0B9F 81 DUP2 0BA0 52 MSTORE 0BA1 60 PUSH1 0x20 0BA3 60 PUSH1 0x04 0BA5 82 DUP3 0BA6 01 ADD 0BA7 52 MSTORE 0BA8 60 PUSH1 0x2b 0BAA 60 PUSH1 0x24 0BAC 82 DUP3 0BAD 01 ADD 0BAE 52 MSTORE 0BAF 7F PUSH32 0x455243373231413a2062616c616e636520717565727920666f7220746865207a 0BD0 60 PUSH1 0x44 0BD2 82 DUP3 0BD3 01 ADD 0BD4 52 MSTORE 0BD5 6A PUSH11 0x65726f2061646472657373 0BE1 60 PUSH1 0xa8 0BE3 1B SHL 0BE4 60 PUSH1 0x64 0BE6 82 DUP3 0BE7 01 ADD 0BE8 52 MSTORE 0BE9 60 PUSH1 0x84 0BEB 01 ADD 0BEC 61 PUSH2 0x0702 0BEF 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0BA0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BA7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BAE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @0BD4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a2062616c616e636520717565727920666f7220746865207a // @0BE8 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x65726f2061646472657373 << 0xa8 // @0BEB stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0702 label_0BF0: // Incoming jump from 0x0B94, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0BFA stack[-2] // @0C08 memory[0x00:0x40] // @0C09 storage[keccak256(memory[0x00:0x40])] // @0C13 stack[-3] // } 0BF0 5B JUMPDEST 0BF1 50 POP 0BF2 60 PUSH1 0x01 0BF4 60 PUSH1 0x01 0BF6 60 PUSH1 0xa0 0BF8 1B SHL 0BF9 03 SUB 0BFA 16 AND 0BFB 60 PUSH1 0x00 0BFD 90 SWAP1 0BFE 81 DUP2 0BFF 52 MSTORE 0C00 60 PUSH1 0x04 0C02 60 PUSH1 0x20 0C04 52 MSTORE 0C05 60 PUSH1 0x40 0C07 90 SWAP1 0C08 20 SHA3 0C09 54 SLOAD 0C0A 60 PUSH1 0x01 0C0C 60 PUSH1 0x01 0C0E 60 PUSH1 0x80 0C10 1B SHL 0C11 03 SUB 0C12 16 AND 0C13 90 SWAP1 0C14 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0BFF memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0C04 memory[0x20:0x40] = 0x04 // @0C13 stack[-3] = (0x01 << 0x80) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0C15: // Incoming call from 0x03C9, returns to 0x0281 // Inputs[2] // { // @0C18 storage[0x07] // @0C22 msg.sender // } 0C15 5B JUMPDEST 0C16 60 PUSH1 0x07 0C18 54 SLOAD 0C19 60 PUSH1 0x01 0C1B 60 PUSH1 0x01 0C1D 60 PUSH1 0xa0 0C1F 1B SHL 0C20 03 SUB 0C21 16 AND 0C22 33 CALLER 0C23 14 EQ 0C24 61 PUSH2 0x0c3f 0C27 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c3f, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_0C28: // Incoming jump from 0x0C27, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[1] { @0C2A memory[0x40:0x60] } 0C28 60 PUSH1 0x40 0C2A 51 MLOAD 0C2B 62 PUSH3 0x461bcd 0C2F 60 PUSH1 0xe5 0C31 1B SHL 0C32 81 DUP2 0C33 52 MSTORE 0C34 60 PUSH1 0x04 0C36 01 ADD 0C37 61 PUSH2 0x0702 0C3A 90 SWAP1 0C3B 61 PUSH2 0x1cb5 0C3E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C33 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C3A stack[0] = 0x0702 // @0C3A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1cb5, returns to 0x0702 label_0C3F: // Incoming jump from 0x0C27, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] 0C3F 5B JUMPDEST 0C40 61 PUSH2 0x0c49 0C43 60 PUSH1 0x00 0C45 61 PUSH2 0x1477 0C48 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C40 stack[0] = 0x0c49 // @0C43 stack[1] = 0x00 // } // Block ends with call to 0x1477, returns to 0x0C49 label_0C49: // Incoming return from call to 0x1477 at 0x0C48 // Inputs[1] { @0C4A stack[-1] } 0C49 5B JUMPDEST 0C4A 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0C4B: // Incoming jump from 0x03E9 // Inputs[2] // { // @0C4E storage[0x07] // @0C58 msg.sender // } 0C4B 5B JUMPDEST 0C4C 60 PUSH1 0x07 0C4E 54 SLOAD 0C4F 60 PUSH1 0x01 0C51 60 PUSH1 0x01 0C53 60 PUSH1 0xa0 0C55 1B SHL 0C56 03 SUB 0C57 16 AND 0C58 33 CALLER 0C59 14 EQ 0C5A 61 PUSH2 0x0c75 0C5D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c75, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_0C5E: // Incoming jump from 0x0C5D, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[1] { @0C60 memory[0x40:0x60] } 0C5E 60 PUSH1 0x40 0C60 51 MLOAD 0C61 62 PUSH3 0x461bcd 0C65 60 PUSH1 0xe5 0C67 1B SHL 0C68 81 DUP2 0C69 52 MSTORE 0C6A 60 PUSH1 0x04 0C6C 01 ADD 0C6D 61 PUSH2 0x0702 0C70 90 SWAP1 0C71 61 PUSH2 0x1cb5 0C74 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C69 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C70 stack[0] = 0x0702 // @0C70 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1cb5, returns to 0x0702 label_0C75: // Incoming jump from 0x0C5D, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[2] // { // @0C78 stack[-1] // @0C79 stack[-2] // } 0C75 5B JUMPDEST 0C76 60 PUSH1 0x0c 0C78 55 SSTORE 0C79 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C78 storage[0x0c] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0C7A: // Incoming jump from 0x0436 // Inputs[2] // { // @0C7D storage[0x07] // @0C87 msg.sender // } 0C7A 5B JUMPDEST 0C7B 60 PUSH1 0x07 0C7D 54 SLOAD 0C7E 60 PUSH1 0x01 0C80 60 PUSH1 0x01 0C82 60 PUSH1 0xa0 0C84 1B SHL 0C85 03 SUB 0C86 16 AND 0C87 33 CALLER 0C88 14 EQ 0C89 61 PUSH2 0x0ca4 0C8C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ca4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_0C8D: // Incoming jump from 0x0C8C, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[1] { @0C8F memory[0x40:0x60] } 0C8D 60 PUSH1 0x40 0C8F 51 MLOAD 0C90 62 PUSH3 0x461bcd 0C94 60 PUSH1 0xe5 0C96 1B SHL 0C97 81 DUP2 0C98 52 MSTORE 0C99 60 PUSH1 0x04 0C9B 01 ADD 0C9C 61 PUSH2 0x0702 0C9F 90 SWAP1 0CA0 61 PUSH2 0x1cb5 0CA3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C98 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C9F stack[0] = 0x0702 // @0C9F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1cb5, returns to 0x0702 label_0CA4: // Incoming jump from 0x0C8C, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[3] // { // @0CA8 storage[0x0a] // @0CAD stack[-1] // @0CB6 stack[-2] // } 0CA4 5B JUMPDEST 0CA5 60 PUSH1 0x0a 0CA7 80 DUP1 0CA8 54 SLOAD 0CA9 60 PUSH1 0xff 0CAB 19 NOT 0CAC 16 AND 0CAD 91 SWAP2 0CAE 15 ISZERO 0CAF 15 ISZERO 0CB0 91 SWAP2 0CB1 90 SWAP1 0CB2 91 SWAP2 0CB3 17 OR 0CB4 90 SWAP1 0CB5 55 SSTORE 0CB6 56 *JUMP // Stack delta = -2 // Outputs[1] { @0CB5 storage[0x0a] = !!stack[-1] | (~0xff & storage[0x0a]) } // Block ends with unconditional jump to stack[-2] label_0CB7: // Incoming call from 0x0469, returns to 0x021C // Inputs[1] { @0CBD storage[0x02] } 0CB7 5B JUMPDEST 0CB8 60 PUSH1 0x60 0CBA 60 PUSH1 0x02 0CBC 80 DUP1 0CBD 54 SLOAD 0CBE 61 PUSH2 0x0614 0CC1 90 SWAP1 0CC2 61 PUSH2 0x1c7b 0CC5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0CB8 stack[0] = 0x60 // @0CBA stack[1] = 0x02 // @0CC1 stack[2] = 0x0614 // @0CC1 stack[3] = storage[0x02] // } // Block ends with call to 0x1c7b, returns to 0x0614 label_0CC6: // Incoming jump from 0x04A3 // Inputs[2] // { // @0CC7 msg.sender // @0CD0 stack[-2] // } 0CC6 5B JUMPDEST 0CC7 33 CALLER 0CC8 60 PUSH1 0x01 0CCA 60 PUSH1 0x01 0CCC 60 PUSH1 0xa0 0CCE 1B SHL 0CCF 03 SUB 0CD0 83 DUP4 0CD1 16 AND 0CD2 03 SUB 0CD3 61 PUSH2 0x0d1e 0CD6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d1e, if (stack[-2] & (0x01 << 0xa0) - 0x01) - msg.sender label_0CD7: // Incoming jump from 0x0CD6, if not (stack[-2] & (0x01 << 0xa0) - 0x01) - msg.sender // Inputs[1] { @0CD9 memory[0x40:0x60] } 0CD7 60 PUSH1 0x40 0CD9 51 MLOAD 0CDA 62 PUSH3 0x461bcd 0CDE 60 PUSH1 0xe5 0CE0 1B SHL 0CE1 81 DUP2 0CE2 52 MSTORE 0CE3 60 PUSH1 0x20 0CE5 60 PUSH1 0x04 0CE7 82 DUP3 0CE8 01 ADD 0CE9 52 MSTORE 0CEA 60 PUSH1 0x1a 0CEC 60 PUSH1 0x24 0CEE 82 DUP3 0CEF 01 ADD 0CF0 52 MSTORE 0CF1 7F PUSH32 0x455243373231413a20617070726f766520746f2063616c6c6572000000000000 0D12 60 PUSH1 0x44 0D14 82 DUP3 0D15 01 ADD 0D16 52 MSTORE 0D17 60 PUSH1 0x64 0D19 01 ADD 0D1A 61 PUSH2 0x0702 0D1D 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0CE2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CE9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0CF0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1a // @0D16 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a20617070726f766520746f2063616c6c6572000000000000 // @0D19 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0702 label_0D1E: // Incoming jump from 0x0CD6, if (stack[-2] & (0x01 << 0xa0) - 0x01) - msg.sender // Inputs[10] // { // @0D1F msg.sender // @0D30 memory[0x00:0x40] // @0D39 stack[-2] // @0D44 memory[0x00:0x40] // @0D46 storage[keccak256(memory[0x00:0x40])] // @0D4B stack[-1] // @0D55 memory[0x40:0x60] // @0D81 memory[0x40:0x60] // @0D86 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0D89 stack[-3] // } 0D1E 5B JUMPDEST 0D1F 33 CALLER 0D20 60 PUSH1 0x00 0D22 81 DUP2 0D23 81 DUP2 0D24 52 MSTORE 0D25 60 PUSH1 0x06 0D27 60 PUSH1 0x20 0D29 90 SWAP1 0D2A 81 DUP2 0D2B 52 MSTORE 0D2C 60 PUSH1 0x40 0D2E 80 DUP1 0D2F 83 DUP4 0D30 20 SHA3 0D31 60 PUSH1 0x01 0D33 60 PUSH1 0x01 0D35 60 PUSH1 0xa0 0D37 1B SHL 0D38 03 SUB 0D39 87 DUP8 0D3A 16 AND 0D3B 80 DUP1 0D3C 85 DUP6 0D3D 52 MSTORE 0D3E 90 SWAP1 0D3F 83 DUP4 0D40 52 MSTORE 0D41 92 SWAP3 0D42 81 DUP2 0D43 90 SWAP1 0D44 20 SHA3 0D45 80 DUP1 0D46 54 SLOAD 0D47 60 PUSH1 0xff 0D49 19 NOT 0D4A 16 AND 0D4B 86 DUP7 0D4C 15 ISZERO 0D4D 15 ISZERO 0D4E 90 SWAP1 0D4F 81 DUP2 0D50 17 OR 0D51 90 SWAP1 0D52 91 SWAP2 0D53 55 SSTORE 0D54 90 SWAP1 0D55 51 MLOAD 0D56 90 SWAP1 0D57 81 DUP2 0D58 52 MSTORE 0D59 91 SWAP2 0D5A 92 SWAP3 0D5B 91 SWAP2 0D5C 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0D7D 91 SWAP2 0D7E 01 ADD 0D7F 60 PUSH1 0x40 0D81 51 MLOAD 0D82 80 DUP1 0D83 91 SWAP2 0D84 03 SUB 0D85 90 SWAP1 0D86 A3 LOG3 0D87 50 POP 0D88 50 POP 0D89 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0D24 memory[0x00:0x20] = msg.sender // @0D2B memory[0x20:0x40] = 0x06 // @0D3D memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0D40 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0D53 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0D58 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0D86 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_0D8A: // Incoming jump from 0x0ACE // Incoming jump from 0x04C3 // Inputs[3] // { // @0D8E stack[-4] // @0D8F stack[-3] // @0D90 stack[-2] // } 0D8A 5B JUMPDEST 0D8B 61 PUSH2 0x0d95 0D8E 84 DUP5 0D8F 84 DUP5 0D90 84 DUP5 0D91 61 PUSH2 0x10bb 0D94 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D8B stack[0] = 0x0d95 // @0D8E stack[1] = stack[-4] // @0D8F stack[2] = stack[-3] // @0D90 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x10bb 0D95 5B JUMPDEST 0D96 61 PUSH2 0x0da1 0D99 84 DUP5 0D9A 84 DUP5 0D9B 84 DUP5 0D9C 84 DUP5 0D9D 61 PUSH2 0x14c9 0DA0 56 *JUMP 0DA1 5B JUMPDEST 0DA2 61 PUSH2 0x0dbd 0DA5 57 *JUMPI 0DA6 60 PUSH1 0x40 0DA8 51 MLOAD 0DA9 62 PUSH3 0x461bcd 0DAD 60 PUSH1 0xe5 0DAF 1B SHL 0DB0 81 DUP2 0DB1 52 MSTORE 0DB2 60 PUSH1 0x04 0DB4 01 ADD 0DB5 61 PUSH2 0x0702 0DB8 90 SWAP1 0DB9 61 PUSH2 0x1cea 0DBC 56 *JUMP label_0DBD: // Incoming jump from 0x19A4, if !(stack[-1] > stack[-4]) // Inputs[1] { @0DC2 stack[-5] } 0DBD 5B JUMPDEST 0DBE 50 POP 0DBF 50 POP 0DC0 50 POP 0DC1 50 POP 0DC2 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0DC3: // Incoming jump from 0x04E3 // Inputs[2] // { // @0DC9 stack[-1] // @0DCC storage[0x00] // } 0DC3 5B JUMPDEST 0DC4 60 PUSH1 0x60 0DC6 61 PUSH2 0x0dd0 0DC9 82 DUP3 0DCA 60 PUSH1 0x00 0DCC 54 SLOAD 0DCD 11 GT 0DCE 90 SWAP1 0DCF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0DC4 stack[0] = 0x60 // @0DCE stack[1] = storage[0x00] > stack[-1] // } // Block ends with unconditional jump to 0x0dd0 label_0DD0: // Incoming jump from 0x0DCF // Inputs[1] { @0DD4 stack[-1] } 0DD0 5B JUMPDEST 0DD1 61 PUSH2 0x0e34 0DD4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e34, if stack[-1] label_0DD5: // Incoming jump from 0x0DD4, if not stack[-1] // Inputs[1] { @0DD7 memory[0x40:0x60] } 0DD5 60 PUSH1 0x40 0DD7 51 MLOAD 0DD8 62 PUSH3 0x461bcd 0DDC 60 PUSH1 0xe5 0DDE 1B SHL 0DDF 81 DUP2 0DE0 52 MSTORE 0DE1 60 PUSH1 0x20 0DE3 60 PUSH1 0x04 0DE5 82 DUP3 0DE6 01 ADD 0DE7 52 MSTORE 0DE8 60 PUSH1 0x2f 0DEA 60 PUSH1 0x24 0DEC 82 DUP3 0DED 01 ADD 0DEE 52 MSTORE 0DEF 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 0E10 60 PUSH1 0x44 0E12 82 DUP3 0E13 01 ADD 0E14 52 MSTORE 0E15 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 0E25 60 PUSH1 0x89 0E27 1B SHL 0E28 60 PUSH1 0x64 0E2A 82 DUP3 0E2B 01 ADD 0E2C 52 MSTORE 0E2D 60 PUSH1 0x84 0E2F 01 ADD 0E30 61 PUSH2 0x0702 0E33 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0DE0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DE7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DEE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @0E14 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @0E2C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3732bc34b9ba32b73a103a37b5b2b7 << 0x89 // @0E2F stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0702 label_0E34: // Incoming jump from 0x0DD4, if stack[-1] 0E34 5B JUMPDEST 0E35 60 PUSH1 0x00 0E37 61 PUSH2 0x0e3e 0E3A 61 PUSH2 0x15cb 0E3D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0E35 stack[0] = 0x00 // @0E37 stack[1] = 0x0e3e // } // Block ends with call to 0x15cb, returns to 0x0E3E label_0E3E: // Incoming return from call to 0x15CB at 0x0E3D // Inputs[3] // { // @0E3F stack[-1] // @0E3F stack[-2] // @0E42 memory[stack[-1]:stack[-1] + 0x20] // } 0E3E 5B JUMPDEST 0E3F 90 SWAP1 0E40 50 POP 0E41 80 DUP1 0E42 51 MLOAD 0E43 60 PUSH1 0x00 0E45 03 SUB 0E46 61 PUSH2 0x0e5e 0E49 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0E3F stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0e5e, if 0x00 - memory[stack[-1]:stack[-1] + 0x20] label_0E4A: // Incoming jump from 0x0E49, if not 0x00 - memory[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @0E4C memory[0x40:0x60] } 0E4A 60 PUSH1 0x40 0E4C 51 MLOAD 0E4D 80 DUP1 0E4E 60 PUSH1 0x20 0E50 01 ADD 0E51 60 PUSH1 0x40 0E53 52 MSTORE 0E54 80 DUP1 0E55 60 PUSH1 0x00 0E57 81 DUP2 0E58 52 MSTORE 0E59 50 POP 0E5A 61 PUSH2 0x0e89 0E5D 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0E4C stack[0] = memory[0x40:0x60] // @0E53 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0E58 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x0e89 label_0E5E: // Incoming jump from 0x0E49, if 0x00 - memory[stack[-1]:stack[-1] + 0x20] // Inputs[2] // { // @0E5F stack[-1] // @0E63 stack[-3] // } 0E5E 5B JUMPDEST 0E5F 80 DUP1 0E60 61 PUSH2 0x0e68 0E63 84 DUP5 0E64 61 PUSH2 0x15da 0E67 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E5F stack[0] = stack[-1] // @0E60 stack[1] = 0x0e68 // @0E63 stack[2] = stack[-3] // } // Block ends with call to 0x15da, returns to 0x0E68 label_0E68: // Incoming return from call to 0x15DA at 0x0E67 // Inputs[3] // { // @0E6B memory[0x40:0x60] // @0E72 stack[-2] // @0E73 stack[-1] // } 0E68 5B JUMPDEST 0E69 60 PUSH1 0x40 0E6B 51 MLOAD 0E6C 60 PUSH1 0x20 0E6E 01 ADD 0E6F 61 PUSH2 0x0e79 0E72 92 SWAP3 0E73 91 SWAP2 0E74 90 SWAP1 0E75 61 PUSH2 0x1d3d 0E78 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0E72 stack[-2] = 0x0e79 // @0E73 stack[-1] = stack[-2] // @0E74 stack[1] = 0x20 + memory[0x40:0x60] // @0E74 stack[0] = stack[-1] // } // Block ends with call to 0x1d3d, returns to 0x0E79 label_0E79: // Incoming return from call to 0x1D3D at 0x0E78 // Inputs[2] // { // @0E7C memory[0x40:0x60] // @0E80 stack[-1] // } 0E79 5B JUMPDEST 0E7A 60 PUSH1 0x40 0E7C 51 MLOAD 0E7D 60 PUSH1 0x20 0E7F 81 DUP2 0E80 83 DUP4 0E81 03 SUB 0E82 03 SUB 0E83 81 DUP2 0E84 52 MSTORE 0E85 90 SWAP1 0E86 60 PUSH1 0x40 0E88 52 MSTORE // Stack delta = +0 // Outputs[3] // { // @0E84 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @0E85 stack[-1] = memory[0x40:0x60] // @0E88 memory[0x40:0x60] = stack[-1] // } // Block continues label_0E89: // Incoming return from call to 0x194E at 0x1980 // Incoming return from call to 0x194E at 0x1DF3 // Incoming jump from 0x0E5D // Incoming return from call to 0x1B77 at 0x1BA1 // Incoming jump from 0x0E88 // Incoming return from call to 0x1A05 at 0x1B76 // Incoming return from call to 0x19AD at 0x19EB // Inputs[3] // { // @0E8A stack[-1] // @0E8A stack[-5] // @0E8B stack[-4] // } 0E89 5B JUMPDEST 0E8A 93 SWAP4 0E8B 92 SWAP3 0E8C 50 POP 0E8D 50 POP 0E8E 50 POP 0E8F 56 *JUMP // Stack delta = -4 // Outputs[1] { @0E8A stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0E90: // Incoming jump from 0x0519 // Inputs[2] // { // @0E93 storage[0x07] // @0E9D msg.sender // } 0E90 5B JUMPDEST 0E91 60 PUSH1 0x07 0E93 54 SLOAD 0E94 60 PUSH1 0x01 0E96 60 PUSH1 0x01 0E98 60 PUSH1 0xa0 0E9A 1B SHL 0E9B 03 SUB 0E9C 16 AND 0E9D 33 CALLER 0E9E 14 EQ 0E9F 61 PUSH2 0x0eba 0EA2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0eba, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_0EA3: // Incoming jump from 0x0EA2, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[1] { @0EA5 memory[0x40:0x60] } 0EA3 60 PUSH1 0x40 0EA5 51 MLOAD 0EA6 62 PUSH3 0x461bcd 0EAA 60 PUSH1 0xe5 0EAC 1B SHL 0EAD 81 DUP2 0EAE 52 MSTORE 0EAF 60 PUSH1 0x04 0EB1 01 ADD 0EB2 61 PUSH2 0x0702 0EB5 90 SWAP1 0EB6 61 PUSH2 0x1cb5 0EB9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0EAE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EB5 stack[0] = 0x0702 // @0EB5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1cb5, returns to 0x0702 label_0EBA: // Incoming jump from 0x0EA2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[3] // { // @0EBD storage[0x00] // @0EC0 storage[0x0b] // @0EC4 stack[-1] // } 0EBA 5B JUMPDEST 0EBB 60 PUSH1 0x00 0EBD 54 SLOAD 0EBE 60 PUSH1 0x0b 0EC0 54 SLOAD 0EC1 61 PUSH2 0x0eca 0EC4 83 DUP4 0EC5 83 DUP4 0EC6 61 PUSH2 0x1d82 0EC9 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0EBD stack[0] = storage[0x00] // @0EC0 stack[1] = storage[0x0b] // @0EC1 stack[2] = 0x0eca // @0EC4 stack[3] = stack[-1] // @0EC5 stack[4] = storage[0x00] // } // Block ends with call to 0x1d82, returns to 0x0ECA label_0ECA: // Incoming return from call to 0x1D82 at 0x0EC9 // Inputs[2] // { // @0ECB stack[-1] // @0ECB stack[-2] // } 0ECA 5B JUMPDEST 0ECB 11 GT 0ECC 15 ISZERO 0ECD 61 PUSH2 0x0ed5 0ED0 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0ed5, if !(stack[-1] > stack[-2]) label_0ED1: // Incoming jump from 0x0ED0, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0ED4 memory[0x00:0x00] } 0ED1 60 PUSH1 0x00 0ED3 80 DUP1 0ED4 FD *REVERT // Stack delta = +0 // Outputs[1] { @0ED4 revert(memory[0x00:0x00]); } // Block terminates label_0ED5: // Incoming jump from 0x0ED0, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @0ED9 stack[-3] // @0EDA stack[-2] // } 0ED5 5B JUMPDEST 0ED6 61 PUSH2 0x0839 0ED9 83 DUP4 0EDA 83 DUP4 0EDB 61 PUSH2 0x16db 0EDE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0ED6 stack[0] = 0x0839 // @0ED9 stack[1] = stack[-3] // @0EDA stack[2] = stack[-2] // } // Block ends with call to 0x16db, returns to 0x0839 label_0EDF: // Incoming call from 0x0577, returns to 0x0281 // Inputs[1] { @0EE4 storage[0x08] } 0EDF 5B JUMPDEST 0EE0 60 PUSH1 0x02 0EE2 60 PUSH1 0x08 0EE4 54 SLOAD 0EE5 03 SUB 0EE6 61 PUSH2 0x0f31 0EE9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f31, if storage[0x08] - 0x02 label_0EEA: // Incoming jump from 0x0EE9, if not storage[0x08] - 0x02 // Inputs[1] { @0EEC memory[0x40:0x60] } 0EEA 60 PUSH1 0x40 0EEC 51 MLOAD 0EED 62 PUSH3 0x461bcd 0EF1 60 PUSH1 0xe5 0EF3 1B SHL 0EF4 81 DUP2 0EF5 52 MSTORE 0EF6 60 PUSH1 0x20 0EF8 60 PUSH1 0x04 0EFA 82 DUP3 0EFB 01 ADD 0EFC 52 MSTORE 0EFD 60 PUSH1 0x1f 0EFF 60 PUSH1 0x24 0F01 82 DUP3 0F02 01 ADD 0F03 52 MSTORE 0F04 7F PUSH32 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 0F25 60 PUSH1 0x44 0F27 82 DUP3 0F28 01 ADD 0F29 52 MSTORE 0F2A 60 PUSH1 0x64 0F2C 01 ADD 0F2D 61 PUSH2 0x0702 0F30 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0EF5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EFC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F03 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @0F29 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 // @0F2C stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0702 label_0F31: // Incoming jump from 0x0EE9, if storage[0x08] - 0x02 // Inputs[2] // { // @0F39 storage[0x00] // @0F3C storage[0x0a] // } 0F31 5B JUMPDEST 0F32 60 PUSH1 0x02 0F34 60 PUSH1 0x08 0F36 55 SSTORE 0F37 60 PUSH1 0x00 0F39 54 SLOAD 0F3A 60 PUSH1 0x0a 0F3C 54 SLOAD 0F3D 60 PUSH1 0xff 0F3F 16 AND 0F40 61 PUSH2 0x0f48 0F43 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0F36 storage[0x08] = 0x02 // @0F39 stack[0] = storage[0x00] // } // Block ends with conditional jump to 0x0f48, if 0xff & storage[0x0a] label_0F44: // Incoming jump from 0x0F43, if not 0xff & storage[0x0a] // Inputs[1] { @0F47 memory[0x00:0x00] } 0F44 60 PUSH1 0x00 0F46 80 DUP1 0F47 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F47 revert(memory[0x00:0x00]); } // Block terminates label_0F48: // Incoming jump from 0x0F43, if 0xff & storage[0x0a] // Inputs[3] // { // @0F4B storage[0x0b] // @0F4E storage[0x0c] // @0F53 stack[-1] // } 0F48 5B JUMPDEST 0F49 60 PUSH1 0x0b 0F4B 54 SLOAD 0F4C 60 PUSH1 0x0c 0F4E 54 SLOAD 0F4F 61 PUSH2 0x0f58 0F52 90 SWAP1 0F53 83 DUP4 0F54 61 PUSH2 0x1d82 0F57 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F4B stack[0] = storage[0x0b] // @0F52 stack[1] = 0x0f58 // @0F52 stack[2] = storage[0x0c] // @0F53 stack[3] = stack[-1] // } // Block ends with call to 0x1d82, returns to 0x0F58 label_0F58: // Incoming return from call to 0x1D82 at 0x0F57 // Inputs[2] // { // @0F59 stack[-1] // @0F59 stack[-2] // } 0F58 5B JUMPDEST 0F59 11 GT 0F5A 15 ISZERO 0F5B 61 PUSH2 0x0f63 0F5E 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0f63, if !(stack[-1] > stack[-2]) label_0F5F: // Incoming jump from 0x0F5E, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0F62 memory[0x00:0x00] } 0F5F 60 PUSH1 0x00 0F61 80 DUP1 0F62 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F62 revert(memory[0x00:0x00]); } // Block terminates label_0F63: // Incoming jump from 0x0F5E, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @0F64 msg.sender // @0F65 tx.origin // } 0F63 5B JUMPDEST 0F64 33 CALLER 0F65 32 ORIGIN 0F66 14 EQ 0F67 61 PUSH2 0x0f6f 0F6A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f6f, if tx.origin == msg.sender label_0F6B: // Incoming jump from 0x0F6A, if not tx.origin == msg.sender // Inputs[1] { @0F6E memory[0x00:0x00] } 0F6B 60 PUSH1 0x00 0F6D 80 DUP1 0F6E FD *REVERT // Stack delta = +0 // Outputs[1] { @0F6E revert(memory[0x00:0x00]); } // Block terminates label_0F6F: // Incoming jump from 0x0F6A, if tx.origin == msg.sender // Inputs[4] // { // @0F72 storage[0x0c] // @0F73 msg.sender // @0F81 memory[0x00:0x40] // @0F82 storage[keccak256(memory[0x00:0x40])] // } 0F6F 5B JUMPDEST 0F70 60 PUSH1 0x0c 0F72 54 SLOAD 0F73 33 CALLER 0F74 60 PUSH1 0x00 0F76 90 SWAP1 0F77 81 DUP2 0F78 52 MSTORE 0F79 60 PUSH1 0x0d 0F7B 60 PUSH1 0x20 0F7D 52 MSTORE 0F7E 60 PUSH1 0x40 0F80 90 SWAP1 0F81 20 SHA3 0F82 54 SLOAD 0F83 10 LT 0F84 61 PUSH2 0x0f8c 0F87 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0F78 memory[0x00:0x20] = msg.sender // @0F7D memory[0x20:0x40] = 0x0d // } // Block ends with conditional jump to 0x0f8c, if storage[keccak256(memory[0x00:0x40])] < storage[0x0c] label_0F88: // Incoming jump from 0x0F87, if not storage[keccak256(memory[0x00:0x40])] < storage[0x0c] // Inputs[1] { @0F8B memory[0x00:0x00] } 0F88 60 PUSH1 0x00 0F8A 80 DUP1 0F8B FD *REVERT // Stack delta = +0 // Outputs[1] { @0F8B revert(memory[0x00:0x00]); } // Block terminates label_0F8C: // Incoming jump from 0x0F87, if storage[keccak256(memory[0x00:0x40])] < storage[0x0c] // Inputs[2] // { // @0F90 msg.sender // @0F93 storage[0x0c] // } 0F8C 5B JUMPDEST 0F8D 61 PUSH2 0x0f98 0F90 33 CALLER 0F91 60 PUSH1 0x0c 0F93 54 SLOAD 0F94 61 PUSH2 0x16db 0F97 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F8D stack[0] = 0x0f98 // @0F90 stack[1] = msg.sender // @0F93 stack[2] = storage[0x0c] // } // Block ends with call to 0x16db, returns to 0x0F98 label_0F98: // Incoming return from call to 0x16DB at 0x0F97 // Inputs[4] // { // @0F9B storage[0x0c] // @0F9C msg.sender // @0FAA memory[0x00:0x40] // @0FAC storage[keccak256(memory[0x00:0x40])] // } 0F98 5B JUMPDEST 0F99 60 PUSH1 0x0c 0F9B 54 SLOAD 0F9C 33 CALLER 0F9D 60 PUSH1 0x00 0F9F 90 SWAP1 0FA0 81 DUP2 0FA1 52 MSTORE 0FA2 60 PUSH1 0x0d 0FA4 60 PUSH1 0x20 0FA6 52 MSTORE 0FA7 60 PUSH1 0x40 0FA9 81 DUP2 0FAA 20 SHA3 0FAB 80 DUP1 0FAC 54 SLOAD 0FAD 90 SWAP1 0FAE 91 SWAP2 0FAF 90 SWAP1 0FB0 61 PUSH2 0x0fba 0FB3 90 SWAP1 0FB4 84 DUP5 0FB5 90 SWAP1 0FB6 61 PUSH2 0x1d82 0FB9 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @0F9B stack[0] = storage[0x0c] // @0FA1 memory[0x00:0x20] = msg.sender // @0FA6 memory[0x20:0x40] = 0x0d // @0FAE stack[1] = keccak256(memory[0x00:0x40]) // @0FAF stack[2] = 0x00 // @0FB3 stack[3] = 0x0fba // @0FB5 stack[4] = storage[0x0c] // @0FB5 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1d82, returns to 0x0FBA label_0FBA: // Incoming return from call to 0x1D82 at 0x0FB9 // Inputs[4] // { // @0FBB stack[-2] // @0FBB stack[-1] // @0FBC stack[-3] // @0FC6 stack[-6] // } 0FBA 5B JUMPDEST 0FBB 90 SWAP1 0FBC 91 SWAP2 0FBD 55 SSTORE 0FBE 50 POP 0FBF 50 POP 0FC0 60 PUSH1 0x01 0FC2 60 PUSH1 0x08 0FC4 55 SSTORE 0FC5 50 POP 0FC6 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @0FBD storage[stack[-3]] = stack[-1] // @0FC4 storage[0x08] = 0x01 // } // Block ends with unconditional jump to stack[-6] label_0FC7: // Incoming jump from 0x0597 // Inputs[2] // { // @0FCA storage[0x07] // @0FD4 msg.sender // } 0FC7 5B JUMPDEST 0FC8 60 PUSH1 0x07 0FCA 54 SLOAD 0FCB 60 PUSH1 0x01 0FCD 60 PUSH1 0x01 0FCF 60 PUSH1 0xa0 0FD1 1B SHL 0FD2 03 SUB 0FD3 16 AND 0FD4 33 CALLER 0FD5 14 EQ 0FD6 61 PUSH2 0x0ff1 0FD9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ff1, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_0FDA: // Incoming jump from 0x0FD9, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[1] { @0FDC memory[0x40:0x60] } 0FDA 60 PUSH1 0x40 0FDC 51 MLOAD 0FDD 62 PUSH3 0x461bcd 0FE1 60 PUSH1 0xe5 0FE3 1B SHL 0FE4 81 DUP2 0FE5 52 MSTORE 0FE6 60 PUSH1 0x04 0FE8 01 ADD 0FE9 61 PUSH2 0x0702 0FEC 90 SWAP1 0FED 61 PUSH2 0x1cb5 0FF0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0FE5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FEC stack[0] = 0x0702 // @0FEC stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1cb5, returns to 0x0702 label_0FF1: // Incoming jump from 0x0FD9, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[1] { @0FFA stack[-1] } 0FF1 5B JUMPDEST 0FF2 60 PUSH1 0x01 0FF4 60 PUSH1 0x01 0FF6 60 PUSH1 0xa0 0FF8 1B SHL 0FF9 03 SUB 0FFA 81 DUP2 0FFB 16 AND 0FFC 61 PUSH2 0x1056 0FFF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1056, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1000: // Incoming jump from 0x0FFF, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1002 memory[0x40:0x60] } 1000 60 PUSH1 0x40 1002 51 MLOAD 1003 62 PUSH3 0x461bcd 1007 60 PUSH1 0xe5 1009 1B SHL 100A 81 DUP2 100B 52 MSTORE 100C 60 PUSH1 0x20 100E 60 PUSH1 0x04 1010 82 DUP3 1011 01 ADD 1012 52 MSTORE 1013 60 PUSH1 0x26 1015 60 PUSH1 0x24 1017 82 DUP3 1018 01 ADD 1019 52 MSTORE 101A 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 103B 60 PUSH1 0x44 103D 82 DUP3 103E 01 ADD 103F 52 MSTORE 1040 65 PUSH6 0x646472657373 1047 60 PUSH1 0xd0 1049 1B SHL 104A 60 PUSH1 0x64 104C 82 DUP3 104D 01 ADD 104E 52 MSTORE 104F 60 PUSH1 0x84 1051 01 ADD 1052 61 PUSH2 0x0702 1055 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @100B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1012 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1019 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @103F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @104E memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @1051 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0702 label_1056: // Incoming jump from 0x0FFF, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @105A stack[-1] } 1056 5B JUMPDEST 1057 61 PUSH2 0x0ab1 105A 81 DUP2 105B 61 PUSH2 0x1477 105E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1057 stack[0] = 0x0ab1 // @105A stack[1] = stack[-1] // } // Block ends with call to 0x1477, returns to 0x0AB1 label_105F: // Incoming call from 0x1260, returns to 0x1261 // Incoming call from 0x0838, returns to 0x0839 // Inputs[8] // { // @1062 stack[-2] // @106E memory[0x00:0x40] // @1070 storage[keccak256(memory[0x00:0x40])] // @1083 stack[-3] // @108D memory[0x40:0x60] // @1091 stack[-1] // @10B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @10BA stack[-4] // } 105F 5B JUMPDEST 1060 60 PUSH1 0x00 1062 82 DUP3 1063 81 DUP2 1064 52 MSTORE 1065 60 PUSH1 0x05 1067 60 PUSH1 0x20 1069 52 MSTORE 106A 60 PUSH1 0x40 106C 80 DUP1 106D 82 DUP3 106E 20 SHA3 106F 80 DUP1 1070 54 SLOAD 1071 60 PUSH1 0x01 1073 60 PUSH1 0x01 1075 60 PUSH1 0xa0 1077 1B SHL 1078 03 SUB 1079 19 NOT 107A 16 AND 107B 60 PUSH1 0x01 107D 60 PUSH1 0x01 107F 60 PUSH1 0xa0 1081 1B SHL 1082 03 SUB 1083 87 DUP8 1084 81 DUP2 1085 16 AND 1086 91 SWAP2 1087 82 DUP3 1088 17 OR 1089 90 SWAP1 108A 92 SWAP3 108B 55 SSTORE 108C 91 SWAP2 108D 51 MLOAD 108E 85 DUP6 108F 93 SWAP4 1090 91 SWAP2 1091 85 DUP6 1092 16 AND 1093 91 SWAP2 1094 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 10B5 91 SWAP2 10B6 A4 LOG4 10B7 50 POP 10B8 50 POP 10B9 50 POP 10BA 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1064 memory[0x00:0x20] = stack[-2] // @1069 memory[0x20:0x40] = 0x05 // @108B storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @10B6 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_10BB: // Incoming jump from 0x0D94 // Incoming jump from 0x0848 // Inputs[1] { @10C1 stack[-1] } 10BB 5B JUMPDEST 10BC 60 PUSH1 0x00 10BE 61 PUSH2 0x10c6 10C1 82 DUP3 10C2 61 PUSH2 0x13a0 10C5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10BC stack[0] = 0x00 // @10BE stack[1] = 0x10c6 // @10C1 stack[2] = stack[-1] // } // Block ends with call to 0x13a0, returns to 0x10C6 label_10C6: // Incoming return from call to 0x13A0 at 0x10C5 // Inputs[4] // { // @10C7 stack[-1] // @10C8 memory[stack[-1]:stack[-1] + 0x20] // @10CA stack[-2] // @10D8 msg.sender // } 10C6 5B JUMPDEST 10C7 80 DUP1 10C8 51 MLOAD 10C9 90 SWAP1 10CA 91 SWAP2 10CB 50 POP 10CC 60 PUSH1 0x00 10CE 90 SWAP1 10CF 60 PUSH1 0x01 10D1 60 PUSH1 0x01 10D3 60 PUSH1 0xa0 10D5 1B SHL 10D6 03 SUB 10D7 16 AND 10D8 33 CALLER 10D9 60 PUSH1 0x01 10DB 60 PUSH1 0x01 10DD 60 PUSH1 0xa0 10DF 1B SHL 10E0 03 SUB 10E1 16 AND 10E2 14 EQ 10E3 80 DUP1 10E4 61 PUSH2 0x10fd 10E7 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @10CA stack[-2] = stack[-1] // @10CE stack[-1] = 0x00 // @10E2 stack[0] = (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x10fd, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] label_10E8: // Incoming jump from 0x10E7, if not (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] // Inputs[2] // { // @10E9 msg.sender // @10ED stack[-4] // } 10E8 50 POP 10E9 33 CALLER 10EA 61 PUSH2 0x10f2 10ED 84 DUP5 10EE 61 PUSH2 0x0697 10F1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @10E9 stack[-1] = msg.sender // @10EA stack[0] = 0x10f2 // @10ED stack[1] = stack[-4] // } // Block ends with call to 0x0697, returns to 0x10F2 label_10F2: // Incoming return from call to 0x0697 at 0x10F1 // Inputs[2] // { // @10FB stack[-1] // @10FC stack[-2] // } 10F2 5B JUMPDEST 10F3 60 PUSH1 0x01 10F5 60 PUSH1 0x01 10F7 60 PUSH1 0xa0 10F9 1B SHL 10FA 03 SUB 10FB 16 AND 10FC 14 EQ // Stack delta = -1 // Outputs[1] { @10FC stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_10FD: // Incoming jump from 0x10E7, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] // Incoming jump from 0x10FC // Inputs[1] { @10FE stack[-1] } 10FD 5B JUMPDEST 10FE 80 DUP1 10FF 61 PUSH2 0x110f 1102 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x110f, if stack[-1] label_1103: // Incoming jump from 0x1102, if not stack[-1] // Inputs[3] // { // @1104 stack[-3] // @1105 memory[stack[-3]:stack[-3] + 0x20] // @110A msg.sender // } 1103 50 POP 1104 81 DUP2 1105 51 MLOAD 1106 61 PUSH2 0x110f 1109 90 SWAP1 110A 33 CALLER 110B 61 PUSH2 0x0535 110E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1109 stack[0] = memory[stack[-3]:stack[-3] + 0x20] // @1109 stack[-1] = 0x110f // @110A stack[1] = msg.sender // } // Block ends with call to 0x0535, returns to 0x110F label_110F: // Incoming return from call to 0x0535 at 0x110E // Incoming jump from 0x1102, if stack[-1] // Inputs[2] // { // @1110 stack[-2] // @1110 stack[-1] // } 110F 5B JUMPDEST 1110 90 SWAP1 1111 50 POP 1112 80 DUP1 1113 61 PUSH2 0x1179 1116 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1110 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1179, if stack[-1] label_1117: // Incoming jump from 0x1116, if not stack[-1] // Inputs[1] { @1119 memory[0x40:0x60] } 1117 60 PUSH1 0x40 1119 51 MLOAD 111A 62 PUSH3 0x461bcd 111E 60 PUSH1 0xe5 1120 1B SHL 1121 81 DUP2 1122 52 MSTORE 1123 60 PUSH1 0x20 1125 60 PUSH1 0x04 1127 82 DUP3 1128 01 ADD 1129 52 MSTORE 112A 60 PUSH1 0x32 112C 60 PUSH1 0x24 112E 82 DUP3 112F 01 ADD 1130 52 MSTORE 1131 7F PUSH32 0x455243373231413a207472616e736665722063616c6c6572206973206e6f7420 1152 60 PUSH1 0x44 1154 82 DUP3 1155 01 ADD 1156 52 MSTORE 1157 71 PUSH18 0x1bdddb995c881b9bdc88185c1c1c9bdd9959 116A 60 PUSH1 0x72 116C 1B SHL 116D 60 PUSH1 0x64 116F 82 DUP3 1170 01 ADD 1171 52 MSTORE 1172 60 PUSH1 0x84 1174 01 ADD 1175 61 PUSH2 0x0702 1178 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1122 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1129 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1130 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x32 // @1156 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a207472616e736665722063616c6c6572206973206e6f7420 // @1171 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x1bdddb995c881b9bdc88185c1c1c9bdd9959 << 0x72 // @1174 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0702 label_1179: // Incoming jump from 0x1116, if stack[-1] // Inputs[3] // { // @117A stack[-5] // @1184 stack[-2] // @1188 memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] // } 1179 5B JUMPDEST 117A 84 DUP5 117B 60 PUSH1 0x01 117D 60 PUSH1 0x01 117F 60 PUSH1 0xa0 1181 1B SHL 1182 03 SUB 1183 16 AND 1184 82 DUP3 1185 60 PUSH1 0x00 1187 01 ADD 1188 51 MLOAD 1189 60 PUSH1 0x01 118B 60 PUSH1 0x01 118D 60 PUSH1 0xa0 118F 1B SHL 1190 03 SUB 1191 16 AND 1192 14 EQ 1193 61 PUSH2 0x11ed 1196 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11ed, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] label_1197: // Incoming jump from 0x1196, if not (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[1] { @1199 memory[0x40:0x60] } 1197 60 PUSH1 0x40 1199 51 MLOAD 119A 62 PUSH3 0x461bcd 119E 60 PUSH1 0xe5 11A0 1B SHL 11A1 81 DUP2 11A2 52 MSTORE 11A3 60 PUSH1 0x20 11A5 60 PUSH1 0x04 11A7 82 DUP3 11A8 01 ADD 11A9 52 MSTORE 11AA 60 PUSH1 0x26 11AC 60 PUSH1 0x24 11AE 82 DUP3 11AF 01 ADD 11B0 52 MSTORE 11B1 7F PUSH32 0x455243373231413a207472616e736665722066726f6d20696e636f7272656374 11D2 60 PUSH1 0x44 11D4 82 DUP3 11D5 01 ADD 11D6 52 MSTORE 11D7 65 PUSH6 0x1037bbb732b9 11DE 60 PUSH1 0xd1 11E0 1B SHL 11E1 60 PUSH1 0x64 11E3 82 DUP3 11E4 01 ADD 11E5 52 MSTORE 11E6 60 PUSH1 0x84 11E8 01 ADD 11E9 61 PUSH2 0x0702 11EC 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @11A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11A9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11B0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @11D6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a207472616e736665722066726f6d20696e636f7272656374 // @11E5 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x1037bbb732b9 << 0xd1 // @11E8 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0702 label_11ED: // Incoming jump from 0x1196, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[1] { @11F6 stack[-4] } 11ED 5B JUMPDEST 11EE 60 PUSH1 0x01 11F0 60 PUSH1 0x01 11F2 60 PUSH1 0xa0 11F4 1B SHL 11F5 03 SUB 11F6 84 DUP5 11F7 16 AND 11F8 61 PUSH2 0x1251 11FB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1251, if stack[-4] & (0x01 << 0xa0) - 0x01 label_11FC: // Incoming jump from 0x11FB, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @11FE memory[0x40:0x60] } 11FC 60 PUSH1 0x40 11FE 51 MLOAD 11FF 62 PUSH3 0x461bcd 1203 60 PUSH1 0xe5 1205 1B SHL 1206 81 DUP2 1207 52 MSTORE 1208 60 PUSH1 0x20 120A 60 PUSH1 0x04 120C 82 DUP3 120D 01 ADD 120E 52 MSTORE 120F 60 PUSH1 0x25 1211 60 PUSH1 0x24 1213 82 DUP3 1214 01 ADD 1215 52 MSTORE 1216 7F PUSH32 0x455243373231413a207472616e7366657220746f20746865207a65726f206164 1237 60 PUSH1 0x44 1239 82 DUP3 123A 01 ADD 123B 52 MSTORE 123C 64 PUSH5 0x6472657373 1242 60 PUSH1 0xd8 1244 1B SHL 1245 60 PUSH1 0x64 1247 82 DUP3 1248 01 ADD 1249 52 MSTORE 124A 60 PUSH1 0x84 124C 01 ADD 124D 61 PUSH2 0x0702 1250 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1207 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @120E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1215 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @123B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a207472616e7366657220746f20746865207a65726f206164 // @1249 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6472657373 << 0xd8 // @124C stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0702 label_1251: // Incoming jump from 0x11FB, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1257 stack[-3] // @1258 stack[-2] // @125C memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] // } 1251 5B JUMPDEST 1252 61 PUSH2 0x1261 1255 60 PUSH1 0x00 1257 84 DUP5 1258 84 DUP5 1259 60 PUSH1 0x00 125B 01 ADD 125C 51 MLOAD 125D 61 PUSH2 0x105f 1260 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1252 stack[0] = 0x1261 // @1255 stack[1] = 0x00 // @1257 stack[2] = stack[-3] // @125C stack[3] = memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] // } // Block ends with call to 0x105f, returns to 0x1261 label_1261: // Incoming return from call to 0x105F at 0x1260 // Inputs[12] // { // @126A stack[-5] // @127D memory[0x00:0x40] // @127F storage[keccak256(memory[0x00:0x40])] // @12A1 stack[-4] // @12A9 memory[0x00:0x40] // @12AB storage[keccak256(memory[0x00:0x40])] // @12C1 stack[-3] // @12CB memory[0x00:0x40] // @12CD storage[keccak256(memory[0x00:0x40])] // @12E0 block.timestamp // @12F6 memory[0x00:0x40] // @12F7 storage[keccak256(memory[0x00:0x40])] // } 1261 5B JUMPDEST 1262 60 PUSH1 0x01 1264 60 PUSH1 0x01 1266 60 PUSH1 0xa0 1268 1B SHL 1269 03 SUB 126A 85 DUP6 126B 81 DUP2 126C 16 AND 126D 60 PUSH1 0x00 126F 90 SWAP1 1270 81 DUP2 1271 52 MSTORE 1272 60 PUSH1 0x04 1274 60 PUSH1 0x20 1276 90 SWAP1 1277 81 DUP2 1278 52 MSTORE 1279 60 PUSH1 0x40 127B 80 DUP1 127C 83 DUP4 127D 20 SHA3 127E 80 DUP1 127F 54 SLOAD 1280 60 PUSH1 0x01 1282 60 PUSH1 0x01 1284 60 PUSH1 0x80 1286 1B SHL 1287 03 SUB 1288 19 NOT 1289 80 DUP1 128A 82 DUP3 128B 16 AND 128C 60 PUSH1 0x01 128E 60 PUSH1 0x01 1290 60 PUSH1 0x80 1292 1B SHL 1293 03 SUB 1294 92 SWAP3 1295 83 DUP4 1296 16 AND 1297 60 PUSH1 0x00 1299 19 NOT 129A 01 ADD 129B 83 DUP4 129C 16 AND 129D 17 OR 129E 90 SWAP1 129F 92 SWAP3 12A0 55 SSTORE 12A1 89 DUP10 12A2 86 DUP7 12A3 16 AND 12A4 80 DUP1 12A5 86 DUP7 12A6 52 MSTORE 12A7 83 DUP4 12A8 86 DUP7 12A9 20 SHA3 12AA 80 DUP1 12AB 54 SLOAD 12AC 93 SWAP4 12AD 84 DUP5 12AE 16 AND 12AF 93 SWAP4 12B0 83 DUP4 12B1 16 AND 12B2 60 PUSH1 0x01 12B4 90 SWAP1 12B5 81 DUP2 12B6 01 ADD 12B7 90 SWAP1 12B8 93 SWAP4 12B9 16 AND 12BA 93 SWAP4 12BB 90 SWAP1 12BC 93 SWAP4 12BD 17 OR 12BE 90 SWAP1 12BF 92 SWAP3 12C0 55 SSTORE 12C1 88 DUP9 12C2 85 DUP6 12C3 52 MSTORE 12C4 60 PUSH1 0x03 12C6 90 SWAP1 12C7 93 SWAP4 12C8 52 MSTORE 12C9 81 DUP2 12CA 84 DUP5 12CB 20 SHA3 12CC 80 DUP1 12CD 54 SLOAD 12CE 60 PUSH1 0x01 12D0 60 PUSH1 0x01 12D2 60 PUSH1 0xe0 12D4 1B SHL 12D5 03 SUB 12D6 19 NOT 12D7 16 AND 12D8 90 SWAP1 12D9 91 SWAP2 12DA 17 OR 12DB 60 PUSH1 0x01 12DD 60 PUSH1 0xa0 12DF 1B SHL 12E0 42 TIMESTAMP 12E1 67 PUSH8 0xffffffffffffffff 12EA 16 AND 12EB 02 MUL 12EC 17 OR 12ED 90 SWAP1 12EE 55 SSTORE 12EF 90 SWAP1 12F0 86 DUP7 12F1 01 ADD 12F2 80 DUP1 12F3 83 DUP4 12F4 52 MSTORE 12F5 91 SWAP2 12F6 20 SHA3 12F7 54 SLOAD 12F8 90 SWAP1 12F9 91 SWAP2 12FA 16 AND 12FB 61 PUSH2 0x1356 12FE 57 *JUMPI // Stack delta = +1 // Outputs[10] // { // @1271 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1278 memory[0x20:0x40] = 0x04 // @12A0 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x80) - 0x01 & ~0x00 + ((0x01 << 0x80) - 0x01 & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~((0x01 << 0x80) - 0x01)) // @12A6 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @12C0 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x80) - 0x01 & 0x01 + ((0x01 << 0x80) - 0x01 & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~((0x01 << 0x80) - 0x01)) // @12C3 memory[0x00:0x20] = stack[-3] // @12C8 memory[0x20:0x40] = 0x03 // @12EE storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | ((0x01 << 0xa0) - 0x01 & stack[-4]) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @12F4 memory[0x00:0x20] = stack[-3] + 0x01 // @12F9 stack[0] = stack[-3] + 0x01 // } // Block ends with conditional jump to 0x1356, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_12FF: // Incoming jump from 0x12FE, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @1302 stack[-1] // @1305 storage[0x00] // } 12FF 61 PUSH2 0x1309 1302 81 DUP2 1303 60 PUSH1 0x00 1305 54 SLOAD 1306 11 GT 1307 90 SWAP1 1308 56 *JUMP // Stack delta = +1 // Outputs[1] { @1307 stack[0] = storage[0x00] > stack[-1] } // Block ends with unconditional jump to 0x1309 label_1309: // Incoming jump from 0x1308 // Inputs[1] { @130A stack[-1] } 1309 5B JUMPDEST 130A 15 ISZERO 130B 61 PUSH2 0x1356 130E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1356, if !stack[-1] label_130F: // Incoming jump from 0x130E, if not !stack[-1] // Inputs[6] // { // @130F stack[-3] // @1310 memory[stack[-3]:stack[-3] + 0x20] // @1313 stack[-1] // @1321 memory[0x00:0x40] // @1323 storage[keccak256(memory[0x00:0x40])] // @1327 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 130F 82 DUP3 1310 51 MLOAD 1311 60 PUSH1 0x00 1313 82 DUP3 1314 81 DUP2 1315 52 MSTORE 1316 60 PUSH1 0x03 1318 60 PUSH1 0x20 131A 90 SWAP1 131B 81 DUP2 131C 52 MSTORE 131D 60 PUSH1 0x40 131F 90 SWAP1 1320 91 SWAP2 1321 20 SHA3 1322 80 DUP1 1323 54 SLOAD 1324 91 SWAP2 1325 86 DUP7 1326 01 ADD 1327 51 MLOAD 1328 67 PUSH8 0xffffffffffffffff 1331 16 AND 1332 60 PUSH1 0x01 1334 60 PUSH1 0xa0 1336 1B SHL 1337 02 MUL 1338 60 PUSH1 0x01 133A 60 PUSH1 0x01 133C 60 PUSH1 0xe0 133E 1B SHL 133F 03 SUB 1340 19 NOT 1341 90 SWAP1 1342 92 SWAP3 1343 16 AND 1344 60 PUSH1 0x01 1346 60 PUSH1 0x01 1348 60 PUSH1 0xa0 134A 1B SHL 134B 03 SUB 134C 90 SWAP1 134D 93 SWAP4 134E 16 AND 134F 92 SWAP3 1350 90 SWAP1 1351 92 SWAP3 1352 17 OR 1353 17 OR 1354 90 SWAP1 1355 55 SSTORE // Stack delta = +0 // Outputs[3] // { // @1315 memory[0x00:0x20] = stack[-1] // @131C memory[0x20:0x40] = 0x03 // @1355 storage[keccak256(memory[0x00:0x40])] = (memory[stack[-3]:stack[-3] + 0x20] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * (0xffffffffffffffff & memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20]) // } // Block continues label_1356: // Incoming jump from 0x12FE, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x130E, if !stack[-1] // Incoming jump from 0x1355 // Inputs[6] // { // @1358 stack[-4] // @1359 stack[-5] // @1363 stack[-6] // @1390 memory[0x40:0x60] // @1393 memory[0x40:0x60] // @1398 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 1356 5B JUMPDEST 1357 50 POP 1358 82 DUP3 1359 84 DUP5 135A 60 PUSH1 0x01 135C 60 PUSH1 0x01 135E 60 PUSH1 0xa0 1360 1B SHL 1361 03 SUB 1362 16 AND 1363 86 DUP7 1364 60 PUSH1 0x01 1366 60 PUSH1 0x01 1368 60 PUSH1 0xa0 136A 1B SHL 136B 03 SUB 136C 16 AND 136D 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 138E 60 PUSH1 0x40 1390 51 MLOAD 1391 60 PUSH1 0x40 1393 51 MLOAD 1394 80 DUP1 1395 91 SWAP2 1396 03 SUB 1397 90 SWAP1 1398 A4 LOG4 // Stack delta = -1 // Outputs[1] { @1398 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 continues label_1399: // Incoming jump from 0x1398 // Incoming jump from 0x18BD // Inputs[1] { @139F stack[-6] } 1399 5B JUMPDEST 139A 50 POP 139B 50 POP 139C 50 POP 139D 50 POP 139E 50 POP 139F 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_13A0: // Incoming call from 0x10C5, returns to 0x10C6 // Incoming call from 0x0B3B, returns to 0x0B3C // Inputs[3] // { // @13A4 memory[0x40:0x60] // @13B8 stack[-1] // @13BB storage[0x00] // } 13A0 5B JUMPDEST 13A1 60 PUSH1 0x40 13A3 80 DUP1 13A4 51 MLOAD 13A5 80 DUP1 13A6 82 DUP3 13A7 01 ADD 13A8 90 SWAP1 13A9 91 SWAP2 13AA 52 MSTORE 13AB 60 PUSH1 0x00 13AD 80 DUP1 13AE 82 DUP3 13AF 52 MSTORE 13B0 60 PUSH1 0x20 13B2 82 DUP3 13B3 01 ADD 13B4 52 MSTORE 13B5 61 PUSH2 0x13bf 13B8 82 DUP3 13B9 60 PUSH1 0x00 13BB 54 SLOAD 13BC 11 GT 13BD 90 SWAP1 13BE 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @13A9 stack[0] = memory[0x40:0x60] // @13AA memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @13AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @13B4 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @13BD stack[1] = storage[0x00] > stack[-1] // } // Block ends with unconditional jump to 0x13bf label_13BF: // Incoming jump from 0x13BE // Inputs[1] { @13C3 stack[-1] } 13BF 5B JUMPDEST 13C0 61 PUSH2 0x141e 13C3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x141e, if stack[-1] label_13C4: // Incoming jump from 0x13C3, if not stack[-1] // Inputs[1] { @13C6 memory[0x40:0x60] } 13C4 60 PUSH1 0x40 13C6 51 MLOAD 13C7 62 PUSH3 0x461bcd 13CB 60 PUSH1 0xe5 13CD 1B SHL 13CE 81 DUP2 13CF 52 MSTORE 13D0 60 PUSH1 0x20 13D2 60 PUSH1 0x04 13D4 82 DUP3 13D5 01 ADD 13D6 52 MSTORE 13D7 60 PUSH1 0x2a 13D9 60 PUSH1 0x24 13DB 82 DUP3 13DC 01 ADD 13DD 52 MSTORE 13DE 7F PUSH32 0x455243373231413a206f776e657220717565727920666f72206e6f6e65786973 13FF 60 PUSH1 0x44 1401 82 DUP3 1402 01 ADD 1403 52 MSTORE 1404 69 PUSH10 0x3a32b73a103a37b5b2b7 140F 60 PUSH1 0xb1 1411 1B SHL 1412 60 PUSH1 0x64 1414 82 DUP3 1415 01 ADD 1416 52 MSTORE 1417 60 PUSH1 0x84 1419 01 ADD 141A 61 PUSH2 0x0702 141D 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @13CF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13D6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @13DD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @1403 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a206f776e657220717565727920666f72206e6f6e65786973 // @1416 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3a32b73a103a37b5b2b7 << 0xb1 // @1419 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0702 label_141E: // Incoming jump from 0x13C3, if stack[-1] // Inputs[4] // { // @141F stack[-2] // @1432 memory[0x00:0x40] // @1434 memory[0x40:0x60] // @143B storage[keccak256(memory[0x00:0x40])] // } 141E 5B JUMPDEST 141F 81 DUP2 1420 5B JUMPDEST 1421 60 PUSH1 0x00 1423 81 DUP2 1424 81 DUP2 1425 52 MSTORE 1426 60 PUSH1 0x03 1428 60 PUSH1 0x20 142A 90 SWAP1 142B 81 DUP2 142C 52 MSTORE 142D 60 PUSH1 0x40 142F 91 SWAP2 1430 82 DUP3 1431 90 SWAP1 1432 20 SHA3 1433 82 DUP3 1434 51 MLOAD 1435 80 DUP1 1436 84 DUP5 1437 01 ADD 1438 90 SWAP1 1439 93 SWAP4 143A 52 MSTORE 143B 54 SLOAD 143C 60 PUSH1 0x01 143E 60 PUSH1 0x01 1440 60 PUSH1 0xa0 1442 1B SHL 1443 03 SUB 1444 81 DUP2 1445 16 AND 1446 80 DUP1 1447 84 DUP5 1448 52 MSTORE 1449 60 PUSH1 0x01 144B 60 PUSH1 0xa0 144D 1B SHL 144E 90 SWAP1 144F 91 SWAP2 1450 04 DIV 1451 67 PUSH8 0xffffffffffffffff 145A 16 AND 145B 91 SWAP2 145C 83 DUP4 145D 01 ADD 145E 91 SWAP2 145F 90 SWAP1 1460 91 SWAP2 1461 52 MSTORE 1462 15 ISZERO 1463 61 PUSH2 0x146d 1466 57 *JUMPI // Stack delta = +2 // Outputs[7] // { // @141F stack[0] = stack[-2] // @1425 memory[0x00:0x20] = stack[-2] // @142C memory[0x20:0x40] = 0x03 // @1439 stack[1] = memory[0x40:0x60] // @143A memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1448 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @1461 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // } // Block ends with conditional jump to 0x146d, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_1467: // Incoming jump from 0x1466, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Incoming jump from 0x1466, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @1467 stack[-5] // @1467 stack[-1] // @1468 stack[-4] // } 1467 93 SWAP4 1468 92 SWAP3 1469 50 POP 146A 50 POP 146B 50 POP 146C 56 *JUMP // Stack delta = -4 // Outputs[1] { @1467 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_146D: // Incoming jump from 0x1466, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Incoming jump from 0x1466, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[1] { @1472 stack[-2] } 146D 5B JUMPDEST 146E 50 POP 146F 60 PUSH1 0x00 1471 19 NOT 1472 01 ADD 1473 61 PUSH2 0x1420 1476 56 *JUMP // Stack delta = -1 // Outputs[1] { @1472 stack[-2] = ~0x00 + stack[-2] } // Block ends with unconditional jump to 0x1420 label_1477: // Incoming call from 0x0C48, returns to 0x0C49 // Incoming call from 0x105E, returns to 0x0AB1 // Inputs[5] // { // @147B storage[0x07] // @1484 stack[-1] // @1499 memory[0x40:0x60] // @14C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @14C8 stack[-2] // } 1477 5B JUMPDEST 1478 60 PUSH1 0x07 147A 80 DUP1 147B 54 SLOAD 147C 60 PUSH1 0x01 147E 60 PUSH1 0x01 1480 60 PUSH1 0xa0 1482 1B SHL 1483 03 SUB 1484 83 DUP4 1485 81 DUP2 1486 16 AND 1487 60 PUSH1 0x01 1489 60 PUSH1 0x01 148B 60 PUSH1 0xa0 148D 1B SHL 148E 03 SUB 148F 19 NOT 1490 83 DUP4 1491 16 AND 1492 81 DUP2 1493 17 OR 1494 90 SWAP1 1495 93 SWAP4 1496 55 SSTORE 1497 60 PUSH1 0x40 1499 51 MLOAD 149A 91 SWAP2 149B 16 AND 149C 91 SWAP2 149D 90 SWAP1 149E 82 DUP3 149F 90 SWAP1 14A0 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 14C1 90 SWAP1 14C2 60 PUSH1 0x00 14C4 90 SWAP1 14C5 A3 LOG3 14C6 50 POP 14C7 50 POP 14C8 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1496 storage[0x07] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x07] & ~((0x01 << 0xa0) - 0x01)) // @14C5 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x07] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_14C9: // Incoming call from 0x188C, returns to 0x188D // Inputs[2] // { // @14D4 stack[-3] // @14D6 address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 14C9 5B JUMPDEST 14CA 60 PUSH1 0x00 14CC 60 PUSH1 0x01 14CE 60 PUSH1 0x01 14D0 60 PUSH1 0xa0 14D2 1B SHL 14D3 03 SUB 14D4 84 DUP5 14D5 16 AND 14D6 3B EXTCODESIZE 14D7 15 ISZERO 14D8 61 PUSH2 0x15bf 14DB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @14CA stack[0] = 0x00 } // Block ends with conditional jump to 0x15bf, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_14DC: // Incoming jump from 0x14DB, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[6] // { // @14DE memory[0x40:0x60] // @14F1 stack[-4] // @14FE msg.sender // @1500 stack[-5] // @1502 stack[-3] // @1504 stack[-2] // } 14DC 60 PUSH1 0x40 14DE 51 MLOAD 14DF 63 PUSH4 0x0a85bd01 14E4 60 PUSH1 0xe1 14E6 1B SHL 14E7 81 DUP2 14E8 52 MSTORE 14E9 60 PUSH1 0x01 14EB 60 PUSH1 0x01 14ED 60 PUSH1 0xa0 14EF 1B SHL 14F0 03 SUB 14F1 85 DUP6 14F2 16 AND 14F3 90 SWAP1 14F4 63 PUSH4 0x150b7a02 14F9 90 SWAP1 14FA 61 PUSH2 0x150d 14FD 90 SWAP1 14FE 33 CALLER 14FF 90 SWAP1 1500 89 DUP10 1501 90 SWAP1 1502 88 DUP9 1503 90 SWAP1 1504 88 DUP9 1505 90 SWAP1 1506 60 PUSH1 0x04 1508 01 ADD 1509 61 PUSH2 0x1d9a 150C 56 *JUMP // Stack delta = +8 // Outputs[9] // { // @14E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @14F3 stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @14F9 stack[1] = 0x150b7a02 // @14FD stack[2] = 0x150d // @14FF stack[3] = msg.sender // @1501 stack[4] = stack[-5] // @1503 stack[5] = stack[-3] // @1505 stack[6] = stack[-2] // @1508 stack[7] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1d9a, returns to 0x150D label_150D: // Incoming return from call to 0x1D9A at 0x150C // Inputs[6] // { // @1512 memory[0x40:0x60] // @1514 stack[-1] // @1519 stack[-3] // @151A msg.gas // @151B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @151B address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } 150D 5B JUMPDEST 150E 60 PUSH1 0x20 1510 60 PUSH1 0x40 1512 51 MLOAD 1513 80 DUP1 1514 83 DUP4 1515 03 SUB 1516 81 DUP2 1517 60 PUSH1 0x00 1519 87 DUP8 151A 5A GAS 151B F1 CALL 151C 92 SWAP3 151D 50 POP 151E 50 POP 151F 50 POP 1520 80 DUP1 1521 15 ISZERO 1522 61 PUSH2 0x1548 1525 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @151B 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]]) // @151C 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 0x1548, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_1526: // Incoming jump from 0x1525, if not !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[2] // { // @152A memory[0x40:0x60] // @152D returndata.length // } 1526 50 POP 1527 60 PUSH1 0x40 1529 80 DUP1 152A 51 MLOAD 152B 60 PUSH1 0x1f 152D 3D RETURNDATASIZE 152E 90 SWAP1 152F 81 DUP2 1530 01 ADD 1531 60 PUSH1 0x1f 1533 19 NOT 1534 16 AND 1535 82 DUP3 1536 01 ADD 1537 90 SWAP1 1538 92 SWAP3 1539 52 MSTORE 153A 61 PUSH2 0x1545 153D 91 SWAP2 153E 81 DUP2 153F 01 ADD 1540 90 SWAP1 1541 61 PUSH2 0x1dd7 1544 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1539 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @153D stack[-1] = 0x1545 // @1540 stack[1] = memory[0x40:0x60] // @1540 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x1dd7 1545 5B JUMPDEST 1546 60 PUSH1 0x01 label_1548: // Incoming jump from 0x1525, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[1] { @154C stack[-1] } 1548 5B JUMPDEST 1549 61 PUSH2 0x15a5 154C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x15a5, if stack[-1] label_154D: // Incoming jump from 0x154C, if not stack[-1] // Inputs[1] { @154D returndata.length } 154D 3D RETURNDATASIZE 154E 80 DUP1 154F 80 DUP1 1550 15 ISZERO 1551 61 PUSH2 0x1576 1554 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @154D stack[0] = returndata.length // @154E stack[1] = returndata.length // } // Block ends with conditional jump to 0x1576, if !returndata.length label_1555: // Incoming jump from 0x1554, if not !returndata.length // Inputs[6] // { // @1557 memory[0x40:0x60] // @1558 stack[-2] // @155F returndata.length // @1567 returndata.length // @156A returndata.length // @1571 returndata[0x00:0x00 + returndata.length] // } 1555 60 PUSH1 0x40 1557 51 MLOAD 1558 91 SWAP2 1559 50 POP 155A 60 PUSH1 0x1f 155C 19 NOT 155D 60 PUSH1 0x3f 155F 3D RETURNDATASIZE 1560 01 ADD 1561 16 AND 1562 82 DUP3 1563 01 ADD 1564 60 PUSH1 0x40 1566 52 MSTORE 1567 3D RETURNDATASIZE 1568 82 DUP3 1569 52 MSTORE 156A 3D RETURNDATASIZE 156B 60 PUSH1 0x00 156D 60 PUSH1 0x20 156F 84 DUP5 1570 01 ADD 1571 3E RETURNDATACOPY 1572 61 PUSH2 0x157b 1575 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1558 stack[-2] = memory[0x40:0x60] // @1566 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1569 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1571 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x157b label_1576: // Incoming jump from 0x1554, if !returndata.length // Inputs[2] // { // @1579 stack[-2] // @157E memory[0x60:0x80] // } 1576 5B JUMPDEST 1577 60 PUSH1 0x60 1579 91 SWAP2 157A 50 POP 157B 5B JUMPDEST 157C 50 POP 157D 80 DUP1 157E 51 MLOAD 157F 60 PUSH1 0x00 1581 03 SUB 1582 61 PUSH2 0x159d 1585 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1579 stack[-2] = 0x60 } // Block ends with conditional jump to 0x159d, if 0x00 - memory[0x60:0x80] label_1586: // Incoming jump from 0x1585, if not 0x00 - memory[0x60:0x80] // Incoming jump from 0x1585, if not 0x00 - memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @1588 memory[0x40:0x60] } 1586 60 PUSH1 0x40 1588 51 MLOAD 1589 62 PUSH3 0x461bcd 158D 60 PUSH1 0xe5 158F 1B SHL 1590 81 DUP2 1591 52 MSTORE 1592 60 PUSH1 0x04 1594 01 ADD 1595 61 PUSH2 0x0702 1598 90 SWAP1 1599 61 PUSH2 0x1cea 159C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1591 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1598 stack[0] = 0x0702 // @1598 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1cea, returns to 0x0702 label_159D: // Incoming jump from 0x1585, if 0x00 - memory[0x60:0x80] // Incoming jump from 0x1585, if 0x00 - memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @159E stack[-1] // @159F memory[stack[-1]:stack[-1] + 0x20] // @15A4 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 159D 5B JUMPDEST 159E 80 DUP1 159F 51 MLOAD 15A0 81 DUP2 15A1 60 PUSH1 0x20 15A3 01 ADD 15A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @15A4 revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_15A5: // Incoming jump from 0x154C, if stack[-1] // Inputs[2] // { // @15AF stack[-1] // @15B9 stack[-2] // } 15A5 5B JUMPDEST 15A6 60 PUSH1 0x01 15A8 60 PUSH1 0x01 15AA 60 PUSH1 0xe0 15AC 1B SHL 15AD 03 SUB 15AE 19 NOT 15AF 16 AND 15B0 63 PUSH4 0x0a85bd01 15B5 60 PUSH1 0xe1 15B7 1B SHL 15B8 14 EQ 15B9 90 SWAP1 15BA 50 POP 15BB 61 PUSH2 0x15c3 15BE 56 *JUMP // Stack delta = -1 // Outputs[1] { @15B9 stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block ends with unconditional jump to 0x15c3 label_15BF: // Incoming jump from 0x14DB, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length 15BF 5B JUMPDEST 15C0 50 POP 15C1 60 PUSH1 0x01 // Stack delta = +0 // Outputs[1] { @15C1 stack[-1] = 0x01 } // Block continues label_15C3: // Incoming jump from 0x167A, if !stack[-7] // Incoming jump from 0x15BE // Incoming jump from 0x15C1 // Incoming jump from 0x167A, if !stack[-7] // Incoming jump from 0x167A, if !stack[-5] // Incoming return from call to 0x1A9D at 0x1B5B // Inputs[3] // { // @15C4 stack[-6] // @15C4 stack[-1] // @15C5 stack[-5] // } 15C3 5B JUMPDEST 15C4 94 SWAP5 15C5 93 SWAP4 15C6 50 POP 15C7 50 POP 15C8 50 POP 15C9 50 POP 15CA 56 *JUMP // Stack delta = -5 // Outputs[1] { @15C4 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_15CB: // Incoming call from 0x0E3D, returns to 0x0E3E // Inputs[1] { @15D1 storage[0x09] } 15CB 5B JUMPDEST 15CC 60 PUSH1 0x60 15CE 60 PUSH1 0x09 15D0 80 DUP1 15D1 54 SLOAD 15D2 61 PUSH2 0x0614 15D5 90 SWAP1 15D6 61 PUSH2 0x1c7b 15D9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @15CC stack[0] = 0x60 // @15CE stack[1] = 0x09 // @15D5 stack[2] = 0x0614 // @15D5 stack[3] = storage[0x09] // } // Block ends with call to 0x1c7b, returns to 0x0614 label_15DA: // Incoming call from 0x0E67, returns to 0x0E68 // Inputs[1] { @15DD stack[-1] } 15DA 5B JUMPDEST 15DB 60 PUSH1 0x60 15DD 81 DUP2 15DE 60 PUSH1 0x00 15E0 03 SUB 15E1 61 PUSH2 0x1601 15E4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @15DB stack[0] = 0x60 } // Block ends with conditional jump to 0x1601, if 0x00 - stack[-1] label_15E5: // Incoming jump from 0x15E4, if not 0x00 - stack[-1] // Inputs[2] // { // @15EA memory[0x40:0x60] // @15FF stack[-3] // } 15E5 50 POP 15E6 50 POP 15E7 60 PUSH1 0x40 15E9 80 DUP1 15EA 51 MLOAD 15EB 80 DUP1 15EC 82 DUP3 15ED 01 ADD 15EE 90 SWAP1 15EF 91 SWAP2 15F0 52 MSTORE 15F1 60 PUSH1 0x01 15F3 81 DUP2 15F4 52 MSTORE 15F5 60 PUSH1 0x03 15F7 60 PUSH1 0xfc 15F9 1B SHL 15FA 60 PUSH1 0x20 15FC 82 DUP3 15FD 01 ADD 15FE 52 MSTORE 15FF 90 SWAP1 1600 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @15F0 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @15F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @15FE memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x03 << 0xfc // @15FF stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_1601: // Incoming jump from 0x15E4, if 0x00 - stack[-1] // Inputs[1] { @1602 stack[-2] } 1601 5B JUMPDEST 1602 81 DUP2 1603 60 PUSH1 0x00 1605 5B JUMPDEST 1606 81 DUP2 1607 15 ISZERO 1608 61 PUSH2 0x162b 160B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1602 stack[0] = stack[-2] // @1603 stack[1] = 0x00 // } // Block ends with conditional jump to 0x162b, if !stack[-2] label_160C: // Incoming jump from 0x160B, if not !stack[-2] // Incoming jump from 0x160B, if not !stack[-2] // Inputs[1] { @160C stack[-1] } 160C 80 DUP1 160D 61 PUSH2 0x1615 1610 81 DUP2 1611 61 PUSH2 0x1df4 1614 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @160C stack[0] = stack[-1] // @160D stack[1] = 0x1615 // @1610 stack[2] = stack[-1] // } // Block ends with call to 0x1df4, returns to 0x1615 label_1615: // Incoming return from call to 0x1DF4 at 0x1614 // Inputs[4] // { // @1616 stack[-1] // @1616 stack[-3] // @161B stack[-2] // @161F stack[-4] // } 1615 5B JUMPDEST 1616 91 SWAP2 1617 50 POP 1618 61 PUSH2 0x1624 161B 90 SWAP1 161C 50 POP 161D 60 PUSH1 0x0a 161F 83 DUP4 1620 61 PUSH2 0x1e23 1623 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1616 stack[-3] = stack[-1] // @161B stack[-2] = 0x1624 // @161D stack[-1] = 0x0a // @161F stack[0] = stack[-4] // } // Block ends with call to 0x1e23, returns to 0x1624 label_1624: // Incoming return from call to 0x1E23 at 0x1623 // Inputs[2] // { // @1625 stack[-1] // @1625 stack[-3] // } 1624 5B JUMPDEST 1625 91 SWAP2 1626 50 POP 1627 61 PUSH2 0x1605 162A 56 *JUMP // Stack delta = -1 // Outputs[1] { @1625 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1605 label_162B: // Incoming jump from 0x160B, if !stack[-2] // Incoming jump from 0x160B, if !stack[-2] // Inputs[1] { @162E stack[-1] } 162B 5B JUMPDEST 162C 60 PUSH1 0x00 162E 81 DUP2 162F 67 PUSH8 0xffffffffffffffff 1638 81 DUP2 1639 11 GT 163A 15 ISZERO 163B 61 PUSH2 0x1646 163E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @162C stack[0] = 0x00 // @162E stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1646, if !(stack[-1] > 0xffffffffffffffff) label_163F: // Incoming jump from 0x163E, if not !(stack[-1] > 0xffffffffffffffff) 163F 61 PUSH2 0x1646 1642 61 PUSH2 0x1a87 1645 56 *JUMP // Stack delta = +1 // Outputs[1] { @163F stack[0] = 0x1646 } // Block ends with unconditional jump to 0x1a87 label_1646: // Incoming jump from 0x163E, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @1649 memory[0x40:0x60] // @164A stack[-1] // } 1646 5B JUMPDEST 1647 60 PUSH1 0x40 1649 51 MLOAD 164A 90 SWAP1 164B 80 DUP1 164C 82 DUP3 164D 52 MSTORE 164E 80 DUP1 164F 60 PUSH1 0x1f 1651 01 ADD 1652 60 PUSH1 0x1f 1654 19 NOT 1655 16 AND 1656 60 PUSH1 0x20 1658 01 ADD 1659 82 DUP3 165A 01 ADD 165B 60 PUSH1 0x40 165D 52 MSTORE 165E 80 DUP1 165F 15 ISZERO 1660 61 PUSH2 0x1670 1663 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @164A stack[-1] = memory[0x40:0x60] // @164A stack[0] = stack[-1] // @164D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @165D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x1670, if !stack[-1] label_1664: // Incoming jump from 0x1663, if not !stack[-1] // Inputs[6] // { // @1666 stack[-2] // @1668 stack[-1] // @166A msg.data.length // @166C msg.data[msg.data.length:msg.data.length + stack[-1]] // @1672 stack[-3] // @1675 stack[-7] // } 1664 60 PUSH1 0x20 1666 82 DUP3 1667 01 ADD 1668 81 DUP2 1669 80 DUP1 166A 36 CALLDATASIZE 166B 83 DUP4 166C 37 CALLDATACOPY 166D 01 ADD 166E 90 SWAP1 166F 50 POP 1670 5B JUMPDEST 1671 50 POP 1672 90 SWAP1 1673 50 POP 1674 5B JUMPDEST 1675 84 DUP5 1676 15 ISZERO 1677 61 PUSH2 0x15c3 167A 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @166C memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @1672 stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x15c3, if !stack[-7] label_167B: // Incoming jump from 0x167A, if not !stack[-7] // Incoming jump from 0x167A, if not !stack[-7] // Incoming jump from 0x167A, if not !stack[-5] // Inputs[1] { @1680 stack[-2] } 167B 61 PUSH2 0x1685 167E 60 PUSH1 0x01 1680 83 DUP4 1681 61 PUSH2 0x1e37 1684 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @167B stack[0] = 0x1685 // @167E stack[1] = 0x01 // @1680 stack[2] = stack[-2] // } // Block ends with call to 0x1e37, returns to 0x1685 label_1685: // Incoming return from call to 0x1E37 at 0x1684 // Inputs[3] // { // @1686 stack[-3] // @1686 stack[-1] // @168D stack[-6] // } 1685 5B JUMPDEST 1686 91 SWAP2 1687 50 POP 1688 61 PUSH2 0x1692 168B 60 PUSH1 0x0a 168D 86 DUP7 168E 61 PUSH2 0x1e4e 1691 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1686 stack[-3] = stack[-1] // @1688 stack[-1] = 0x1692 // @168B stack[0] = 0x0a // @168D stack[1] = stack[-6] // } // Block ends with call to 0x1e4e, returns to 0x1692 label_1692: // Incoming return from call to 0x1E4E at 0x1691 // Inputs[1] { @1696 stack[-1] } 1692 5B JUMPDEST 1693 61 PUSH2 0x169d 1696 90 SWAP1 1697 60 PUSH1 0x30 1699 61 PUSH2 0x1d82 169C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1696 stack[0] = stack[-1] // @1696 stack[-1] = 0x169d // @1697 stack[1] = 0x30 // } // Block ends with call to 0x1d82, returns to 0x169D label_169D: // Incoming return from call to 0x1D82 at 0x169C // Inputs[4] // { // @16A0 stack[-1] // @16A1 stack[-2] // @16A2 stack[-3] // @16A4 memory[stack[-2]:stack[-2] + 0x20] // } 169D 5B JUMPDEST 169E 60 PUSH1 0xf8 16A0 1B SHL 16A1 81 DUP2 16A2 83 DUP4 16A3 81 DUP2 16A4 51 MLOAD 16A5 81 DUP2 16A6 10 LT 16A7 61 PUSH2 0x16b2 16AA 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @16A0 stack[-1] = stack[-1] << 0xf8 // @16A1 stack[0] = stack[-2] // @16A2 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x16b2, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_16AB: // Incoming jump from 0x16AA, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] 16AB 61 PUSH2 0x16b2 16AE 61 PUSH2 0x1e62 16B1 56 *JUMP // Stack delta = +1 // Outputs[1] { @16AB stack[0] = 0x16b2 } // Block ends with unconditional jump to 0x1e62 label_16B2: // Incoming jump from 0x16AA, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @16B5 stack[-1] // @16B6 stack[-2] // @16B7 stack[-3] // @16CF stack[-8] // } 16B2 5B JUMPDEST 16B3 60 PUSH1 0x20 16B5 01 ADD 16B6 01 ADD 16B7 90 SWAP1 16B8 60 PUSH1 0x01 16BA 60 PUSH1 0x01 16BC 60 PUSH1 0xf8 16BE 1B SHL 16BF 03 SUB 16C0 19 NOT 16C1 16 AND 16C2 90 SWAP1 16C3 81 DUP2 16C4 60 PUSH1 0x00 16C6 1A BYTE 16C7 90 SWAP1 16C8 53 MSTORE8 16C9 50 POP 16CA 61 PUSH2 0x16d4 16CD 60 PUSH1 0x0a 16CF 86 DUP7 16D0 61 PUSH2 0x1e23 16D3 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @16C8 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @16CA stack[-3] = 0x16d4 // @16CD stack[-2] = 0x0a // @16CF stack[-1] = stack[-8] // } // Block ends with call to 0x1e23, returns to 0x16D4 label_16D4: // Incoming return from call to 0x1E23 at 0x16D3 // Inputs[2] // { // @16D5 stack[-1] // @16D5 stack[-6] // } 16D4 5B JUMPDEST 16D5 94 SWAP5 16D6 50 POP 16D7 61 PUSH2 0x1674 16DA 56 *JUMP // Stack delta = -1 // Outputs[1] { @16D5 stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x1674 label_16DB: // Incoming call from 0x0EDE, returns to 0x0839 // Incoming call from 0x0F97, returns to 0x0F98 // Inputs[4] // { // @16DF stack[-2] // @16E0 stack[-1] // @16E3 memory[0x40:0x60] // @16FB storage[0x00] // } 16DB 5B JUMPDEST 16DC 61 PUSH2 0x0b80 16DF 82 DUP3 16E0 82 DUP3 16E1 60 PUSH1 0x40 16E3 51 MLOAD 16E4 80 DUP1 16E5 60 PUSH1 0x20 16E7 01 ADD 16E8 60 PUSH1 0x40 16EA 52 MSTORE 16EB 80 DUP1 16EC 60 PUSH1 0x00 16EE 81 DUP2 16EF 52 MSTORE 16F0 50 POP 16F1 61 PUSH2 0x0839 16F4 83 DUP4 16F5 83 DUP4 16F6 83 DUP4 16F7 60 PUSH1 0x01 16F9 60 PUSH1 0x00 16FB 54 SLOAD 16FC 60 PUSH1 0x01 16FE 60 PUSH1 0x01 1700 60 PUSH1 0xa0 1702 1B SHL 1703 03 SUB 1704 85 DUP6 1705 16 AND 1706 61 PUSH2 0x175b 1709 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @16DC stack[0] = 0x0b80 // @16DF stack[1] = stack[-2] // @16E0 stack[2] = stack[-1] // @16E3 stack[3] = memory[0x40:0x60] // @16EA memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @16EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @16F1 stack[4] = 0x0839 // @16F4 stack[5] = stack[-2] // @16F5 stack[6] = stack[-1] // @16F6 stack[7] = memory[0x40:0x60] // @16F7 stack[8] = 0x01 // @16FB stack[9] = storage[0x00] // } // Block ends with conditional call to 0x175b, returns to 0x0839, if stack[-2] & (0x01 << 0xa0) - 0x01 label_170A: // Incoming jump from 0x1709, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @170C memory[0x40:0x60] } 170A 60 PUSH1 0x40 170C 51 MLOAD 170D 62 PUSH3 0x461bcd 1711 60 PUSH1 0xe5 1713 1B SHL 1714 81 DUP2 1715 52 MSTORE 1716 60 PUSH1 0x20 1718 60 PUSH1 0x04 171A 82 DUP3 171B 01 ADD 171C 52 MSTORE 171D 60 PUSH1 0x21 171F 60 PUSH1 0x24 1721 82 DUP3 1722 01 ADD 1723 52 MSTORE 1724 7F PUSH32 0x455243373231413a206d696e7420746f20746865207a65726f20616464726573 1745 60 PUSH1 0x44 1747 82 DUP3 1748 01 ADD 1749 52 MSTORE 174A 60 PUSH1 0x73 174C 60 PUSH1 0xf8 174E 1B SHL 174F 60 PUSH1 0x64 1751 82 DUP3 1752 01 ADD 1753 52 MSTORE 1754 60 PUSH1 0x84 1756 01 ADD 1757 61 PUSH2 0x0702 175A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1715 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @171C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1723 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @1749 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a206d696e7420746f20746865207a65726f20616464726573 // @1753 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x73 << 0xf8 // @1756 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0702 label_175B: // Incoming call from 0x1709, returns to 0x0839, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @175C stack[-4] } 175B 5B JUMPDEST 175C 83 DUP4 175D 60 PUSH1 0x00 175F 03 SUB 1760 61 PUSH2 0x17bc 1763 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17bc, if 0x00 - stack[-4] label_1764: // Incoming jump from 0x1763, if not 0x00 - stack[-4] // Inputs[1] { @1766 memory[0x40:0x60] } 1764 60 PUSH1 0x40 1766 51 MLOAD 1767 62 PUSH3 0x461bcd 176B 60 PUSH1 0xe5 176D 1B SHL 176E 81 DUP2 176F 52 MSTORE 1770 60 PUSH1 0x20 1772 60 PUSH1 0x04 1774 82 DUP3 1775 01 ADD 1776 52 MSTORE 1777 60 PUSH1 0x28 1779 60 PUSH1 0x24 177B 82 DUP3 177C 01 ADD 177D 52 MSTORE 177E 7F PUSH32 0x455243373231413a207175616e74697479206d75737420626520677265617465 179F 60 PUSH1 0x44 17A1 82 DUP3 17A2 01 ADD 17A3 52 MSTORE 17A4 67 PUSH8 0x072207468616e203 17AD 60 PUSH1 0xc4 17AF 1B SHL 17B0 60 PUSH1 0x64 17B2 82 DUP3 17B3 01 ADD 17B4 52 MSTORE 17B5 60 PUSH1 0x84 17B7 01 ADD 17B8 61 PUSH2 0x0702 17BB 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @176F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1776 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @177D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x28 // @17A3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a207175616e74697479206d75737420626520677265617465 // @17B4 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x072207468616e203 << 0xc4 // @17B7 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0702 label_17BC: // Incoming jump from 0x1763, if 0x00 - stack[-4] // Inputs[8] // { // @17C5 stack[-5] // @17D7 memory[0x00:0x40] // @17D9 storage[keccak256(memory[0x00:0x40])] // @17F5 stack[-4] // @180A stack[-1] // @1813 memory[0x00:0x40] // @1815 storage[keccak256(memory[0x00:0x40])] // @1828 block.timestamp // } 17BC 5B JUMPDEST 17BD 60 PUSH1 0x01 17BF 60 PUSH1 0x01 17C1 60 PUSH1 0xa0 17C3 1B SHL 17C4 03 SUB 17C5 85 DUP6 17C6 16 AND 17C7 60 PUSH1 0x00 17C9 81 DUP2 17CA 81 DUP2 17CB 52 MSTORE 17CC 60 PUSH1 0x04 17CE 60 PUSH1 0x20 17D0 90 SWAP1 17D1 81 DUP2 17D2 52 MSTORE 17D3 60 PUSH1 0x40 17D5 80 DUP1 17D6 83 DUP4 17D7 20 SHA3 17D8 80 DUP1 17D9 54 SLOAD 17DA 60 PUSH1 0x01 17DC 60 PUSH1 0x80 17DE 1B SHL 17DF 60 PUSH1 0x01 17E1 60 PUSH1 0x01 17E3 60 PUSH1 0x80 17E5 1B SHL 17E6 03 SUB 17E7 19 NOT 17E8 82 DUP3 17E9 16 AND 17EA 60 PUSH1 0x01 17EC 60 PUSH1 0x01 17EE 60 PUSH1 0x80 17F0 1B SHL 17F1 03 SUB 17F2 92 SWAP3 17F3 83 DUP4 17F4 16 AND 17F5 8C DUP13 17F6 01 ADD 17F7 83 DUP4 17F8 16 AND 17F9 90 SWAP1 17FA 81 DUP2 17FB 17 OR 17FC 82 DUP3 17FD 90 SWAP1 17FE 04 DIV 17FF 83 DUP4 1800 16 AND 1801 8C DUP13 1802 01 ADD 1803 90 SWAP1 1804 92 SWAP3 1805 16 AND 1806 02 MUL 1807 17 OR 1808 90 SWAP1 1809 55 SSTORE 180A 84 DUP5 180B 83 DUP4 180C 52 MSTORE 180D 60 PUSH1 0x03 180F 90 SWAP1 1810 91 SWAP2 1811 52 MSTORE 1812 81 DUP2 1813 20 SHA3 1814 80 DUP1 1815 54 SLOAD 1816 60 PUSH1 0x01 1818 60 PUSH1 0x01 181A 60 PUSH1 0xe0 181C 1B SHL 181D 03 SUB 181E 19 NOT 181F 16 AND 1820 90 SWAP1 1821 92 SWAP3 1822 17 OR 1823 60 PUSH1 0x01 1825 60 PUSH1 0xa0 1827 1B SHL 1828 42 TIMESTAMP 1829 67 PUSH8 0xffffffffffffffff 1832 16 AND 1833 02 MUL 1834 17 OR 1835 90 SWAP1 1836 91 SWAP2 1837 55 SSTORE 1838 81 DUP2 1839 90 SWAP1 183A 5B JUMPDEST 183B 85 DUP6 183C 81 DUP2 183D 10 LT 183E 15 ISZERO 183F 61 PUSH2 0x18b5 1842 57 *JUMPI // Stack delta = +2 // Outputs[8] // { // @17CB memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @17D2 memory[0x20:0x40] = 0x04 // @1809 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x80) - 0x01 & stack[-4] + ((0x01 << 0x80) - 0x01 & (((0x01 << 0x80) - 0x01 & stack[-4] + ((0x01 << 0x80) - 0x01 & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~((0x01 << 0x80) - 0x01))) / (0x01 << 0x80))) * (0x01 << 0x80) | ((0x01 << 0x80) - 0x01 & stack[-4] + ((0x01 << 0x80) - 0x01 & storage[keccak256(memory[0x00:0x40])])) // @180C memory[0x00:0x20] = stack[-1] // @1811 memory[0x20:0x40] = 0x03 // @1837 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1839 stack[0] = stack[-1] // @1839 stack[1] = 0x00 // } // Block ends with conditional jump to 0x18b5, if !(0x00 < stack[-4]) label_1843: // Incoming call from 0x1842, returns to 0x0000, if not !(0x00 < stack[-4]) // Incoming jump from 0x1842, if not !(stack[-1] < stack[-6]) // Inputs[5] // { // @1845 memory[0x40:0x60] // @1846 stack[-2] // @1850 stack[-7] // @187A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @187B stack[-4] // } 1843 60 PUSH1 0x40 1845 51 MLOAD 1846 82 DUP3 1847 90 SWAP1 1848 60 PUSH1 0x01 184A 60 PUSH1 0x01 184C 60 PUSH1 0xa0 184E 1B SHL 184F 03 SUB 1850 89 DUP10 1851 16 AND 1852 90 SWAP1 1853 60 PUSH1 0x00 1855 90 SWAP1 1856 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1877 90 SWAP1 1878 82 DUP3 1879 90 SWAP1 187A A4 LOG4 187B 83 DUP4 187C 15 ISZERO 187D 61 PUSH2 0x18a9 1880 57 *JUMPI // Stack delta = +0 // Outputs[1] { @187A log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); } // Block ends with conditional jump to 0x18a9, if !stack[-4] label_1881: // Incoming jump from 0x1880, if not !stack[-4] // Inputs[3] // { // @1886 stack[-7] // @1887 stack[-2] // @1888 stack[-5] // } 1881 61 PUSH2 0x188d 1884 60 PUSH1 0x00 1886 88 DUP9 1887 84 DUP5 1888 88 DUP9 1889 61 PUSH2 0x14c9 188C 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1881 stack[0] = 0x188d // @1884 stack[1] = 0x00 // @1886 stack[2] = stack[-7] // @1887 stack[3] = stack[-2] // @1888 stack[4] = stack[-5] // } // Block ends with call to 0x14c9, returns to 0x188D label_188D: // Incoming return from call to 0x14C9 at 0x188C // Inputs[1] { @1891 stack[-1] } 188D 5B JUMPDEST 188E 61 PUSH2 0x18a9 1891 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x18a9, if stack[-1] label_1892: // Incoming jump from 0x1891, if not stack[-1] // Inputs[1] { @1894 memory[0x40:0x60] } 1892 60 PUSH1 0x40 1894 51 MLOAD 1895 62 PUSH3 0x461bcd 1899 60 PUSH1 0xe5 189B 1B SHL 189C 81 DUP2 189D 52 MSTORE 189E 60 PUSH1 0x04 18A0 01 ADD 18A1 61 PUSH2 0x0702 18A4 90 SWAP1 18A5 61 PUSH2 0x1cea 18A8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @189D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @18A4 stack[0] = 0x0702 // @18A4 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1cea, returns to 0x0702 label_18A9: // Incoming jump from 0x1891, if stack[-1] // Incoming jump from 0x1880, if !stack[-4] // Inputs[2] // { // @18AC stack[-2] // @18B0 stack[-1] // } 18A9 5B JUMPDEST 18AA 60 PUSH1 0x01 18AC 91 SWAP2 18AD 82 DUP3 18AE 01 ADD 18AF 91 SWAP2 18B0 01 ADD 18B1 61 PUSH2 0x183a 18B4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @18AF stack[-2] = 0x01 + stack[-2] // @18B0 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x183a label_18B5: // Incoming jump from 0x1842, if !(0x00 < stack[-4]) // Incoming jump from 0x1842, if !(stack[-1] < stack[-6]) // Inputs[1] { @18B9 stack[-2] } 18B5 5B JUMPDEST 18B6 50 POP 18B7 60 PUSH1 0x00 18B9 55 SSTORE 18BA 61 PUSH2 0x1399 18BD 56 *JUMP // Stack delta = -2 // Outputs[1] { @18B9 storage[0x00] = stack[-2] } // Block ends with unconditional jump to 0x1399 label_18BE: // Incoming jump from 0x0B7F // Inputs[2] // { // @18BF stack[-3] // @18C1 storage[stack[-3]] // } 18BE 5B JUMPDEST 18BF 82 DUP3 18C0 80 DUP1 18C1 54 SLOAD 18C2 61 PUSH2 0x18ca 18C5 90 SWAP1 18C6 61 PUSH2 0x1c7b 18C9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @18BF stack[0] = stack[-3] // @18C5 stack[1] = 0x18ca // @18C5 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x1c7b, returns to 0x18CA label_18CA: // Incoming return from call to 0x1C7B at 0x18C9 // Inputs[5] // { // @18CB stack[-1] // @18CB stack[-2] // @18D3 memory[0x00:0x20] // @18DE stack[-4] // @18DF stack[-3] // } 18CA 5B JUMPDEST 18CB 90 SWAP1 18CC 60 PUSH1 0x00 18CE 52 MSTORE 18CF 60 PUSH1 0x20 18D1 60 PUSH1 0x00 18D3 20 SHA3 18D4 90 SWAP1 18D5 60 PUSH1 0x1f 18D7 01 ADD 18D8 60 PUSH1 0x20 18DA 90 SWAP1 18DB 04 DIV 18DC 81 DUP2 18DD 01 ADD 18DE 92 SWAP3 18DF 82 DUP3 18E0 61 PUSH2 0x18ec 18E3 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @18CE memory[0x00:0x20] = stack[-2] // @18D4 stack[-2] = keccak256(memory[0x00:0x20]) // @18DE stack[-1] = stack[-4] // @18DE stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x18ec, if stack[-3] label_18E4: // Incoming jump from 0x18E3, if not stack[-3] // Inputs[1] { @18E6 stack[-5] } 18E4 60 PUSH1 0x00 18E6 85 DUP6 18E7 55 SSTORE 18E8 61 PUSH2 0x1932 18EB 56 *JUMP // Stack delta = +0 // Outputs[1] { @18E7 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x1932 label_18EC: // Incoming jump from 0x18E3, if stack[-3] // Inputs[1] { @18ED stack[-3] } 18EC 5B JUMPDEST 18ED 82 DUP3 18EE 60 PUSH1 0x1f 18F0 10 LT 18F1 61 PUSH2 0x1905 18F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1905, if 0x1f < stack[-3] label_18F5: // Incoming jump from 0x18F4, if not 0x1f < stack[-3] // Inputs[4] // { // @18F5 stack[-1] // @18F6 memory[stack[-1]:stack[-1] + 0x20] // @18FB stack[-3] // @18FF stack[-5] // } 18F5 80 DUP1 18F6 51 MLOAD 18F7 60 PUSH1 0xff 18F9 19 NOT 18FA 16 AND 18FB 83 DUP4 18FC 80 DUP1 18FD 01 ADD 18FE 17 OR 18FF 85 DUP6 1900 55 SSTORE 1901 61 PUSH2 0x1932 1904 56 *JUMP // Stack delta = +0 // Outputs[1] { @1900 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x1932 label_1905: // Incoming jump from 0x18F4, if 0x1f < stack[-3] // Inputs[2] // { // @1906 stack[-3] // @190C stack[-5] // } 1905 5B JUMPDEST 1906 82 DUP3 1907 80 DUP1 1908 01 ADD 1909 60 PUSH1 0x01 190B 01 ADD 190C 85 DUP6 190D 55 SSTORE 190E 82 DUP3 190F 15 ISZERO 1910 61 PUSH2 0x1932 1913 57 *JUMPI // Stack delta = +0 // Outputs[1] { @190D storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1932, if !stack[-3] label_1914: // Incoming jump from 0x1913, if not !stack[-3] // Inputs[2] // { // @1914 stack[-1] // @1914 stack[-3] // } 1914 91 SWAP2 1915 82 DUP3 1916 01 ADD 1917 5B JUMPDEST 1918 82 DUP3 1919 81 DUP2 191A 11 GT 191B 15 ISZERO 191C 61 PUSH2 0x1932 191F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1914 stack[-3] = stack[-1] // @1916 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1932, if !(stack[-1] + stack[-3] > stack[-1]) label_1920: // Incoming jump from 0x191F, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x191F, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @1920 stack[-3] // @1921 memory[stack[-3]:stack[-3] + 0x20] // @1922 stack[-2] // @1924 stack[-1] // } 1920 82 DUP3 1921 51 MLOAD 1922 82 DUP3 1923 55 SSTORE 1924 91 SWAP2 1925 60 PUSH1 0x20 1927 01 ADD 1928 91 SWAP2 1929 90 SWAP1 192A 60 PUSH1 0x01 192C 01 ADD 192D 90 SWAP1 192E 61 PUSH2 0x1917 1931 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1923 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1928 stack[-3] = 0x20 + stack[-3] // @192D stack[-2] = 0x01 + stack[-2] // @192D stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1917 label_1932: // Incoming jump from 0x191F, if !(stack[-1] > stack[-3]) // Incoming jump from 0x1904 // Incoming jump from 0x191F, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x18EB // Incoming jump from 0x1913, if !stack[-3] // Inputs[3] // { // @1937 stack[-4] // @1938 stack[-3] // @193B stack[-2] // } 1932 5B JUMPDEST 1933 50 POP 1934 61 PUSH2 0x0b2d 1937 92 SWAP3 1938 91 SWAP2 1939 50 POP 193A 5B JUMPDEST 193B 80 DUP1 193C 82 DUP3 193D 11 GT 193E 15 ISZERO 193F 61 PUSH2 0x0b2d 1942 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1937 stack[-4] = 0x0b2d // @1938 stack[-3] = stack[-4] // } // Block ends with conditional call to 0x0b2d, returns to 0x0B2D, if !(stack[-4] > stack[-2]) label_1943: // Incoming jump from 0x1942, if not !(stack[-4] > stack[-2]) // Incoming jump from 0x1942, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1945 stack[-1] } 1943 60 PUSH1 0x00 1945 81 DUP2 1946 55 SSTORE 1947 60 PUSH1 0x01 1949 01 ADD 194A 61 PUSH2 0x193a 194D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1946 storage[stack[-1]] = 0x00 // @1949 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x193a label_194E: // Incoming call from 0x1980, returns to 0x0E89 // Incoming call from 0x1DF3, returns to 0x0E89 // Inputs[1] { @1958 stack[-1] } 194E 5B JUMPDEST 194F 60 PUSH1 0x01 1951 60 PUSH1 0x01 1953 60 PUSH1 0xe0 1955 1B SHL 1956 03 SUB 1957 19 NOT 1958 81 DUP2 1959 16 AND 195A 81 DUP2 195B 14 EQ 195C 61 PUSH2 0x0ab1 195F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ab1, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1960: // Incoming jump from 0x195F, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1963 memory[0x00:0x00] } 1960 60 PUSH1 0x00 1962 80 DUP1 1963 FD *REVERT // Stack delta = +0 // Outputs[1] { @1963 revert(memory[0x00:0x00]); } // Block terminates label_1964: // Incoming call from 0x01EC, returns to 0x01ED // Inputs[2] // { // @1969 stack[-1] // @196A stack[-2] // } 1964 5B JUMPDEST 1965 60 PUSH1 0x00 1967 60 PUSH1 0x20 1969 82 DUP3 196A 84 DUP5 196B 03 SUB 196C 12 SLT 196D 15 ISZERO 196E 61 PUSH2 0x1976 1971 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1965 stack[0] = 0x00 } // Block ends with conditional jump to 0x1976, if !(stack[-2] - stack[-1] i< 0x20) label_1972: // Incoming jump from 0x1971, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1975 memory[0x00:0x00] } 1972 60 PUSH1 0x00 1974 80 DUP1 1975 FD *REVERT // Stack delta = +0 // Outputs[1] { @1975 revert(memory[0x00:0x00]); } // Block terminates label_1976: // Incoming jump from 0x1971, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1977 stack[-2] // @1978 msg.data[stack[-2]:stack[-2] + 0x20] // } 1976 5B JUMPDEST 1977 81 DUP2 1978 35 CALLDATALOAD 1979 61 PUSH2 0x0e89 197C 81 DUP2 197D 61 PUSH2 0x194e 1980 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1978 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1979 stack[1] = 0x0e89 // @197C stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x194e, returns to 0x0E89 label_1981: // Incoming call from 0x1D62, returns to 0x1D63 // Incoming call from 0x1D4E, returns to 0x1D4F // Incoming call from 0x19C4, returns to 0x19C5 // Inputs[1] { @1985 stack[-3] } 1981 5B JUMPDEST 1982 60 PUSH1 0x00 1984 5B JUMPDEST 1985 83 DUP4 1986 81 DUP2 1987 10 LT 1988 15 ISZERO 1989 61 PUSH2 0x199c 198C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1982 stack[0] = 0x00 } // Block ends with conditional jump to 0x199c, if !(0x00 < stack[-3]) label_198D: // Incoming jump from 0x198C, if not !(0x00 < stack[-3]) // Incoming jump from 0x198C, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @198D stack[-2] // @198E stack[-1] // @1990 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1991 stack[-3] // } 198D 81 DUP2 198E 81 DUP2 198F 01 ADD 1990 51 MLOAD 1991 83 DUP4 1992 82 DUP3 1993 01 ADD 1994 52 MSTORE 1995 60 PUSH1 0x20 1997 01 ADD 1998 61 PUSH2 0x1984 199B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1994 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1997 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1984 label_199C: // Incoming jump from 0x198C, if !(0x00 < stack[-3]) // Incoming jump from 0x198C, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @199D stack[-4] // @199E stack[-1] // } 199C 5B JUMPDEST 199D 83 DUP4 199E 81 DUP2 199F 11 GT 19A0 15 ISZERO 19A1 61 PUSH2 0x0dbd 19A4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dbd, if !(stack[-1] > stack[-4]) label_19A5: // Incoming jump from 0x19A4, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @19A9 stack[-4] // @19AA stack[-3] // @19AC stack[-5] // } 19A5 50 POP 19A6 50 POP 19A7 60 PUSH1 0x00 19A9 91 SWAP2 19AA 01 ADD 19AB 52 MSTORE 19AC 56 *JUMP // Stack delta = -5 // Outputs[1] { @19AB memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_19AD: // Incoming call from 0x19EB, returns to 0x0E89 // Incoming call from 0x1DCC, returns to 0x1DCD // Inputs[3] // { // @19B0 stack[-1] // @19B1 memory[stack[-1]:stack[-1] + 0x20] // @19B3 stack[-2] // } 19AD 5B JUMPDEST 19AE 60 PUSH1 0x00 19B0 81 DUP2 19B1 51 MLOAD 19B2 80 DUP1 19B3 84 DUP5 19B4 52 MSTORE 19B5 61 PUSH2 0x19c5 19B8 81 DUP2 19B9 60 PUSH1 0x20 19BB 86 DUP7 19BC 01 ADD 19BD 60 PUSH1 0x20 19BF 86 DUP7 19C0 01 ADD 19C1 61 PUSH2 0x1981 19C4 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @19AE stack[0] = 0x00 // @19B1 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @19B4 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @19B5 stack[2] = 0x19c5 // @19B8 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @19BC stack[4] = stack[-2] + 0x20 // @19C0 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x1981, returns to 0x19C5 label_19C5: // Incoming return from call to 0x1981 at 0x19C4 // Inputs[4] // { // @19C8 stack[-1] // @19CD stack[-4] // @19CE stack[-2] // @19D4 stack[-5] // } 19C5 5B JUMPDEST 19C6 60 PUSH1 0x1f 19C8 01 ADD 19C9 60 PUSH1 0x1f 19CB 19 NOT 19CC 16 AND 19CD 92 SWAP3 19CE 90 SWAP1 19CF 92 SWAP3 19D0 01 ADD 19D1 60 PUSH1 0x20 19D3 01 ADD 19D4 92 SWAP3 19D5 91 SWAP2 19D6 50 POP 19D7 50 POP 19D8 56 *JUMP // Stack delta = -4 // Outputs[1] { @19D4 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_19D9: // Incoming jump from 0x0228 // Inputs[2] // { // @19DC stack[-1] // @19E7 stack[-2] // } 19D9 5B JUMPDEST 19DA 60 PUSH1 0x20 19DC 81 DUP2 19DD 52 MSTORE 19DE 60 PUSH1 0x00 19E0 61 PUSH2 0x0e89 19E3 60 PUSH1 0x20 19E5 83 DUP4 19E6 01 ADD 19E7 84 DUP5 19E8 61 PUSH2 0x19ad 19EB 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @19DD memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @19DE stack[0] = 0x00 // @19E0 stack[1] = 0x0e89 // @19E6 stack[2] = stack[-1] + 0x20 // @19E7 stack[3] = stack[-2] // } // Block ends with call to 0x19ad, returns to 0x0E89 label_19EC: // Incoming call from 0x036F, returns to 0x0370 // Incoming call from 0x0243, returns to 0x0244 // Incoming call from 0x034F, returns to 0x0350 // Incoming call from 0x03E4, returns to 0x03E5 // Incoming call from 0x04DE, returns to 0x04DF // Inputs[2] // { // @19F1 stack[-1] // @19F2 stack[-2] // } 19EC 5B JUMPDEST 19ED 60 PUSH1 0x00 19EF 60 PUSH1 0x20 19F1 82 DUP3 19F2 84 DUP5 19F3 03 SUB 19F4 12 SLT 19F5 15 ISZERO 19F6 61 PUSH2 0x19fe 19F9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @19ED stack[0] = 0x00 } // Block ends with conditional jump to 0x19fe, if !(stack[-2] - stack[-1] i< 0x20) label_19FA: // Incoming jump from 0x19F9, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @19FD memory[0x00:0x00] } 19FA 60 PUSH1 0x00 19FC 80 DUP1 19FD FD *REVERT // Stack delta = +0 // Outputs[1] { @19FD revert(memory[0x00:0x00]); } // Block terminates label_19FE: // Incoming jump from 0x19F9, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1A00 stack[-2] // @1A00 msg.data[stack[-2]:stack[-2] + 0x20] // @1A01 stack[-4] // @1A02 stack[-3] // } 19FE 5B JUMPDEST 19FF 50 POP 1A00 35 CALLDATALOAD 1A01 91 SWAP2 1A02 90 SWAP1 1A03 50 POP 1A04 56 *JUMP // Stack delta = -3 // Outputs[1] { @1A01 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1A05: // Incoming call from 0x1A76, returns to 0x1A77 // Incoming call from 0x1A68, returns to 0x1A69 // Incoming call from 0x1B76, returns to 0x0E89 // Incoming call from 0x1BBD, returns to 0x1BBE // Incoming call from 0x1C01, returns to 0x1C02 // Incoming call from 0x1A3C, returns to 0x1A3D // Incoming call from 0x1C6C, returns to 0x1C6D // Incoming call from 0x1C7A, returns to 0x1BCC // Incoming call from 0x1BF3, returns to 0x1BF4 // Inputs[2] // { // @1A06 stack[-1] // @1A07 msg.data[stack[-1]:stack[-1] + 0x20] // } 1A05 5B JUMPDEST 1A06 80 DUP1 1A07 35 CALLDATALOAD 1A08 60 PUSH1 0x01 1A0A 60 PUSH1 0x01 1A0C 60 PUSH1 0xa0 1A0E 1B SHL 1A0F 03 SUB 1A10 81 DUP2 1A11 16 AND 1A12 81 DUP2 1A13 14 EQ 1A14 61 PUSH2 0x1a1c 1A17 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A07 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1a1c, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_1A18: // Incoming jump from 0x1A17, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1A1B memory[0x00:0x00] } 1A18 60 PUSH1 0x00 1A1A 80 DUP1 1A1B FD *REVERT // Stack delta = +0 // Outputs[1] { @1A1B revert(memory[0x00:0x00]); } // Block terminates label_1A1C: // Incoming jump from 0x1A17, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x1B82, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @1A1D stack[-3] // @1A1D stack[-1] // @1A1E stack[-2] // } 1A1C 5B JUMPDEST 1A1D 91 SWAP2 1A1E 90 SWAP1 1A1F 50 POP 1A20 56 *JUMP // Stack delta = -2 // Outputs[1] { @1A1D stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1A21: // Incoming call from 0x02F2, returns to 0x02F3 // Incoming call from 0x027B, returns to 0x027C // Incoming call from 0x0514, returns to 0x0515 // Inputs[2] // { // @1A27 stack[-1] // @1A28 stack[-2] // } 1A21 5B JUMPDEST 1A22 60 PUSH1 0x00 1A24 80 DUP1 1A25 60 PUSH1 0x40 1A27 83 DUP4 1A28 85 DUP6 1A29 03 SUB 1A2A 12 SLT 1A2B 15 ISZERO 1A2C 61 PUSH2 0x1a34 1A2F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A22 stack[0] = 0x00 // @1A24 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1a34, if !(stack[-2] - stack[-1] i< 0x40) label_1A30: // Incoming jump from 0x1A2F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1A33 memory[0x00:0x00] } 1A30 60 PUSH1 0x00 1A32 80 DUP1 1A33 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A33 revert(memory[0x00:0x00]); } // Block terminates label_1A34: // Incoming jump from 0x1A2F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1A38 stack[-3] } 1A34 5B JUMPDEST 1A35 61 PUSH2 0x1a3d 1A38 83 DUP4 1A39 61 PUSH2 0x1a05 1A3C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A35 stack[0] = 0x1a3d // @1A38 stack[1] = stack[-3] // } // Block ends with call to 0x1a05, returns to 0x1A3D label_1A3D: // Incoming return from call to 0x1A05 at 0x1A3C // Inputs[5] // { // @1A3E stack[-1] // @1A3E stack[-6] // @1A41 stack[-4] // @1A45 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1A46 stack[-5] // } 1A3D 5B JUMPDEST 1A3E 94 SWAP5 1A3F 60 PUSH1 0x20 1A41 93 SWAP4 1A42 90 SWAP1 1A43 93 SWAP4 1A44 01 ADD 1A45 35 CALLDATALOAD 1A46 93 SWAP4 1A47 50 POP 1A48 50 POP 1A49 50 POP 1A4A 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1A3E stack[-6] = stack[-1] // @1A46 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_1A4B: // Incoming call from 0x032F, returns to 0x0330 // Incoming call from 0x02BC, returns to 0x02BD // Inputs[2] // { // @1A53 stack[-1] // @1A54 stack[-2] // } 1A4B 5B JUMPDEST 1A4C 60 PUSH1 0x00 1A4E 80 DUP1 1A4F 60 PUSH1 0x00 1A51 60 PUSH1 0x60 1A53 84 DUP5 1A54 86 DUP7 1A55 03 SUB 1A56 12 SLT 1A57 15 ISZERO 1A58 61 PUSH2 0x1a60 1A5B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1A4C stack[0] = 0x00 // @1A4E stack[1] = 0x00 // @1A4F stack[2] = 0x00 // } // Block ends with conditional jump to 0x1a60, if !(stack[-2] - stack[-1] i< 0x60) label_1A5C: // Incoming jump from 0x1A5B, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1A5F memory[0x00:0x00] } 1A5C 60 PUSH1 0x00 1A5E 80 DUP1 1A5F FD *REVERT // Stack delta = +0 // Outputs[1] { @1A5F revert(memory[0x00:0x00]); } // Block terminates label_1A60: // Incoming jump from 0x1A5B, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1A64 stack[-4] } 1A60 5B JUMPDEST 1A61 61 PUSH2 0x1a69 1A64 84 DUP5 1A65 61 PUSH2 0x1a05 1A68 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A61 stack[0] = 0x1a69 // @1A64 stack[1] = stack[-4] // } // Block ends with call to 0x1a05, returns to 0x1A69 label_1A69: // Incoming return from call to 0x1A05 at 0x1A68 // Inputs[3] // { // @1A6A stack[-1] // @1A6A stack[-4] // @1A71 stack[-5] // } 1A69 5B JUMPDEST 1A6A 92 SWAP3 1A6B 50 POP 1A6C 61 PUSH2 0x1a77 1A6F 60 PUSH1 0x20 1A71 85 DUP6 1A72 01 ADD 1A73 61 PUSH2 0x1a05 1A76 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1A6A stack[-4] = stack[-1] // @1A6C stack[-1] = 0x1a77 // @1A72 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x1a05, returns to 0x1A77 label_1A77: // Incoming return from call to 0x1A05 at 0x1A76 // Inputs[8] // { // @1A78 stack[-1] // @1A78 stack[-3] // @1A7C stack[-5] // @1A7E msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1A7F stack[-2] // @1A83 stack[-6] // @1A85 stack[-4] // @1A85 stack[-7] // } 1A77 5B JUMPDEST 1A78 91 SWAP2 1A79 50 POP 1A7A 60 PUSH1 0x40 1A7C 84 DUP5 1A7D 01 ADD 1A7E 35 CALLDATALOAD 1A7F 90 SWAP1 1A80 50 POP 1A81 92 SWAP3 1A82 50 POP 1A83 92 SWAP3 1A84 50 POP 1A85 92 SWAP3 1A86 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1A81 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1A83 stack[-6] = stack[-1] // @1A85 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1A87: // Incoming jump from 0x1ADF // Incoming jump from 0x1645 // Incoming jump from 0x1AB7 // Inputs[1] { @1A9C memory[0x00:0x24] } 1A87 5B JUMPDEST 1A88 63 PUSH4 0x4e487b71 1A8D 60 PUSH1 0xe0 1A8F 1B SHL 1A90 60 PUSH1 0x00 1A92 52 MSTORE 1A93 60 PUSH1 0x41 1A95 60 PUSH1 0x04 1A97 52 MSTORE 1A98 60 PUSH1 0x24 1A9A 60 PUSH1 0x00 1A9C FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1A92 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1A97 memory[0x04:0x24] = 0x41 // @1A9C revert(memory[0x00:0x24]); // } // Block terminates label_1A9D: // Incoming call from 0x1C44, returns to 0x1C45 // Incoming call from 0x1B5B, returns to 0x15C3 // Inputs[1] { @1AAA stack[-2] } 1A9D 5B JUMPDEST 1A9E 60 PUSH1 0x00 1AA0 67 PUSH8 0xffffffffffffffff 1AA9 80 DUP1 1AAA 84 DUP5 1AAB 11 GT 1AAC 15 ISZERO 1AAD 61 PUSH2 0x1ab8 1AB0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A9E stack[0] = 0x00 // @1AA0 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1ab8, if !(stack[-2] > 0xffffffffffffffff) label_1AB1: // Incoming jump from 0x1AB0, if not !(stack[-2] > 0xffffffffffffffff) 1AB1 61 PUSH2 0x1ab8 1AB4 61 PUSH2 0x1a87 1AB7 56 *JUMP // Stack delta = +1 // Outputs[1] { @1AB1 stack[0] = 0x1ab8 } // Block ends with unconditional jump to 0x1a87 label_1AB8: // Incoming jump from 0x1AB0, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @1ABB memory[0x40:0x60] // @1ABE stack[-4] // @1ACD stack[-1] // } 1AB8 5B JUMPDEST 1AB9 60 PUSH1 0x40 1ABB 51 MLOAD 1ABC 60 PUSH1 0x1f 1ABE 85 DUP6 1ABF 01 ADD 1AC0 60 PUSH1 0x1f 1AC2 19 NOT 1AC3 90 SWAP1 1AC4 81 DUP2 1AC5 16 AND 1AC6 60 PUSH1 0x3f 1AC8 01 ADD 1AC9 16 AND 1ACA 81 DUP2 1ACB 01 ADD 1ACC 90 SWAP1 1ACD 82 DUP3 1ACE 82 DUP3 1ACF 11 GT 1AD0 81 DUP2 1AD1 83 DUP4 1AD2 10 LT 1AD3 17 OR 1AD4 15 ISZERO 1AD5 61 PUSH2 0x1ae0 1AD8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1ACC stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @1ACC stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x1ae0, 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_1AD9: // Incoming jump from 0x1AD8, 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])) 1AD9 61 PUSH2 0x1ae0 1ADC 61 PUSH2 0x1a87 1ADF 56 *JUMP // Stack delta = +1 // Outputs[1] { @1AD9 stack[0] = 0x1ae0 } // Block ends with unconditional jump to 0x1a87 label_1AE0: // Incoming jump from 0x1AD8, 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] // { // @1AE1 stack[-2] // @1AE5 stack[-1] // @1AE6 stack[-4] // @1AE8 stack[-6] // @1AEB stack[-7] // @1AED stack[-5] // } 1AE0 5B JUMPDEST 1AE1 81 DUP2 1AE2 60 PUSH1 0x40 1AE4 52 MSTORE 1AE5 80 DUP1 1AE6 93 SWAP4 1AE7 50 POP 1AE8 85 DUP6 1AE9 81 DUP2 1AEA 52 MSTORE 1AEB 86 DUP7 1AEC 86 DUP7 1AED 86 DUP7 1AEE 01 ADD 1AEF 11 GT 1AF0 15 ISZERO 1AF1 61 PUSH2 0x1af9 1AF4 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1AE4 memory[0x40:0x60] = stack[-2] // @1AE6 stack[-4] = stack[-1] // @1AEA memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x1af9, if !(stack[-5] + stack[-6] > stack[-7]) label_1AF5: // Incoming jump from 0x1AF4, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @1AF8 memory[0x00:0x00] } 1AF5 60 PUSH1 0x00 1AF7 80 DUP1 1AF8 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AF8 revert(memory[0x00:0x00]); } // Block terminates label_1AF9: // Incoming jump from 0x1AF4, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @1AFA stack[-6] // @1AFB stack[-5] // @1AFE stack[-1] // @1B00 msg.data[stack[-5]:stack[-5] + stack[-6]] // @1B0D stack[-8] // @1B0D stack[-4] // @1B0E stack[-7] // } 1AF9 5B JUMPDEST 1AFA 85 DUP6 1AFB 85 DUP6 1AFC 60 PUSH1 0x20 1AFE 83 DUP4 1AFF 01 ADD 1B00 37 CALLDATACOPY 1B01 60 PUSH1 0x00 1B03 60 PUSH1 0x20 1B05 87 DUP8 1B06 83 DUP4 1B07 01 ADD 1B08 01 ADD 1B09 52 MSTORE 1B0A 50 POP 1B0B 50 POP 1B0C 50 POP 1B0D 93 SWAP4 1B0E 92 SWAP3 1B0F 50 POP 1B10 50 POP 1B11 50 POP 1B12 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @1B00 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @1B09 memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @1B0D stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_1B13: // Incoming call from 0x038F, returns to 0x0390 // Inputs[2] // { // @1B18 stack[-1] // @1B19 stack[-2] // } 1B13 5B JUMPDEST 1B14 60 PUSH1 0x00 1B16 60 PUSH1 0x20 1B18 82 DUP3 1B19 84 DUP5 1B1A 03 SUB 1B1B 12 SLT 1B1C 15 ISZERO 1B1D 61 PUSH2 0x1b25 1B20 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B14 stack[0] = 0x00 } // Block ends with conditional jump to 0x1b25, if !(stack[-2] - stack[-1] i< 0x20) label_1B21: // Incoming jump from 0x1B20, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1B24 memory[0x00:0x00] } 1B21 60 PUSH1 0x00 1B23 80 DUP1 1B24 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B24 revert(memory[0x00:0x00]); } // Block terminates label_1B25: // Incoming jump from 0x1B20, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1B26 stack[-2] // @1B27 msg.data[stack[-2]:stack[-2] + 0x20] // } 1B25 5B JUMPDEST 1B26 81 DUP2 1B27 35 CALLDATALOAD 1B28 67 PUSH8 0xffffffffffffffff 1B31 81 DUP2 1B32 11 GT 1B33 15 ISZERO 1B34 61 PUSH2 0x1b3c 1B37 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B27 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1b3c, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1B38: // Incoming jump from 0x1B37, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1B3B memory[0x00:0x00] } 1B38 60 PUSH1 0x00 1B3A 80 DUP1 1B3B FD *REVERT // Stack delta = +0 // Outputs[1] { @1B3B revert(memory[0x00:0x00]); } // Block terminates label_1B3C: // Incoming jump from 0x1B37, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1B3D stack[-3] // @1B3E stack[-1] // @1B43 stack[-4] // } 1B3C 5B JUMPDEST 1B3D 82 DUP3 1B3E 01 ADD 1B3F 60 PUSH1 0x1f 1B41 81 DUP2 1B42 01 ADD 1B43 84 DUP5 1B44 13 SGT 1B45 61 PUSH2 0x1b4d 1B48 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1B3E stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1b4d, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_1B49: // Incoming jump from 0x1B48, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @1B4C memory[0x00:0x00] } 1B49 60 PUSH1 0x00 1B4B 80 DUP1 1B4C FD *REVERT // Stack delta = +0 // Outputs[1] { @1B4C revert(memory[0x00:0x00]); } // Block terminates label_1B4D: // Incoming jump from 0x1B48, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @1B51 stack[-4] // @1B52 stack[-1] // @1B53 msg.data[stack[-1]:stack[-1] + 0x20] // } 1B4D 5B JUMPDEST 1B4E 61 PUSH2 0x15c3 1B51 84 DUP5 1B52 82 DUP3 1B53 35 CALLDATALOAD 1B54 60 PUSH1 0x20 1B56 84 DUP5 1B57 01 ADD 1B58 61 PUSH2 0x1a9d 1B5B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B4E stack[0] = 0x15c3 // @1B51 stack[1] = stack[-4] // @1B53 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1B57 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1a9d, returns to 0x15C3 label_1B5C: // Incoming call from 0x03AF, returns to 0x03B0 // Incoming call from 0x0404, returns to 0x0405 // Incoming call from 0x0592, returns to 0x0593 // Inputs[2] // { // @1B61 stack[-1] // @1B62 stack[-2] // } 1B5C 5B JUMPDEST 1B5D 60 PUSH1 0x00 1B5F 60 PUSH1 0x20 1B61 82 DUP3 1B62 84 DUP5 1B63 03 SUB 1B64 12 SLT 1B65 15 ISZERO 1B66 61 PUSH2 0x1b6e 1B69 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B5D stack[0] = 0x00 } // Block ends with conditional jump to 0x1b6e, if !(stack[-2] - stack[-1] i< 0x20) label_1B6A: // Incoming jump from 0x1B69, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1B6D memory[0x00:0x00] } 1B6A 60 PUSH1 0x00 1B6C 80 DUP1 1B6D FD *REVERT // Stack delta = +0 // Outputs[1] { @1B6D revert(memory[0x00:0x00]); } // Block terminates label_1B6E: // Incoming jump from 0x1B69, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1B72 stack[-2] } 1B6E 5B JUMPDEST 1B6F 61 PUSH2 0x0e89 1B72 82 DUP3 1B73 61 PUSH2 0x1a05 1B76 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1B6F stack[0] = 0x0e89 // @1B72 stack[1] = stack[-2] // } // Block ends with call to 0x1a05, returns to 0x0E89 label_1B77: // Incoming call from 0x1BCB, returns to 0x1BCC // Incoming call from 0x1BA1, returns to 0x0E89 // Inputs[2] // { // @1B78 stack[-1] // @1B79 msg.data[stack[-1]:stack[-1] + 0x20] // } 1B77 5B JUMPDEST 1B78 80 DUP1 1B79 35 CALLDATALOAD 1B7A 80 DUP1 1B7B 15 ISZERO 1B7C 15 ISZERO 1B7D 81 DUP2 1B7E 14 EQ 1B7F 61 PUSH2 0x1a1c 1B82 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B79 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1a1c, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_1B83: // Incoming jump from 0x1B82, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @1B86 memory[0x00:0x00] } 1B83 60 PUSH1 0x00 1B85 80 DUP1 1B86 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B86 revert(memory[0x00:0x00]); } // Block terminates label_1B87: // Incoming call from 0x0431, returns to 0x0432 // Inputs[2] // { // @1B8C stack[-1] // @1B8D stack[-2] // } 1B87 5B JUMPDEST 1B88 60 PUSH1 0x00 1B8A 60 PUSH1 0x20 1B8C 82 DUP3 1B8D 84 DUP5 1B8E 03 SUB 1B8F 12 SLT 1B90 15 ISZERO 1B91 61 PUSH2 0x1b99 1B94 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B88 stack[0] = 0x00 } // Block ends with conditional jump to 0x1b99, if !(stack[-2] - stack[-1] i< 0x20) label_1B95: // Incoming jump from 0x1B94, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1B98 memory[0x00:0x00] } 1B95 60 PUSH1 0x00 1B97 80 DUP1 1B98 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B98 revert(memory[0x00:0x00]); } // Block terminates label_1B99: // Incoming jump from 0x1B94, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1B9D stack[-2] } 1B99 5B JUMPDEST 1B9A 61 PUSH2 0x0e89 1B9D 82 DUP3 1B9E 61 PUSH2 0x1b77 1BA1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1B9A stack[0] = 0x0e89 // @1B9D stack[1] = stack[-2] // } // Block ends with call to 0x1b77, returns to 0x0E89 label_1BA2: // Incoming call from 0x049E, returns to 0x049F // Inputs[2] // { // @1BA8 stack[-1] // @1BA9 stack[-2] // } 1BA2 5B JUMPDEST 1BA3 60 PUSH1 0x00 1BA5 80 DUP1 1BA6 60 PUSH1 0x40 1BA8 83 DUP4 1BA9 85 DUP6 1BAA 03 SUB 1BAB 12 SLT 1BAC 15 ISZERO 1BAD 61 PUSH2 0x1bb5 1BB0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1BA3 stack[0] = 0x00 // @1BA5 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1bb5, if !(stack[-2] - stack[-1] i< 0x40) label_1BB1: // Incoming jump from 0x1BB0, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1BB4 memory[0x00:0x00] } 1BB1 60 PUSH1 0x00 1BB3 80 DUP1 1BB4 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BB4 revert(memory[0x00:0x00]); } // Block terminates label_1BB5: // Incoming jump from 0x1BB0, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1BB9 stack[-3] } 1BB5 5B JUMPDEST 1BB6 61 PUSH2 0x1bbe 1BB9 83 DUP4 1BBA 61 PUSH2 0x1a05 1BBD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1BB6 stack[0] = 0x1bbe // @1BB9 stack[1] = stack[-3] // } // Block ends with call to 0x1a05, returns to 0x1BBE label_1BBE: // Incoming return from call to 0x1A05 at 0x1BBD // Inputs[3] // { // @1BBF stack[-3] // @1BBF stack[-1] // @1BC6 stack[-4] // } 1BBE 5B JUMPDEST 1BBF 91 SWAP2 1BC0 50 POP 1BC1 61 PUSH2 0x1bcc 1BC4 60 PUSH1 0x20 1BC6 84 DUP5 1BC7 01 ADD 1BC8 61 PUSH2 0x1b77 1BCB 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1BBF stack[-3] = stack[-1] // @1BC1 stack[-1] = 0x1bcc // @1BC7 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1b77, returns to 0x1BCC label_1BCC: // Incoming return from call to 0x1B77 at 0x1BCB // Incoming return from call to 0x1A05 at 0x1C7A // Inputs[6] // { // @1BCD stack[-1] // @1BCD stack[-2] // @1BCF stack[-5] // @1BD1 stack[-6] // @1BD1 stack[-3] // @1BD2 stack[-4] // } 1BCC 5B JUMPDEST 1BCD 90 SWAP1 1BCE 50 POP 1BCF 92 SWAP3 1BD0 50 POP 1BD1 92 SWAP3 1BD2 90 SWAP1 1BD3 50 POP 1BD4 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1BCF stack[-5] = stack[-1] // @1BD1 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1BD5: // Incoming call from 0x04BE, returns to 0x04BF // Inputs[2] // { // @1BDE stack[-1] // @1BDF stack[-2] // } 1BD5 5B JUMPDEST 1BD6 60 PUSH1 0x00 1BD8 80 DUP1 1BD9 60 PUSH1 0x00 1BDB 80 DUP1 1BDC 60 PUSH1 0x80 1BDE 85 DUP6 1BDF 87 DUP8 1BE0 03 SUB 1BE1 12 SLT 1BE2 15 ISZERO 1BE3 61 PUSH2 0x1beb 1BE6 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1BD6 stack[0] = 0x00 // @1BD8 stack[1] = 0x00 // @1BD9 stack[2] = 0x00 // @1BDB stack[3] = 0x00 // } // Block ends with conditional jump to 0x1beb, if !(stack[-2] - stack[-1] i< 0x80) label_1BE7: // Incoming jump from 0x1BE6, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1BEA memory[0x00:0x00] } 1BE7 60 PUSH1 0x00 1BE9 80 DUP1 1BEA FD *REVERT // Stack delta = +0 // Outputs[1] { @1BEA revert(memory[0x00:0x00]); } // Block terminates label_1BEB: // Incoming jump from 0x1BE6, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1BEF stack[-5] } 1BEB 5B JUMPDEST 1BEC 61 PUSH2 0x1bf4 1BEF 85 DUP6 1BF0 61 PUSH2 0x1a05 1BF3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1BEC stack[0] = 0x1bf4 // @1BEF stack[1] = stack[-5] // } // Block ends with call to 0x1a05, returns to 0x1BF4 label_1BF4: // Incoming return from call to 0x1A05 at 0x1BF3 // Inputs[3] // { // @1BF5 stack[-5] // @1BF5 stack[-1] // @1BFC stack[-6] // } 1BF4 5B JUMPDEST 1BF5 93 SWAP4 1BF6 50 POP 1BF7 61 PUSH2 0x1c02 1BFA 60 PUSH1 0x20 1BFC 86 DUP7 1BFD 01 ADD 1BFE 61 PUSH2 0x1a05 1C01 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1BF5 stack[-5] = stack[-1] // @1BF7 stack[-1] = 0x1c02 // @1BFD stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x1a05, returns to 0x1C02 label_1C02: // Incoming return from call to 0x1A05 at 0x1C01 // Inputs[6] // { // @1C03 stack[-4] // @1C03 stack[-1] // @1C07 stack[-6] // @1C09 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1C0A stack[-3] // @1C10 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 1C02 5B JUMPDEST 1C03 92 SWAP3 1C04 50 POP 1C05 60 PUSH1 0x40 1C07 85 DUP6 1C08 01 ADD 1C09 35 CALLDATALOAD 1C0A 91 SWAP2 1C0B 50 POP 1C0C 60 PUSH1 0x60 1C0E 85 DUP6 1C0F 01 ADD 1C10 35 CALLDATALOAD 1C11 67 PUSH8 0xffffffffffffffff 1C1A 81 DUP2 1C1B 11 GT 1C1C 15 ISZERO 1C1D 61 PUSH2 0x1c25 1C20 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1C03 stack[-4] = stack[-1] // @1C0A stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1C10 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x1c25, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_1C21: // Incoming jump from 0x1C20, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1C24 memory[0x00:0x00] } 1C21 60 PUSH1 0x00 1C23 80 DUP1 1C24 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C24 revert(memory[0x00:0x00]); } // Block terminates label_1C25: // Incoming jump from 0x1C20, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1C26 stack[-6] // @1C27 stack[-1] // @1C2C stack[-7] // } 1C25 5B JUMPDEST 1C26 85 DUP6 1C27 01 ADD 1C28 60 PUSH1 0x1f 1C2A 81 DUP2 1C2B 01 ADD 1C2C 87 DUP8 1C2D 13 SGT 1C2E 61 PUSH2 0x1c36 1C31 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1C27 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x1c36, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_1C32: // Incoming jump from 0x1C31, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @1C35 memory[0x00:0x00] } 1C32 60 PUSH1 0x00 1C34 80 DUP1 1C35 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C35 revert(memory[0x00:0x00]); } // Block terminates label_1C36: // Incoming jump from 0x1C31, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @1C3A stack[-7] // @1C3B stack[-1] // @1C3C msg.data[stack[-1]:stack[-1] + 0x20] // } 1C36 5B JUMPDEST 1C37 61 PUSH2 0x1c45 1C3A 87 DUP8 1C3B 82 DUP3 1C3C 35 CALLDATALOAD 1C3D 60 PUSH1 0x20 1C3F 84 DUP5 1C40 01 ADD 1C41 61 PUSH2 0x1a9d 1C44 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C37 stack[0] = 0x1c45 // @1C3A stack[1] = stack[-7] // @1C3C stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1C40 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1a9d, returns to 0x1C45 label_1C45: // Incoming return from call to 0x1A9D at 0x1C44 // Inputs[8] // { // @1C46 stack[-1] // @1C46 stack[-3] // @1C49 stack[-6] // @1C4A stack[-9] // @1C4B stack[-5] // @1C4C stack[-8] // @1C4E stack[-4] // @1C4E stack[-7] // } 1C45 5B JUMPDEST 1C46 91 SWAP2 1C47 50 POP 1C48 50 POP 1C49 92 SWAP3 1C4A 95 SWAP6 1C4B 91 SWAP2 1C4C 94 SWAP5 1C4D 50 POP 1C4E 92 SWAP3 1C4F 50 POP 1C50 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @1C49 stack[-6] = stack[-1] // @1C4A stack[-9] = stack[-6] // @1C4C stack[-8] = stack[-5] // @1C4E stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_1C51: // Incoming call from 0x0534, returns to 0x0535 // Inputs[2] // { // @1C57 stack[-1] // @1C58 stack[-2] // } 1C51 5B JUMPDEST 1C52 60 PUSH1 0x00 1C54 80 DUP1 1C55 60 PUSH1 0x40 1C57 83 DUP4 1C58 85 DUP6 1C59 03 SUB 1C5A 12 SLT 1C5B 15 ISZERO 1C5C 61 PUSH2 0x1c64 1C5F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C52 stack[0] = 0x00 // @1C54 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1c64, if !(stack[-2] - stack[-1] i< 0x40) label_1C60: // Incoming jump from 0x1C5F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1C63 memory[0x00:0x00] } 1C60 60 PUSH1 0x00 1C62 80 DUP1 1C63 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C63 revert(memory[0x00:0x00]); } // Block terminates label_1C64: // Incoming jump from 0x1C5F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1C68 stack[-3] } 1C64 5B JUMPDEST 1C65 61 PUSH2 0x1c6d 1C68 83 DUP4 1C69 61 PUSH2 0x1a05 1C6C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1C65 stack[0] = 0x1c6d // @1C68 stack[1] = stack[-3] // } // Block ends with call to 0x1a05, returns to 0x1C6D label_1C6D: // Incoming return from call to 0x1A05 at 0x1C6C // Inputs[3] // { // @1C6E stack[-1] // @1C6E stack[-3] // @1C75 stack[-4] // } 1C6D 5B JUMPDEST 1C6E 91 SWAP2 1C6F 50 POP 1C70 61 PUSH2 0x1bcc 1C73 60 PUSH1 0x20 1C75 84 DUP5 1C76 01 ADD 1C77 61 PUSH2 0x1a05 1C7A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1C6E stack[-3] = stack[-1] // @1C70 stack[-1] = 0x1bcc // @1C76 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1a05, returns to 0x1BCC label_1C7B: // Incoming call from 0x09DC, returns to 0x09DD // Incoming call from 0x09B0, returns to 0x09B1 // Incoming call from 0x0CC5, returns to 0x0614 // Incoming call from 0x0613, returns to 0x0614 // Incoming call from 0x15D9, returns to 0x0614 // Incoming call from 0x063F, returns to 0x0640 // Incoming call from 0x18C9, returns to 0x18CA // Inputs[1] { @1C7E stack[-1] } 1C7B 5B JUMPDEST 1C7C 60 PUSH1 0x01 1C7E 81 DUP2 1C7F 81 DUP2 1C80 1C SHR 1C81 90 SWAP1 1C82 82 DUP3 1C83 16 AND 1C84 80 DUP1 1C85 61 PUSH2 0x1c8f 1C88 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C81 stack[0] = stack[-1] >> 0x01 // @1C83 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x1c8f, if stack[-1] & 0x01 label_1C89: // Incoming jump from 0x1C88, if not stack[-1] & 0x01 // Inputs[2] // { // @1C8B stack[-2] // @1C94 stack[-1] // } 1C89 60 PUSH1 0x7f 1C8B 82 DUP3 1C8C 16 AND 1C8D 91 SWAP2 1C8E 50 POP 1C8F 5B JUMPDEST 1C90 60 PUSH1 0x20 1C92 82 DUP3 1C93 10 LT 1C94 81 DUP2 1C95 03 SUB 1C96 61 PUSH2 0x1caf 1C99 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1C8D stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x1caf, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_1C9A: // Incoming jump from 0x1C99, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Incoming jump from 0x1C99, if not stack[-1] - (stack[-2] < 0x20) // Inputs[1] { @1CAE memory[0x00:0x24] } 1C9A 63 PUSH4 0x4e487b71 1C9F 60 PUSH1 0xe0 1CA1 1B SHL 1CA2 60 PUSH1 0x00 1CA4 52 MSTORE 1CA5 60 PUSH1 0x22 1CA7 60 PUSH1 0x04 1CA9 52 MSTORE 1CAA 60 PUSH1 0x24 1CAC 60 PUSH1 0x00 1CAE FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1CA4 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1CA9 memory[0x04:0x24] = 0x22 // @1CAE revert(memory[0x00:0x24]); // } // Block terminates label_1CAF: // Incoming jump from 0x1C99, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Incoming jump from 0x1C99, if stack[-1] - (stack[-2] < 0x20) // Inputs[3] // { // @1CB1 stack[-2] // @1CB1 stack[-4] // @1CB2 stack[-3] // } 1CAF 5B JUMPDEST 1CB0 50 POP 1CB1 91 SWAP2 1CB2 90 SWAP1 1CB3 50 POP 1CB4 56 *JUMP // Stack delta = -3 // Outputs[1] { @1CB1 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_1CB5: // Incoming call from 0x0B6C, returns to 0x0702 // Incoming call from 0x0C3E, returns to 0x0702 // Incoming call from 0x0A5B, returns to 0x0702 // Incoming call from 0x0FF0, returns to 0x0702 // Incoming call from 0x0EB9, returns to 0x0702 // Incoming call from 0x0CA3, returns to 0x0702 // Incoming call from 0x0C74, returns to 0x0702 // Inputs[2] // { // @1CB9 stack[-1] // @1CE8 stack[-2] // } 1CB5 5B JUMPDEST 1CB6 60 PUSH1 0x20 1CB8 80 DUP1 1CB9 82 DUP3 1CBA 52 MSTORE 1CBB 81 DUP2 1CBC 81 DUP2 1CBD 01 ADD 1CBE 52 MSTORE 1CBF 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1CE0 60 PUSH1 0x40 1CE2 82 DUP3 1CE3 01 ADD 1CE4 52 MSTORE 1CE5 60 PUSH1 0x60 1CE7 01 ADD 1CE8 90 SWAP1 1CE9 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1CBA memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1CBE memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @1CE4 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1CE8 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_1CEA: // Incoming call from 0x18A8, returns to 0x0702 // Incoming call from 0x159C, returns to 0x0702 // Inputs[2] // { // @1CEE stack[-1] // @1D3B stack[-2] // } 1CEA 5B JUMPDEST 1CEB 60 PUSH1 0x20 1CED 80 DUP1 1CEE 82 DUP3 1CEF 52 MSTORE 1CF0 60 PUSH1 0x33 1CF2 90 SWAP1 1CF3 82 DUP3 1CF4 01 ADD 1CF5 52 MSTORE 1CF6 7F PUSH32 0x455243373231413a207472616e7366657220746f206e6f6e2045524337323152 1D17 60 PUSH1 0x40 1D19 82 DUP3 1D1A 01 ADD 1D1B 52 MSTORE 1D1C 72 PUSH19 0x32b1b2b4bb32b91034b6b83632b6b2b73a32b9 1D30 60 PUSH1 0x69 1D32 1B SHL 1D33 60 PUSH1 0x60 1D35 82 DUP3 1D36 01 ADD 1D37 52 MSTORE 1D38 60 PUSH1 0x80 1D3A 01 ADD 1D3B 90 SWAP1 1D3C 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1CEF memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1CF5 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x33 // @1D1B memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243373231413a207472616e7366657220746f206e6f6e2045524337323152 // @1D37 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x32b1b2b4bb32b91034b6b83632b6b2b73a32b9 << 0x69 // @1D3B stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_1D3D: // Incoming call from 0x0E78, returns to 0x0E79 // Inputs[3] // { // @1D40 stack[-3] // @1D41 memory[stack[-3]:stack[-3] + 0x20] // @1D46 stack[-1] // } 1D3D 5B JUMPDEST 1D3E 60 PUSH1 0x00 1D40 83 DUP4 1D41 51 MLOAD 1D42 61 PUSH2 0x1d4f 1D45 81 DUP2 1D46 84 DUP5 1D47 60 PUSH1 0x20 1D49 88 DUP9 1D4A 01 ADD 1D4B 61 PUSH2 0x1981 1D4E 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1D3E stack[0] = 0x00 // @1D41 stack[1] = memory[stack[-3]:stack[-3] + 0x20] // @1D42 stack[2] = 0x1d4f // @1D45 stack[3] = memory[stack[-3]:stack[-3] + 0x20] // @1D46 stack[4] = stack[-1] // @1D4A stack[5] = stack[-3] + 0x20 // } // Block ends with call to 0x1981, returns to 0x1D4F label_1D4F: // Incoming return from call to 0x1981 at 0x1D4E // Inputs[4] // { // @1D50 stack[-4] // @1D51 memory[stack[-4]:stack[-4] + 0x20] // @1D52 stack[-1] // @1D53 stack[-3] // } 1D4F 5B JUMPDEST 1D50 83 DUP4 1D51 51 MLOAD 1D52 90 SWAP1 1D53 83 DUP4 1D54 01 ADD 1D55 90 SWAP1 1D56 61 PUSH2 0x1d63 1D59 81 DUP2 1D5A 83 DUP4 1D5B 60 PUSH1 0x20 1D5D 88 DUP9 1D5E 01 ADD 1D5F 61 PUSH2 0x1981 1D62 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @1D55 stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @1D55 stack[-1] = stack[-3] + stack[-1] // @1D56 stack[1] = 0x1d63 // @1D59 stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @1D5A stack[3] = stack[-3] + stack[-1] // @1D5E stack[4] = stack[-4] + 0x20 // } // Block ends with call to 0x1981, returns to 0x1D63 label_1D63: // Incoming return from call to 0x1981 at 0x1D62 // Inputs[4] // { // @1D64 stack[-2] // @1D64 stack[-1] // @1D65 stack[-7] // @1D66 stack[-6] // } 1D63 5B JUMPDEST 1D64 01 ADD 1D65 94 SWAP5 1D66 93 SWAP4 1D67 50 POP 1D68 50 POP 1D69 50 POP 1D6A 50 POP 1D6B 56 *JUMP // Stack delta = -6 // Outputs[1] { @1D65 stack[-7] = stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-7] label_1D6C: // Incoming jump from 0x1E48 // Incoming jump from 0x1D94 // Incoming jump from 0x1E05 // Inputs[1] { @1D81 memory[0x00:0x24] } 1D6C 5B JUMPDEST 1D6D 63 PUSH4 0x4e487b71 1D72 60 PUSH1 0xe0 1D74 1B SHL 1D75 60 PUSH1 0x00 1D77 52 MSTORE 1D78 60 PUSH1 0x11 1D7A 60 PUSH1 0x04 1D7C 52 MSTORE 1D7D 60 PUSH1 0x24 1D7F 60 PUSH1 0x00 1D81 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1D77 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1D7C memory[0x04:0x24] = 0x11 // @1D81 revert(memory[0x00:0x24]); // } // Block terminates label_1D82: // Incoming call from 0x0F57, returns to 0x0F58 // Incoming call from 0x0FB9, returns to 0x0FBA // Incoming call from 0x0EC9, returns to 0x0ECA // Incoming call from 0x169C, returns to 0x169D // Inputs[2] // { // @1D85 stack[-2] // @1D87 stack[-1] // } 1D82 5B JUMPDEST 1D83 60 PUSH1 0x00 1D85 82 DUP3 1D86 19 NOT 1D87 82 DUP3 1D88 11 GT 1D89 15 ISZERO 1D8A 61 PUSH2 0x1d95 1D8D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D83 stack[0] = 0x00 } // Block ends with conditional jump to 0x1d95, if !(stack[-1] > ~stack[-2]) label_1D8E: // Incoming jump from 0x1D8D, if not !(stack[-1] > ~stack[-2]) 1D8E 61 PUSH2 0x1d95 1D91 61 PUSH2 0x1d6c 1D94 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D8E stack[0] = 0x1d95 } // Block ends with unconditional jump to 0x1d6c label_1D95: // Incoming jump from 0x1D8D, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @1D97 stack[-2] // @1D97 stack[-3] // @1D98 stack[-4] // } 1D95 5B JUMPDEST 1D96 50 POP 1D97 01 ADD 1D98 90 SWAP1 1D99 56 *JUMP // Stack delta = -3 // Outputs[1] { @1D98 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_1D9A: // Incoming call from 0x150C, returns to 0x150D // Inputs[5] // { // @1DA3 stack[-5] // @1DA6 stack[-1] // @1DA8 stack[-4] // @1DB3 stack[-3] // @1DC8 stack[-2] // } 1D9A 5B JUMPDEST 1D9B 60 PUSH1 0x01 1D9D 60 PUSH1 0x01 1D9F 60 PUSH1 0xa0 1DA1 1B SHL 1DA2 03 SUB 1DA3 85 DUP6 1DA4 81 DUP2 1DA5 16 AND 1DA6 82 DUP3 1DA7 52 MSTORE 1DA8 84 DUP5 1DA9 16 AND 1DAA 60 PUSH1 0x20 1DAC 82 DUP3 1DAD 01 ADD 1DAE 52 MSTORE 1DAF 60 PUSH1 0x40 1DB1 81 DUP2 1DB2 01 ADD 1DB3 83 DUP4 1DB4 90 SWAP1 1DB5 52 MSTORE 1DB6 60 PUSH1 0x80 1DB8 60 PUSH1 0x60 1DBA 82 DUP3 1DBB 01 ADD 1DBC 81 DUP2 1DBD 90 SWAP1 1DBE 52 MSTORE 1DBF 60 PUSH1 0x00 1DC1 90 SWAP1 1DC2 61 PUSH2 0x1dcd 1DC5 90 SWAP1 1DC6 83 DUP4 1DC7 01 ADD 1DC8 84 DUP5 1DC9 61 PUSH2 0x19ad 1DCC 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @1DA7 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1DAE memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1DB5 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @1DBE memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @1DC1 stack[0] = 0x00 // @1DC5 stack[1] = 0x1dcd // @1DC7 stack[2] = stack[-1] + 0x80 // @1DC8 stack[3] = stack[-2] // } // Block ends with call to 0x19ad, returns to 0x1DCD label_1DCD: // Incoming return from call to 0x19AD at 0x1DCC // Inputs[3] // { // @1DCE stack[-8] // @1DCE stack[-1] // @1DCF stack[-7] // } 1DCD 5B JUMPDEST 1DCE 96 SWAP7 1DCF 95 SWAP6 1DD0 50 POP 1DD1 50 POP 1DD2 50 POP 1DD3 50 POP 1DD4 50 POP 1DD5 50 POP 1DD6 56 *JUMP // Stack delta = -7 // Outputs[1] { @1DCE stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_1DD7: // Incoming jump from 0x1544 // Inputs[2] // { // @1DDC stack[-1] // @1DDD stack[-2] // } 1DD7 5B JUMPDEST 1DD8 60 PUSH1 0x00 1DDA 60 PUSH1 0x20 1DDC 82 DUP3 1DDD 84 DUP5 1DDE 03 SUB 1DDF 12 SLT 1DE0 15 ISZERO 1DE1 61 PUSH2 0x1de9 1DE4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DD8 stack[0] = 0x00 } // Block ends with conditional jump to 0x1de9, if !(stack[-2] - stack[-1] i< 0x20) label_1DE5: // Incoming jump from 0x1DE4, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1DE8 memory[0x00:0x00] } 1DE5 60 PUSH1 0x00 1DE7 80 DUP1 1DE8 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DE8 revert(memory[0x00:0x00]); } // Block terminates label_1DE9: // Incoming jump from 0x1DE4, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1DEA stack[-2] // @1DEB memory[stack[-2]:stack[-2] + 0x20] // } 1DE9 5B JUMPDEST 1DEA 81 DUP2 1DEB 51 MLOAD 1DEC 61 PUSH2 0x0e89 1DEF 81 DUP2 1DF0 61 PUSH2 0x194e 1DF3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1DEB stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @1DEC stack[1] = 0x0e89 // @1DEF stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x194e, returns to 0x0E89 label_1DF4: // Incoming call from 0x1614, returns to 0x1615 // Inputs[1] { @1DF9 stack[-1] } 1DF4 5B JUMPDEST 1DF5 60 PUSH1 0x00 1DF7 60 PUSH1 0x01 1DF9 82 DUP3 1DFA 01 ADD 1DFB 61 PUSH2 0x1e06 1DFE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DF5 stack[0] = 0x00 } // Block ends with conditional jump to 0x1e06, if stack[-1] + 0x01 label_1DFF: // Incoming jump from 0x1DFE, if not stack[-1] + 0x01 1DFF 61 PUSH2 0x1e06 1E02 61 PUSH2 0x1d6c 1E05 56 *JUMP // Stack delta = +1 // Outputs[1] { @1DFF stack[0] = 0x1e06 } // Block ends with unconditional jump to 0x1d6c label_1E06: // Incoming jump from 0x1DFE, if stack[-1] + 0x01 // Inputs[2] // { // @1E0A stack[-2] // @1E0B stack[-3] // } 1E06 5B JUMPDEST 1E07 50 POP 1E08 60 PUSH1 0x01 1E0A 01 ADD 1E0B 90 SWAP1 1E0C 56 *JUMP // Stack delta = -2 // Outputs[1] { @1E0B stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_1E0D: // Incoming jump from 0x1E5C // Incoming jump from 0x1E31 // Inputs[1] { @1E22 memory[0x00:0x24] } 1E0D 5B JUMPDEST 1E0E 63 PUSH4 0x4e487b71 1E13 60 PUSH1 0xe0 1E15 1B SHL 1E16 60 PUSH1 0x00 1E18 52 MSTORE 1E19 60 PUSH1 0x12 1E1B 60 PUSH1 0x04 1E1D 52 MSTORE 1E1E 60 PUSH1 0x24 1E20 60 PUSH1 0x00 1E22 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1E18 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1E1D memory[0x04:0x24] = 0x12 // @1E22 revert(memory[0x00:0x24]); // } // Block terminates label_1E23: // Incoming call from 0x16D3, returns to 0x16D4 // Incoming call from 0x1623, returns to 0x1624 // Inputs[1] { @1E26 stack[-2] } 1E23 5B JUMPDEST 1E24 60 PUSH1 0x00 1E26 82 DUP3 1E27 61 PUSH2 0x1e32 1E2A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E24 stack[0] = 0x00 } // Block ends with conditional jump to 0x1e32, if stack[-2] label_1E2B: // Incoming jump from 0x1E2A, if not stack[-2] 1E2B 61 PUSH2 0x1e32 1E2E 61 PUSH2 0x1e0d 1E31 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E2B stack[0] = 0x1e32 } // Block ends with unconditional jump to 0x1e0d label_1E32: // Incoming jump from 0x1E2A, if stack[-2] // Inputs[3] // { // @1E34 stack[-2] // @1E34 stack[-3] // @1E35 stack[-4] // } 1E32 5B JUMPDEST 1E33 50 POP 1E34 04 DIV 1E35 90 SWAP1 1E36 56 *JUMP // Stack delta = -3 // Outputs[1] { @1E35 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_1E37: // Incoming call from 0x1684, returns to 0x1685 // Inputs[2] // { // @1E3A stack[-2] // @1E3B stack[-1] // } 1E37 5B JUMPDEST 1E38 60 PUSH1 0x00 1E3A 82 DUP3 1E3B 82 DUP3 1E3C 10 LT 1E3D 15 ISZERO 1E3E 61 PUSH2 0x1e49 1E41 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E38 stack[0] = 0x00 } // Block ends with conditional jump to 0x1e49, if !(stack[-1] < stack[-2]) label_1E42: // Incoming jump from 0x1E41, if not !(stack[-1] < stack[-2]) 1E42 61 PUSH2 0x1e49 1E45 61 PUSH2 0x1d6c 1E48 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E42 stack[0] = 0x1e49 } // Block ends with unconditional jump to 0x1d6c label_1E49: // Incoming jump from 0x1E41, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @1E4B stack[-3] // @1E4B stack[-2] // @1E4C stack[-4] // } 1E49 5B JUMPDEST 1E4A 50 POP 1E4B 03 SUB 1E4C 90 SWAP1 1E4D 56 *JUMP // Stack delta = -3 // Outputs[1] { @1E4C stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_1E4E: // Incoming call from 0x1691, returns to 0x1692 // Inputs[1] { @1E51 stack[-2] } 1E4E 5B JUMPDEST 1E4F 60 PUSH1 0x00 1E51 82 DUP3 1E52 61 PUSH2 0x1e5d 1E55 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E4F stack[0] = 0x00 } // Block ends with conditional jump to 0x1e5d, if stack[-2] label_1E56: // Incoming jump from 0x1E55, if not stack[-2] 1E56 61 PUSH2 0x1e5d 1E59 61 PUSH2 0x1e0d 1E5C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E56 stack[0] = 0x1e5d } // Block ends with unconditional jump to 0x1e0d label_1E5D: // Incoming jump from 0x1E55, if stack[-2] // Inputs[3] // { // @1E5F stack[-2] // @1E5F stack[-3] // @1E60 stack[-4] // } 1E5D 5B JUMPDEST 1E5E 50 POP 1E5F 06 MOD 1E60 90 SWAP1 1E61 56 *JUMP // Stack delta = -3 // Outputs[1] { @1E60 stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_1E62: // Incoming jump from 0x16B1 // Inputs[1] { @1E77 memory[0x00:0x24] } 1E62 5B JUMPDEST 1E63 63 PUSH4 0x4e487b71 1E68 60 PUSH1 0xe0 1E6A 1B SHL 1E6B 60 PUSH1 0x00 1E6D 52 MSTORE 1E6E 60 PUSH1 0x32 1E70 60 PUSH1 0x04 1E72 52 MSTORE 1E73 60 PUSH1 0x24 1E75 60 PUSH1 0x00 1E77 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1E6D memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1E72 memory[0x04:0x24] = 0x32 // @1E77 revert(memory[0x00:0x24]); // } // Block terminates 1E78 FE *ASSERT 1E79 A2 LOG2 1E7A 64 PUSH5 0x6970667358 1E80 22 22 1E81 12 SLT 1E82 20 SHA3 1E83 88 DUP9 1E84 53 MSTORE8 1E85 4B 4B 1E86 87 DUP8 1E87 0B SIGNEXTEND 1E88 74 PUSH21 0xd079496500c10c65c4c8b09d28e149d4dfc41803e0 1E9E 91 SWAP2 1E9F 88 DUP9 1EA0 AF AF 1EA1 C8 C8 1EA2 6F PUSH16 0x64736f6c634300080d0033