Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x0285 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0285, 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 0x70a08231 0019 11 GT 001A 61 PUSH2 0x0153 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0153, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xb88d4fde 0024 11 GT 0025 61 PUSH2 0x00cb 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00cb, if 0xb88d4fde > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xb88d4fde > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xdb97d4f8 002F 11 GT 0030 61 PUSH2 0x007f 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007f, if 0xdb97d4f8 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xdb97d4f8 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xe985e9c5 003A 11 GT 003B 61 PUSH2 0x0064 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0064, if 0xe985e9c5 > stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xe985e9c5 > stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe985e9c5 0045 14 EQ 0046 61 PUSH2 0x06a5 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06a5, if 0xe985e9c5 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xf2fde38b 0050 14 EQ 0051 61 PUSH2 0x06ee 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06ee, if 0xf2fde38b == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xfb5d18cd 005B 14 EQ 005C 61 PUSH2 0x070e 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x070e, if 0xfb5d18cd == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xfb5d18cd == 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 0x003E, if 0xe985e9c5 > stack[-1] // Inputs[1] { @0065 stack[-1] } 0064 5B JUMPDEST 0065 80 DUP1 0066 63 PUSH4 0xdb97d4f8 006B 14 EQ 006C 61 PUSH2 0x0670 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0670, if 0xdb97d4f8 == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0xdb97d4f8 == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xdd108ab5 0076 14 EQ 0077 61 PUSH2 0x0685 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0685, if 0xdd108ab5 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xdd108ab5 == stack[-1] // Inputs[1] { @007E memory[0x00:0x00] } 007B 60 PUSH1 0x00 007D 80 DUP1 007E FD *REVERT // Stack delta = +0 // Outputs[1] { @007E revert(memory[0x00:0x00]); } // Block terminates label_007F: // Incoming jump from 0x0033, if 0xdb97d4f8 > stack[-1] // Inputs[1] { @0080 stack[-1] } 007F 5B JUMPDEST 0080 80 DUP1 0081 63 PUSH4 0xc285e107 0086 11 GT 0087 61 PUSH2 0x00b0 008A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b0, if 0xc285e107 > stack[-1] label_008B: // Incoming jump from 0x008A, if not 0xc285e107 > stack[-1] // Inputs[1] { @008B stack[-1] } 008B 80 DUP1 008C 63 PUSH4 0xc285e107 0091 14 EQ 0092 61 PUSH2 0x0624 0095 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0624, if 0xc285e107 == stack[-1] label_0096: // Incoming jump from 0x0095, if not 0xc285e107 == stack[-1] // Inputs[1] { @0096 stack[-1] } 0096 80 DUP1 0097 63 PUSH4 0xc87b56dd 009C 14 EQ 009D 61 PUSH2 0x063a 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x063a, if 0xc87b56dd == stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0xc87b56dd == stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0xd5abeb01 00A7 14 EQ 00A8 61 PUSH2 0x065a 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x065a, if 0xd5abeb01 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0xd5abeb01 == stack[-1] // Inputs[1] { @00AF memory[0x00:0x00] } 00AC 60 PUSH1 0x00 00AE 80 DUP1 00AF FD *REVERT // Stack delta = +0 // Outputs[1] { @00AF revert(memory[0x00:0x00]); } // Block terminates label_00B0: // Incoming jump from 0x008A, if 0xc285e107 > stack[-1] // Inputs[1] { @00B1 stack[-1] } 00B0 5B JUMPDEST 00B1 80 DUP1 00B2 63 PUSH4 0xb88d4fde 00B7 14 EQ 00B8 61 PUSH2 0x05ee 00BB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05ee, if 0xb88d4fde == stack[-1] label_00BC: // Incoming jump from 0x00BB, if not 0xb88d4fde == stack[-1] // Inputs[1] { @00BC stack[-1] } 00BC 80 DUP1 00BD 63 PUSH4 0xbdb4b848 00C2 14 EQ 00C3 61 PUSH2 0x060e 00C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x060e, if 0xbdb4b848 == stack[-1] label_00C7: // Incoming jump from 0x00C6, if not 0xbdb4b848 == stack[-1] // Inputs[1] { @00CA memory[0x00:0x00] } 00C7 60 PUSH1 0x00 00C9 80 DUP1 00CA FD *REVERT // Stack delta = +0 // Outputs[1] { @00CA revert(memory[0x00:0x00]); } // Block terminates label_00CB: // Incoming jump from 0x0028, if 0xb88d4fde > stack[-1] // Inputs[1] { @00CC stack[-1] } 00CB 5B JUMPDEST 00CC 80 DUP1 00CD 63 PUSH4 0x8545f4ea 00D2 11 GT 00D3 61 PUSH2 0x0122 00D6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0122, if 0x8545f4ea > stack[-1] label_00D7: // Incoming jump from 0x00D6, if not 0x8545f4ea > stack[-1] // Inputs[1] { @00D7 stack[-1] } 00D7 80 DUP1 00D8 63 PUSH4 0x95d89b41 00DD 11 GT 00DE 61 PUSH2 0x0107 00E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0107, if 0x95d89b41 > stack[-1] label_00E2: // Incoming jump from 0x00E1, if not 0x95d89b41 > stack[-1] // Inputs[1] { @00E2 stack[-1] } 00E2 80 DUP1 00E3 63 PUSH4 0x95d89b41 00E8 14 EQ 00E9 61 PUSH2 0x05a6 00EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a6, if 0x95d89b41 == stack[-1] label_00ED: // Incoming jump from 0x00EC, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00ED stack[-1] } 00ED 80 DUP1 00EE 63 PUSH4 0xa0712d68 00F3 14 EQ 00F4 61 PUSH2 0x05bb 00F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05bb, if 0xa0712d68 == stack[-1] label_00F8: // Incoming jump from 0x00F7, if not 0xa0712d68 == stack[-1] // Inputs[1] { @00F8 stack[-1] } 00F8 80 DUP1 00F9 63 PUSH4 0xa22cb465 00FE 14 EQ 00FF 61 PUSH2 0x05ce 0102 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05ce, if 0xa22cb465 == stack[-1] label_0103: // Incoming jump from 0x0102, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0106 memory[0x00:0x00] } 0103 60 PUSH1 0x00 0105 80 DUP1 0106 FD *REVERT // Stack delta = +0 // Outputs[1] { @0106 revert(memory[0x00:0x00]); } // Block terminates label_0107: // Incoming jump from 0x00E1, if 0x95d89b41 > stack[-1] // Inputs[1] { @0108 stack[-1] } 0107 5B JUMPDEST 0108 80 DUP1 0109 63 PUSH4 0x8545f4ea 010E 14 EQ 010F 61 PUSH2 0x0568 0112 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0568, if 0x8545f4ea == stack[-1] label_0113: // Incoming jump from 0x0112, if not 0x8545f4ea == stack[-1] // Inputs[1] { @0113 stack[-1] } 0113 80 DUP1 0114 63 PUSH4 0x8da5cb5b 0119 14 EQ 011A 61 PUSH2 0x0588 011D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0588, if 0x8da5cb5b == stack[-1] label_011E: // Incoming jump from 0x011D, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0121 memory[0x00:0x00] } 011E 60 PUSH1 0x00 0120 80 DUP1 0121 FD *REVERT // Stack delta = +0 // Outputs[1] { @0121 revert(memory[0x00:0x00]); } // Block terminates label_0122: // Incoming jump from 0x00D6, if 0x8545f4ea > stack[-1] // Inputs[1] { @0123 stack[-1] } 0122 5B JUMPDEST 0123 80 DUP1 0124 63 PUSH4 0x70a08231 0129 14 EQ 012A 61 PUSH2 0x04f3 012D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f3, if 0x70a08231 == stack[-1] label_012E: // Incoming jump from 0x012D, if not 0x70a08231 == stack[-1] // Inputs[1] { @012E stack[-1] } 012E 80 DUP1 012F 63 PUSH4 0x715018a6 0134 14 EQ 0135 61 PUSH2 0x0513 0138 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0513, if 0x715018a6 == stack[-1] label_0139: // Incoming jump from 0x0138, if not 0x715018a6 == stack[-1] // Inputs[1] { @0139 stack[-1] } 0139 80 DUP1 013A 63 PUSH4 0x7389fbb7 013F 14 EQ 0140 61 PUSH2 0x0528 0143 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0528, if 0x7389fbb7 == stack[-1] label_0144: // Incoming jump from 0x0143, if not 0x7389fbb7 == stack[-1] // Inputs[1] { @0144 stack[-1] } 0144 80 DUP1 0145 63 PUSH4 0x780cf82a 014A 14 EQ 014B 61 PUSH2 0x0548 014E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0548, if 0x780cf82a == stack[-1] label_014F: // Incoming jump from 0x014E, if not 0x780cf82a == stack[-1] // Inputs[1] { @0152 memory[0x00:0x00] } 014F 60 PUSH1 0x00 0151 80 DUP1 0152 FD *REVERT // Stack delta = +0 // Outputs[1] { @0152 revert(memory[0x00:0x00]); } // Block terminates label_0153: // Incoming jump from 0x001D, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0154 stack[-1] } 0153 5B JUMPDEST 0154 80 DUP1 0155 63 PUSH4 0x355f2747 015A 11 GT 015B 61 PUSH2 0x0201 015E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0201, if 0x355f2747 > stack[-1] label_015F: // Incoming jump from 0x015E, if not 0x355f2747 > stack[-1] // Inputs[1] { @015F stack[-1] } 015F 80 DUP1 0160 63 PUSH4 0x55f804b3 0165 11 GT 0166 61 PUSH2 0x01b5 0169 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b5, if 0x55f804b3 > stack[-1] label_016A: // Incoming jump from 0x0169, if not 0x55f804b3 > stack[-1] // Inputs[1] { @016A stack[-1] } 016A 80 DUP1 016B 63 PUSH4 0x6352211e 0170 11 GT 0171 61 PUSH2 0x019a 0174 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x019a, if 0x6352211e > stack[-1] label_0175: // Incoming jump from 0x0174, if not 0x6352211e > stack[-1] // Inputs[1] { @0175 stack[-1] } 0175 80 DUP1 0176 63 PUSH4 0x6352211e 017B 14 EQ 017C 61 PUSH2 0x049e 017F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x049e, if 0x6352211e == stack[-1] label_0180: // Incoming jump from 0x017F, if not 0x6352211e == stack[-1] // Inputs[1] { @0180 stack[-1] } 0180 80 DUP1 0181 63 PUSH4 0x6c0360eb 0186 14 EQ 0187 61 PUSH2 0x04be 018A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04be, if 0x6c0360eb == stack[-1] label_018B: // Incoming jump from 0x018A, if not 0x6c0360eb == stack[-1] // Inputs[1] { @018B stack[-1] } 018B 80 DUP1 018C 63 PUSH4 0x6f8b44b0 0191 14 EQ 0192 61 PUSH2 0x04d3 0195 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d3, if 0x6f8b44b0 == stack[-1] label_0196: // Incoming jump from 0x0195, if not 0x6f8b44b0 == stack[-1] // Inputs[1] { @0199 memory[0x00:0x00] } 0196 60 PUSH1 0x00 0198 80 DUP1 0199 FD *REVERT // Stack delta = +0 // Outputs[1] { @0199 revert(memory[0x00:0x00]); } // Block terminates label_019A: // Incoming jump from 0x0174, if 0x6352211e > stack[-1] // Inputs[1] { @019B stack[-1] } 019A 5B JUMPDEST 019B 80 DUP1 019C 63 PUSH4 0x55f804b3 01A1 14 EQ 01A2 61 PUSH2 0x0464 01A5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0464, if 0x55f804b3 == stack[-1] label_01A6: // Incoming jump from 0x01A5, if not 0x55f804b3 == stack[-1] // Inputs[1] { @01A6 stack[-1] } 01A6 80 DUP1 01A7 63 PUSH4 0x5c975abb 01AC 14 EQ 01AD 61 PUSH2 0x0484 01B0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0484, if 0x5c975abb == stack[-1] label_01B1: // Incoming jump from 0x01B0, if not 0x5c975abb == stack[-1] // Inputs[1] { @01B4 memory[0x00:0x00] } 01B1 60 PUSH1 0x00 01B3 80 DUP1 01B4 FD *REVERT // Stack delta = +0 // Outputs[1] { @01B4 revert(memory[0x00:0x00]); } // Block terminates label_01B5: // Incoming jump from 0x0169, if 0x55f804b3 > stack[-1] // Inputs[1] { @01B6 stack[-1] } 01B5 5B JUMPDEST 01B6 80 DUP1 01B7 63 PUSH4 0x421357c1 01BC 11 GT 01BD 61 PUSH2 0x01e6 01C0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e6, if 0x421357c1 > stack[-1] label_01C1: // Incoming jump from 0x01C0, if not 0x421357c1 > stack[-1] // Inputs[1] { @01C1 stack[-1] } 01C1 80 DUP1 01C2 63 PUSH4 0x421357c1 01C7 14 EQ 01C8 61 PUSH2 0x0411 01CB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0411, if 0x421357c1 == stack[-1] label_01CC: // Incoming jump from 0x01CB, if not 0x421357c1 == stack[-1] // Inputs[1] { @01CC stack[-1] } 01CC 80 DUP1 01CD 63 PUSH4 0x42842e0e 01D2 14 EQ 01D3 61 PUSH2 0x0424 01D6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0424, if 0x42842e0e == stack[-1] label_01D7: // Incoming jump from 0x01D6, if not 0x42842e0e == stack[-1] // Inputs[1] { @01D7 stack[-1] } 01D7 80 DUP1 01D8 63 PUSH4 0x4f558e79 01DD 14 EQ 01DE 61 PUSH2 0x0444 01E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0444, if 0x4f558e79 == stack[-1] label_01E2: // Incoming jump from 0x01E1, if not 0x4f558e79 == stack[-1] // Inputs[1] { @01E5 memory[0x00:0x00] } 01E2 60 PUSH1 0x00 01E4 80 DUP1 01E5 FD *REVERT // Stack delta = +0 // Outputs[1] { @01E5 revert(memory[0x00:0x00]); } // Block terminates label_01E6: // Incoming jump from 0x01C0, if 0x421357c1 > stack[-1] // Inputs[1] { @01E7 stack[-1] } 01E6 5B JUMPDEST 01E7 80 DUP1 01E8 63 PUSH4 0x355f2747 01ED 14 EQ 01EE 61 PUSH2 0x03ea 01F1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ea, if 0x355f2747 == stack[-1] label_01F2: // Incoming jump from 0x01F1, if not 0x355f2747 == stack[-1] // Inputs[1] { @01F2 stack[-1] } 01F2 80 DUP1 01F3 63 PUSH4 0x3ccfd60b 01F8 14 EQ 01F9 61 PUSH2 0x0409 01FC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0409, if 0x3ccfd60b == stack[-1] label_01FD: // Incoming jump from 0x01FC, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @0200 memory[0x00:0x00] } 01FD 60 PUSH1 0x00 01FF 80 DUP1 0200 FD *REVERT // Stack delta = +0 // Outputs[1] { @0200 revert(memory[0x00:0x00]); } // Block terminates label_0201: // Incoming jump from 0x015E, if 0x355f2747 > stack[-1] // Inputs[1] { @0202 stack[-1] } 0201 5B JUMPDEST 0202 80 DUP1 0203 63 PUSH4 0x095ea7b3 0208 11 GT 0209 61 PUSH2 0x0258 020C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0258, if 0x095ea7b3 > stack[-1] label_020D: // Incoming jump from 0x020C, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @020D stack[-1] } 020D 80 DUP1 020E 63 PUSH4 0x18160ddd 0213 11 GT 0214 61 PUSH2 0x023d 0217 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023d, if 0x18160ddd > stack[-1] label_0218: // Incoming jump from 0x0217, if not 0x18160ddd > stack[-1] // Inputs[1] { @0218 stack[-1] } 0218 80 DUP1 0219 63 PUSH4 0x18160ddd 021E 14 EQ 021F 61 PUSH2 0x0383 0222 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0383, if 0x18160ddd == stack[-1] label_0223: // Incoming jump from 0x0222, if not 0x18160ddd == stack[-1] // Inputs[1] { @0223 stack[-1] } 0223 80 DUP1 0224 63 PUSH4 0x23b872dd 0229 14 EQ 022A 61 PUSH2 0x03aa 022D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03aa, if 0x23b872dd == stack[-1] label_022E: // Incoming jump from 0x022D, if not 0x23b872dd == stack[-1] // Inputs[1] { @022E stack[-1] } 022E 80 DUP1 022F 63 PUSH4 0x257841e7 0234 14 EQ 0235 61 PUSH2 0x03ca 0238 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ca, if 0x257841e7 == stack[-1] label_0239: // Incoming jump from 0x0238, if not 0x257841e7 == stack[-1] // Inputs[1] { @023C memory[0x00:0x00] } 0239 60 PUSH1 0x00 023B 80 DUP1 023C FD *REVERT // Stack delta = +0 // Outputs[1] { @023C revert(memory[0x00:0x00]); } // Block terminates label_023D: // Incoming jump from 0x0217, if 0x18160ddd > stack[-1] // Inputs[1] { @023E stack[-1] } 023D 5B JUMPDEST 023E 80 DUP1 023F 63 PUSH4 0x095ea7b3 0244 14 EQ 0245 61 PUSH2 0x033b 0248 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033b, if 0x095ea7b3 == stack[-1] label_0249: // Incoming jump from 0x0248, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0249 stack[-1] } 0249 80 DUP1 024A 63 PUSH4 0x1581b600 024F 14 EQ 0250 61 PUSH2 0x035b 0253 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x035b, if 0x1581b600 == stack[-1] label_0254: // Incoming jump from 0x0253, if not 0x1581b600 == stack[-1] // Inputs[1] { @0257 memory[0x00:0x00] } 0254 60 PUSH1 0x00 0256 80 DUP1 0257 FD *REVERT // Stack delta = +0 // Outputs[1] { @0257 revert(memory[0x00:0x00]); } // Block terminates label_0258: // Incoming jump from 0x020C, if 0x095ea7b3 > stack[-1] // Inputs[1] { @0259 stack[-1] } 0258 5B JUMPDEST 0259 80 DUP1 025A 63 PUSH4 0x01ffc9a7 025F 14 EQ 0260 61 PUSH2 0x028a 0263 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x028a, if 0x01ffc9a7 == stack[-1] label_0264: // Incoming jump from 0x0263, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0264 stack[-1] } 0264 80 DUP1 0265 63 PUSH4 0x02329a29 026A 14 EQ 026B 61 PUSH2 0x02bf 026E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02bf, if 0x02329a29 == stack[-1] label_026F: // Incoming jump from 0x026E, if not 0x02329a29 == stack[-1] // Inputs[1] { @026F stack[-1] } 026F 80 DUP1 0270 63 PUSH4 0x06fdde03 0275 14 EQ 0276 61 PUSH2 0x02e1 0279 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e1, if 0x06fdde03 == stack[-1] label_027A: // Incoming jump from 0x0279, if not 0x06fdde03 == stack[-1] // Inputs[1] { @027A stack[-1] } 027A 80 DUP1 027B 63 PUSH4 0x081812fc 0280 14 EQ 0281 61 PUSH2 0x0303 0284 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0303, if 0x081812fc == stack[-1] label_0285: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x0284, if not 0x081812fc == stack[-1] // Inputs[1] { @0289 memory[0x00:0x00] } 0285 5B JUMPDEST 0286 60 PUSH1 0x00 0288 80 DUP1 0289 FD *REVERT // Stack delta = +0 // Outputs[1] { @0289 revert(memory[0x00:0x00]); } // Block terminates label_028A: // Incoming jump from 0x0263, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @028B msg.value } 028A 5B JUMPDEST 028B 34 CALLVALUE 028C 80 DUP1 028D 15 ISZERO 028E 61 PUSH2 0x0296 0291 57 *JUMPI // Stack delta = +1 // Outputs[1] { @028B stack[0] = msg.value } // Block ends with conditional jump to 0x0296, if !msg.value label_0292: // Incoming jump from 0x0291, if not !msg.value // Inputs[1] { @0295 memory[0x00:0x00] } 0292 60 PUSH1 0x00 0294 80 DUP1 0295 FD *REVERT // Stack delta = +0 // Outputs[1] { @0295 revert(memory[0x00:0x00]); } // Block terminates label_0296: // Incoming jump from 0x0291, if !msg.value // Inputs[1] { @029E msg.data.length } 0296 5B JUMPDEST 0297 50 POP 0298 61 PUSH2 0x02aa 029B 61 PUSH2 0x02a5 029E 36 CALLDATASIZE 029F 60 PUSH1 0x04 02A1 61 PUSH2 0x1ce4 02A4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0298 stack[-1] = 0x02aa // @029B stack[0] = 0x02a5 // @029E stack[1] = msg.data.length // @029F stack[2] = 0x04 // } // Block ends with call to 0x1ce4, returns to 0x02A5 label_02A5: // Incoming return from call to 0x1CE4 at 0x02A4 02A5 5B JUMPDEST 02A6 61 PUSH2 0x0724 02A9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0724 label_02AA: // Incoming jump from 0x0408 // Incoming return from call to 0x045F at 0x045E // Incoming jump from 0x049D // Incoming return from call to 0x06C0 at 0x06BF // Incoming return from call to 0x02A5 at 0x02A4 // Inputs[4] // { // @02AD memory[0x40:0x60] // @02AE stack[-1] // @02B9 memory[0x40:0x60] // @02BE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02AA 5B JUMPDEST 02AB 60 PUSH1 0x40 02AD 51 MLOAD 02AE 90 SWAP1 02AF 15 ISZERO 02B0 15 ISZERO 02B1 81 DUP2 02B2 52 MSTORE 02B3 60 PUSH1 0x20 02B5 01 ADD 02B6 5B JUMPDEST 02B7 60 PUSH1 0x40 02B9 51 MLOAD 02BA 80 DUP1 02BB 91 SWAP2 02BC 03 SUB 02BD 90 SWAP1 02BE F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02B2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @02BE return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02BF: // Incoming jump from 0x026E, if 0x02329a29 == stack[-1] // Inputs[1] { @02C0 msg.value } 02BF 5B JUMPDEST 02C0 34 CALLVALUE 02C1 80 DUP1 02C2 15 ISZERO 02C3 61 PUSH2 0x02cb 02C6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C0 stack[0] = msg.value } // Block ends with conditional jump to 0x02cb, if !msg.value label_02C7: // Incoming jump from 0x02C6, if not !msg.value // Inputs[1] { @02CA memory[0x00:0x00] } 02C7 60 PUSH1 0x00 02C9 80 DUP1 02CA FD *REVERT // Stack delta = +0 // Outputs[1] { @02CA revert(memory[0x00:0x00]); } // Block terminates label_02CB: // Incoming jump from 0x02C6, if !msg.value // Inputs[1] { @02D3 msg.data.length } 02CB 5B JUMPDEST 02CC 50 POP 02CD 61 PUSH2 0x02df 02D0 61 PUSH2 0x02da 02D3 36 CALLDATASIZE 02D4 60 PUSH1 0x04 02D6 61 PUSH2 0x1d16 02D9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02CD stack[-1] = 0x02df // @02D0 stack[0] = 0x02da // @02D3 stack[1] = msg.data.length // @02D4 stack[2] = 0x04 // } // Block ends with call to 0x1d16, returns to 0x02DA label_02DA: // Incoming return from call to 0x1D16 at 0x02D9 02DA 5B JUMPDEST 02DB 61 PUSH2 0x0776 02DE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0776 label_02DF: // Incoming return from call to 0x0D2F at 0x0527 // Incoming return from call to 0x0543 at 0x0542 // Incoming return from call to 0x02DA at 0x02D9 // Incoming return from call to 0x06A0 at 0x069F // Incoming return from call to 0x03E5 at 0x03E4 // Incoming return from call to 0x04EE at 0x04ED // Incoming return from call to 0x09A7 at 0x0410 // Incoming return from call to 0x0583 at 0x0582 // Incoming return from call to 0x05E9 at 0x05E8 02DF 5B JUMPDEST 02E0 00 *STOP // Stack delta = +0 // Outputs[1] { @02E0 stop(); } // Block terminates label_02E1: // Incoming jump from 0x0279, if 0x06fdde03 == stack[-1] // Inputs[1] { @02E2 msg.value } 02E1 5B JUMPDEST 02E2 34 CALLVALUE 02E3 80 DUP1 02E4 15 ISZERO 02E5 61 PUSH2 0x02ed 02E8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02E2 stack[0] = msg.value } // Block ends with conditional jump to 0x02ed, if !msg.value label_02E9: // Incoming jump from 0x02E8, if not !msg.value // Inputs[1] { @02EC memory[0x00:0x00] } 02E9 60 PUSH1 0x00 02EB 80 DUP1 02EC FD *REVERT // Stack delta = +0 // Outputs[1] { @02EC revert(memory[0x00:0x00]); } // Block terminates label_02ED: // Incoming jump from 0x02E8, if !msg.value 02ED 5B JUMPDEST 02EE 50 POP 02EF 61 PUSH2 0x02f6 02F2 61 PUSH2 0x07d6 02F5 56 *JUMP // Stack delta = +0 // Outputs[1] { @02EF stack[-1] = 0x02f6 } // Block ends with call to 0x07d6, returns to 0x02F6 label_02F6: // Incoming return from call to 0x0C05 at 0x04D2 // Incoming return from call to 0x07D6 at 0x02F5 // Incoming return from call to 0x0E78 at 0x05BA // Incoming return from call to 0x1059 at 0x0684 // Inputs[2] // { // @02F9 memory[0x40:0x60] // @02FD stack[-1] // } 02F6 5B JUMPDEST 02F7 60 PUSH1 0x40 02F9 51 MLOAD 02FA 61 PUSH2 0x02b6 02FD 91 SWAP2 02FE 90 SWAP1 02FF 61 PUSH2 0x1d89 0302 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02FD stack[-1] = 0x02b6 // @02FE stack[1] = memory[0x40:0x60] // @02FE stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1d89 label_0303: // Incoming jump from 0x0284, if 0x081812fc == stack[-1] // Inputs[1] { @0304 msg.value } 0303 5B JUMPDEST 0304 34 CALLVALUE 0305 80 DUP1 0306 15 ISZERO 0307 61 PUSH2 0x030f 030A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0304 stack[0] = msg.value } // Block ends with conditional jump to 0x030f, if !msg.value label_030B: // Incoming jump from 0x030A, if not !msg.value // Inputs[1] { @030E memory[0x00:0x00] } 030B 60 PUSH1 0x00 030D 80 DUP1 030E FD *REVERT // Stack delta = +0 // Outputs[1] { @030E revert(memory[0x00:0x00]); } // Block terminates label_030F: // Incoming jump from 0x030A, if !msg.value // Inputs[1] { @0317 msg.data.length } 030F 5B JUMPDEST 0310 50 POP 0311 61 PUSH2 0x0323 0314 61 PUSH2 0x031e 0317 36 CALLDATASIZE 0318 60 PUSH1 0x04 031A 61 PUSH2 0x1d9c 031D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0311 stack[-1] = 0x0323 // @0314 stack[0] = 0x031e // @0317 stack[1] = msg.data.length // @0318 stack[2] = 0x04 // } // Block ends with call to 0x1d9c, returns to 0x031E label_031E: // Incoming return from call to 0x1D9C at 0x031D 031E 5B JUMPDEST 031F 61 PUSH2 0x0868 0322 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0868 label_0323: // Incoming return from call to 0x031E at 0x031D // Incoming jump from 0x0382 // Incoming jump from 0x05A5 // Incoming return from call to 0x04B9 at 0x04B8 // Inputs[2] // { // @0326 memory[0x40:0x60] // @0330 stack[-1] // } 0323 5B JUMPDEST 0324 60 PUSH1 0x40 0326 51 MLOAD 0327 60 PUSH1 0x01 0329 60 PUSH1 0x01 032B 60 PUSH1 0xa0 032D 1B SHL 032E 03 SUB 032F 90 SWAP1 0330 91 SWAP2 0331 16 AND 0332 81 DUP2 0333 52 MSTORE 0334 60 PUSH1 0x20 0336 01 ADD 0337 61 PUSH2 0x02b6 033A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0333 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0336 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02b6 label_033B: // Incoming jump from 0x0248, if 0x095ea7b3 == stack[-1] // Inputs[1] { @033C msg.value } 033B 5B JUMPDEST 033C 34 CALLVALUE 033D 80 DUP1 033E 15 ISZERO 033F 61 PUSH2 0x0347 0342 57 *JUMPI // Stack delta = +1 // Outputs[1] { @033C stack[0] = msg.value } // Block ends with conditional jump to 0x0347, if !msg.value label_0343: // Incoming jump from 0x0342, if not !msg.value // Inputs[1] { @0346 memory[0x00:0x00] } 0343 60 PUSH1 0x00 0345 80 DUP1 0346 FD *REVERT // Stack delta = +0 // Outputs[1] { @0346 revert(memory[0x00:0x00]); } // Block terminates label_0347: // Incoming jump from 0x0342, if !msg.value // Inputs[1] { @034F msg.data.length } 0347 5B JUMPDEST 0348 50 POP 0349 61 PUSH2 0x02df 034C 61 PUSH2 0x0356 034F 36 CALLDATASIZE 0350 60 PUSH1 0x04 0352 61 PUSH2 0x1dcc 0355 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0349 stack[-1] = 0x02df // @034C stack[0] = 0x0356 // @034F stack[1] = msg.data.length // @0350 stack[2] = 0x04 // } // Block ends with call to 0x1dcc, returns to 0x0356 label_0356: // Incoming return from call to 0x1DCC at 0x0355 0356 5B JUMPDEST 0357 61 PUSH2 0x08ac 035A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08ac label_035B: // Incoming jump from 0x0253, if 0x1581b600 == stack[-1] // Inputs[1] { @035C msg.value } 035B 5B JUMPDEST 035C 34 CALLVALUE 035D 80 DUP1 035E 15 ISZERO 035F 61 PUSH2 0x0367 0362 57 *JUMPI // Stack delta = +1 // Outputs[1] { @035C stack[0] = msg.value } // Block ends with conditional jump to 0x0367, if !msg.value label_0363: // Incoming jump from 0x0362, if not !msg.value // Inputs[1] { @0366 memory[0x00:0x00] } 0363 60 PUSH1 0x00 0365 80 DUP1 0366 FD *REVERT // Stack delta = +0 // Outputs[1] { @0366 revert(memory[0x00:0x00]); } // Block terminates label_0367: // Incoming jump from 0x0362, if !msg.value 0367 5B JUMPDEST 0368 50 POP 0369 61 PUSH2 0x0323 036C 73 PUSH20 0x0a2c099044c088a431b78a0d6bb5a137a5663297 0381 81 DUP2 0382 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0369 stack[-1] = 0x0323 // @036C stack[0] = 0x0a2c099044c088a431b78a0d6bb5a137a5663297 // } // Block ends with unconditional jump to 0x0323 label_0383: // Incoming jump from 0x0222, if 0x18160ddd == stack[-1] // Inputs[1] { @0384 msg.value } 0383 5B JUMPDEST 0384 34 CALLVALUE 0385 80 DUP1 0386 15 ISZERO 0387 61 PUSH2 0x038f 038A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0384 stack[0] = msg.value } // Block ends with conditional jump to 0x038f, if !msg.value label_038B: // Incoming jump from 0x038A, if not !msg.value // Inputs[1] { @038E memory[0x00:0x00] } 038B 60 PUSH1 0x00 038D 80 DUP1 038E FD *REVERT // Stack delta = +0 // Outputs[1] { @038E revert(memory[0x00:0x00]); } // Block terminates label_038F: // Incoming jump from 0x038A, if !msg.value // Inputs[2] // { // @0393 storage[0x01] // @0396 storage[0x00] // } 038F 5B JUMPDEST 0390 50 POP 0391 60 PUSH1 0x01 0393 54 SLOAD 0394 60 PUSH1 0x00 0396 54 SLOAD 0397 03 SUB 0398 60 PUSH1 0x00 039A 19 NOT 039B 01 ADD // Stack delta = +0 // Outputs[1] { @039B stack[-1] = ~0x00 + (storage[0x00] - storage[0x01]) } // Block continues label_039C: // Incoming jump from 0x0639 // Incoming jump from 0x039B // Incoming jump from 0x0723 // Incoming jump from 0x066F // Incoming jump from 0x0623 // Incoming return from call to 0x050E at 0x050D // Inputs[2] // { // @039F memory[0x40:0x60] // @03A0 stack[-1] // } 039C 5B JUMPDEST 039D 60 PUSH1 0x40 039F 51 MLOAD 03A0 90 SWAP1 03A1 81 DUP2 03A2 52 MSTORE 03A3 60 PUSH1 0x20 03A5 01 ADD 03A6 61 PUSH2 0x02b6 03A9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @03A5 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02b6 label_03AA: // Incoming jump from 0x022D, if 0x23b872dd == stack[-1] // Inputs[1] { @03AB msg.value } 03AA 5B JUMPDEST 03AB 34 CALLVALUE 03AC 80 DUP1 03AD 15 ISZERO 03AE 61 PUSH2 0x03b6 03B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03AB stack[0] = msg.value } // Block ends with conditional jump to 0x03b6, if !msg.value label_03B2: // Incoming jump from 0x03B1, if not !msg.value // Inputs[1] { @03B5 memory[0x00:0x00] } 03B2 60 PUSH1 0x00 03B4 80 DUP1 03B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @03B5 revert(memory[0x00:0x00]); } // Block terminates label_03B6: // Incoming jump from 0x03B1, if !msg.value // Inputs[1] { @03BE msg.data.length } 03B6 5B JUMPDEST 03B7 50 POP 03B8 61 PUSH2 0x02df 03BB 61 PUSH2 0x03c5 03BE 36 CALLDATASIZE 03BF 60 PUSH1 0x04 03C1 61 PUSH2 0x1df6 03C4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03B8 stack[-1] = 0x02df // @03BB stack[0] = 0x03c5 // @03BE stack[1] = msg.data.length // @03BF stack[2] = 0x04 // } // Block ends with call to 0x1df6, returns to 0x03C5 label_03C5: // Incoming return from call to 0x1DF6 at 0x03C4 03C5 5B JUMPDEST 03C6 61 PUSH2 0x093a 03C9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x093a label_03CA: // Incoming jump from 0x0238, if 0x257841e7 == 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 0x02df 03DB 61 PUSH2 0x03e5 03DE 36 CALLDATASIZE 03DF 60 PUSH1 0x04 03E1 61 PUSH2 0x1d16 03E4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03D8 stack[-1] = 0x02df // @03DB stack[0] = 0x03e5 // @03DE stack[1] = msg.data.length // @03DF stack[2] = 0x04 // } // Block ends with call to 0x1d16, returns to 0x03E5 label_03E5: // Incoming return from call to 0x1D16 at 0x03E4 03E5 5B JUMPDEST 03E6 61 PUSH2 0x0945 03E9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0945 label_03EA: // Incoming jump from 0x01F1, if 0x355f2747 == 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] { @03FA storage[0x0d] } 03F6 5B JUMPDEST 03F7 50 POP 03F8 60 PUSH1 0x0d 03FA 54 SLOAD 03FB 61 PUSH2 0x02aa 03FE 90 SWAP1 03FF 61 PUSH2 0x0100 0402 90 SWAP1 0403 04 DIV 0404 60 PUSH1 0xff 0406 16 AND 0407 81 DUP2 0408 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03FE stack[-1] = 0x02aa // @0406 stack[0] = 0xff & storage[0x0d] / 0x0100 // } // Block ends with unconditional jump to 0x02aa label_0409: // Incoming jump from 0x01FC, if 0x3ccfd60b == stack[-1] 0409 5B JUMPDEST 040A 61 PUSH2 0x02df 040D 61 PUSH2 0x09a7 0410 56 *JUMP // Stack delta = +1 // Outputs[1] { @040A stack[0] = 0x02df } // Block ends with call to 0x09a7, returns to 0x02DF label_0411: // Incoming jump from 0x01CB, if 0x421357c1 == stack[-1] // Inputs[1] { @0418 msg.data.length } 0411 5B JUMPDEST 0412 61 PUSH2 0x02df 0415 61 PUSH2 0x041f 0418 36 CALLDATASIZE 0419 60 PUSH1 0x04 041B 61 PUSH2 0x1e79 041E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0412 stack[0] = 0x02df // @0415 stack[1] = 0x041f // @0418 stack[2] = msg.data.length // @0419 stack[3] = 0x04 // } // Block ends with call to 0x1e79, returns to 0x041F label_041F: // Incoming return from call to 0x1E79 at 0x041E 041F 5B JUMPDEST 0420 61 PUSH2 0x0a5b 0423 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a5b label_0424: // Incoming jump from 0x01D6, if 0x42842e0e == stack[-1] // Inputs[1] { @0425 msg.value } 0424 5B JUMPDEST 0425 34 CALLVALUE 0426 80 DUP1 0427 15 ISZERO 0428 61 PUSH2 0x0430 042B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0425 stack[0] = msg.value } // Block ends with conditional jump to 0x0430, if !msg.value label_042C: // Incoming jump from 0x042B, if not !msg.value // Inputs[1] { @042F memory[0x00:0x00] } 042C 60 PUSH1 0x00 042E 80 DUP1 042F FD *REVERT // Stack delta = +0 // Outputs[1] { @042F revert(memory[0x00:0x00]); } // Block terminates label_0430: // Incoming jump from 0x042B, if !msg.value // Inputs[1] { @0438 msg.data.length } 0430 5B JUMPDEST 0431 50 POP 0432 61 PUSH2 0x02df 0435 61 PUSH2 0x043f 0438 36 CALLDATASIZE 0439 60 PUSH1 0x04 043B 61 PUSH2 0x1df6 043E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0432 stack[-1] = 0x02df // @0435 stack[0] = 0x043f // @0438 stack[1] = msg.data.length // @0439 stack[2] = 0x04 // } // Block ends with call to 0x1df6, returns to 0x043F label_043F: // Incoming return from call to 0x1DF6 at 0x043E 043F 5B JUMPDEST 0440 61 PUSH2 0x0b6e 0443 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b6e label_0444: // Incoming jump from 0x01E1, if 0x4f558e79 == stack[-1] // Inputs[1] { @0445 msg.value } 0444 5B JUMPDEST 0445 34 CALLVALUE 0446 80 DUP1 0447 15 ISZERO 0448 61 PUSH2 0x0450 044B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0445 stack[0] = msg.value } // Block ends with conditional jump to 0x0450, if !msg.value label_044C: // Incoming jump from 0x044B, if not !msg.value // Inputs[1] { @044F memory[0x00:0x00] } 044C 60 PUSH1 0x00 044E 80 DUP1 044F FD *REVERT // Stack delta = +0 // Outputs[1] { @044F revert(memory[0x00:0x00]); } // Block terminates label_0450: // Incoming jump from 0x044B, if !msg.value // Inputs[1] { @0458 msg.data.length } 0450 5B JUMPDEST 0451 50 POP 0452 61 PUSH2 0x02aa 0455 61 PUSH2 0x045f 0458 36 CALLDATASIZE 0459 60 PUSH1 0x04 045B 61 PUSH2 0x1d9c 045E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0452 stack[-1] = 0x02aa // @0455 stack[0] = 0x045f // @0458 stack[1] = msg.data.length // @0459 stack[2] = 0x04 // } // Block ends with call to 0x1d9c, returns to 0x045F label_045F: // Incoming return from call to 0x1D9C at 0x045E 045F 5B JUMPDEST 0460 61 PUSH2 0x0b89 0463 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b89 label_0464: // Incoming jump from 0x01A5, if 0x55f804b3 == stack[-1] // Inputs[1] { @0465 msg.value } 0464 5B JUMPDEST 0465 34 CALLVALUE 0466 80 DUP1 0467 15 ISZERO 0468 61 PUSH2 0x0470 046B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0465 stack[0] = msg.value } // Block ends with conditional jump to 0x0470, if !msg.value label_046C: // Incoming jump from 0x046B, if not !msg.value // Inputs[1] { @046F memory[0x00:0x00] } 046C 60 PUSH1 0x00 046E 80 DUP1 046F FD *REVERT // Stack delta = +0 // Outputs[1] { @046F revert(memory[0x00:0x00]); } // Block terminates label_0470: // Incoming jump from 0x046B, if !msg.value // Inputs[1] { @0478 msg.data.length } 0470 5B JUMPDEST 0471 50 POP 0472 61 PUSH2 0x02df 0475 61 PUSH2 0x047f 0478 36 CALLDATASIZE 0479 60 PUSH1 0x04 047B 61 PUSH2 0x1f77 047E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0472 stack[-1] = 0x02df // @0475 stack[0] = 0x047f // @0478 stack[1] = msg.data.length // @0479 stack[2] = 0x04 // } // Block ends with call to 0x1f77, returns to 0x047F label_047F: // Incoming return from call to 0x1F77 at 0x047E 047F 5B JUMPDEST 0480 61 PUSH2 0x0b94 0483 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b94 label_0484: // Incoming jump from 0x01B0, if 0x5c975abb == 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] { @0494 storage[0x0d] } 0490 5B JUMPDEST 0491 50 POP 0492 60 PUSH1 0x0d 0494 54 SLOAD 0495 61 PUSH2 0x02aa 0498 90 SWAP1 0499 60 PUSH1 0xff 049B 16 AND 049C 81 DUP2 049D 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0498 stack[-1] = 0x02aa // @049B stack[0] = 0xff & storage[0x0d] // } // Block ends with unconditional jump to 0x02aa label_049E: // Incoming jump from 0x017F, if 0x6352211e == stack[-1] // Inputs[1] { @049F msg.value } 049E 5B JUMPDEST 049F 34 CALLVALUE 04A0 80 DUP1 04A1 15 ISZERO 04A2 61 PUSH2 0x04aa 04A5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @049F stack[0] = msg.value } // Block ends with conditional jump to 0x04aa, if !msg.value label_04A6: // Incoming jump from 0x04A5, if not !msg.value // Inputs[1] { @04A9 memory[0x00:0x00] } 04A6 60 PUSH1 0x00 04A8 80 DUP1 04A9 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A9 revert(memory[0x00:0x00]); } // Block terminates label_04AA: // Incoming jump from 0x04A5, if !msg.value // Inputs[1] { @04B2 msg.data.length } 04AA 5B JUMPDEST 04AB 50 POP 04AC 61 PUSH2 0x0323 04AF 61 PUSH2 0x04b9 04B2 36 CALLDATASIZE 04B3 60 PUSH1 0x04 04B5 61 PUSH2 0x1d9c 04B8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04AC stack[-1] = 0x0323 // @04AF stack[0] = 0x04b9 // @04B2 stack[1] = msg.data.length // @04B3 stack[2] = 0x04 // } // Block ends with call to 0x1d9c, returns to 0x04B9 label_04B9: // Incoming return from call to 0x1D9C at 0x04B8 04B9 5B JUMPDEST 04BA 61 PUSH2 0x0bf3 04BD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bf3 label_04BE: // Incoming jump from 0x018A, if 0x6c0360eb == stack[-1] // Inputs[1] { @04BF msg.value } 04BE 5B JUMPDEST 04BF 34 CALLVALUE 04C0 80 DUP1 04C1 15 ISZERO 04C2 61 PUSH2 0x04ca 04C5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04BF stack[0] = msg.value } // Block ends with conditional jump to 0x04ca, if !msg.value label_04C6: // Incoming jump from 0x04C5, if not !msg.value // Inputs[1] { @04C9 memory[0x00:0x00] } 04C6 60 PUSH1 0x00 04C8 80 DUP1 04C9 FD *REVERT // Stack delta = +0 // Outputs[1] { @04C9 revert(memory[0x00:0x00]); } // Block terminates label_04CA: // Incoming jump from 0x04C5, if !msg.value 04CA 5B JUMPDEST 04CB 50 POP 04CC 61 PUSH2 0x02f6 04CF 61 PUSH2 0x0c05 04D2 56 *JUMP // Stack delta = +0 // Outputs[1] { @04CC stack[-1] = 0x02f6 } // Block ends with call to 0x0c05, returns to 0x02F6 label_04D3: // Incoming jump from 0x0195, if 0x6f8b44b0 == stack[-1] // Inputs[1] { @04D4 msg.value } 04D3 5B JUMPDEST 04D4 34 CALLVALUE 04D5 80 DUP1 04D6 15 ISZERO 04D7 61 PUSH2 0x04df 04DA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D4 stack[0] = msg.value } // Block ends with conditional jump to 0x04df, if !msg.value label_04DB: // Incoming jump from 0x04DA, if not !msg.value // Inputs[1] { @04DE memory[0x00:0x00] } 04DB 60 PUSH1 0x00 04DD 80 DUP1 04DE FD *REVERT // Stack delta = +0 // Outputs[1] { @04DE revert(memory[0x00:0x00]); } // Block terminates label_04DF: // Incoming jump from 0x04DA, if !msg.value // Inputs[1] { @04E7 msg.data.length } 04DF 5B JUMPDEST 04E0 50 POP 04E1 61 PUSH2 0x02df 04E4 61 PUSH2 0x04ee 04E7 36 CALLDATASIZE 04E8 60 PUSH1 0x04 04EA 61 PUSH2 0x1d9c 04ED 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04E1 stack[-1] = 0x02df // @04E4 stack[0] = 0x04ee // @04E7 stack[1] = msg.data.length // @04E8 stack[2] = 0x04 // } // Block ends with call to 0x1d9c, returns to 0x04EE label_04EE: // Incoming return from call to 0x1D9C at 0x04ED 04EE 5B JUMPDEST 04EF 61 PUSH2 0x0c93 04F2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c93 label_04F3: // Incoming jump from 0x012D, if 0x70a08231 == stack[-1] // Inputs[1] { @04F4 msg.value } 04F3 5B JUMPDEST 04F4 34 CALLVALUE 04F5 80 DUP1 04F6 15 ISZERO 04F7 61 PUSH2 0x04ff 04FA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04F4 stack[0] = msg.value } // Block ends with conditional jump to 0x04ff, if !msg.value label_04FB: // Incoming jump from 0x04FA, if not !msg.value // Inputs[1] { @04FE memory[0x00:0x00] } 04FB 60 PUSH1 0x00 04FD 80 DUP1 04FE FD *REVERT // Stack delta = +0 // Outputs[1] { @04FE revert(memory[0x00:0x00]); } // Block terminates label_04FF: // Incoming jump from 0x04FA, if !msg.value // Inputs[1] { @0507 msg.data.length } 04FF 5B JUMPDEST 0500 50 POP 0501 61 PUSH2 0x039c 0504 61 PUSH2 0x050e 0507 36 CALLDATASIZE 0508 60 PUSH1 0x04 050A 61 PUSH2 0x1fc0 050D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0501 stack[-1] = 0x039c // @0504 stack[0] = 0x050e // @0507 stack[1] = msg.data.length // @0508 stack[2] = 0x04 // } // Block ends with call to 0x1fc0, returns to 0x050E label_050E: // Incoming return from call to 0x1FC0 at 0x050D 050E 5B JUMPDEST 050F 61 PUSH2 0x0ce0 0512 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ce0 label_0513: // Incoming jump from 0x0138, if 0x715018a6 == stack[-1] // Inputs[1] { @0514 msg.value } 0513 5B JUMPDEST 0514 34 CALLVALUE 0515 80 DUP1 0516 15 ISZERO 0517 61 PUSH2 0x051f 051A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0514 stack[0] = msg.value } // Block ends with conditional jump to 0x051f, if !msg.value label_051B: // Incoming jump from 0x051A, if not !msg.value // Inputs[1] { @051E memory[0x00:0x00] } 051B 60 PUSH1 0x00 051D 80 DUP1 051E FD *REVERT // Stack delta = +0 // Outputs[1] { @051E revert(memory[0x00:0x00]); } // Block terminates label_051F: // Incoming jump from 0x051A, if !msg.value 051F 5B JUMPDEST 0520 50 POP 0521 61 PUSH2 0x02df 0524 61 PUSH2 0x0d2f 0527 56 *JUMP // Stack delta = +0 // Outputs[1] { @0521 stack[-1] = 0x02df } // Block ends with call to 0x0d2f, returns to 0x02DF label_0528: // Incoming jump from 0x0143, if 0x7389fbb7 == stack[-1] // Inputs[1] { @0529 msg.value } 0528 5B JUMPDEST 0529 34 CALLVALUE 052A 80 DUP1 052B 15 ISZERO 052C 61 PUSH2 0x0534 052F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0529 stack[0] = msg.value } // Block ends with conditional jump to 0x0534, if !msg.value label_0530: // Incoming jump from 0x052F, if not !msg.value // Inputs[1] { @0533 memory[0x00:0x00] } 0530 60 PUSH1 0x00 0532 80 DUP1 0533 FD *REVERT // Stack delta = +0 // Outputs[1] { @0533 revert(memory[0x00:0x00]); } // Block terminates label_0534: // Incoming jump from 0x052F, if !msg.value // Inputs[1] { @053C msg.data.length } 0534 5B JUMPDEST 0535 50 POP 0536 61 PUSH2 0x02df 0539 61 PUSH2 0x0543 053C 36 CALLDATASIZE 053D 60 PUSH1 0x04 053F 61 PUSH2 0x1d9c 0542 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0536 stack[-1] = 0x02df // @0539 stack[0] = 0x0543 // @053C stack[1] = msg.data.length // @053D stack[2] = 0x04 // } // Block ends with call to 0x1d9c, returns to 0x0543 label_0543: // Incoming return from call to 0x1D9C at 0x0542 0543 5B JUMPDEST 0544 61 PUSH2 0x0d83 0547 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d83 label_0548: // Incoming jump from 0x014E, if 0x780cf82a == stack[-1] // Inputs[1] { @0549 msg.value } 0548 5B JUMPDEST 0549 34 CALLVALUE 054A 80 DUP1 054B 15 ISZERO 054C 61 PUSH2 0x0554 054F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0549 stack[0] = msg.value } // Block ends with conditional jump to 0x0554, if !msg.value label_0550: // Incoming jump from 0x054F, if not !msg.value // Inputs[1] { @0553 memory[0x00:0x00] } 0550 60 PUSH1 0x00 0552 80 DUP1 0553 FD *REVERT // Stack delta = +0 // Outputs[1] { @0553 revert(memory[0x00:0x00]); } // Block terminates label_0554: // Incoming jump from 0x054F, if !msg.value // Inputs[1] { @055C msg.data.length } 0554 5B JUMPDEST 0555 50 POP 0556 61 PUSH2 0x02df 0559 61 PUSH2 0x0563 055C 36 CALLDATASIZE 055D 60 PUSH1 0x04 055F 61 PUSH2 0x1f77 0562 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0556 stack[-1] = 0x02df // @0559 stack[0] = 0x0563 // @055C stack[1] = msg.data.length // @055D stack[2] = 0x04 // } // Block ends with call to 0x1f77, returns to 0x0563 label_0563: // Incoming return from call to 0x1F77 at 0x0562 0563 5B JUMPDEST 0564 61 PUSH2 0x0dd0 0567 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dd0 label_0568: // Incoming jump from 0x0112, if 0x8545f4ea == stack[-1] // Inputs[1] { @0569 msg.value } 0568 5B JUMPDEST 0569 34 CALLVALUE 056A 80 DUP1 056B 15 ISZERO 056C 61 PUSH2 0x0574 056F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0569 stack[0] = msg.value } // Block ends with conditional jump to 0x0574, if !msg.value label_0570: // Incoming jump from 0x056F, if not !msg.value // Inputs[1] { @0573 memory[0x00:0x00] } 0570 60 PUSH1 0x00 0572 80 DUP1 0573 FD *REVERT // Stack delta = +0 // Outputs[1] { @0573 revert(memory[0x00:0x00]); } // Block terminates label_0574: // Incoming jump from 0x056F, if !msg.value // Inputs[1] { @057C msg.data.length } 0574 5B JUMPDEST 0575 50 POP 0576 61 PUSH2 0x02df 0579 61 PUSH2 0x0583 057C 36 CALLDATASIZE 057D 60 PUSH1 0x04 057F 61 PUSH2 0x1d9c 0582 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0576 stack[-1] = 0x02df // @0579 stack[0] = 0x0583 // @057C stack[1] = msg.data.length // @057D stack[2] = 0x04 // } // Block ends with call to 0x1d9c, returns to 0x0583 label_0583: // Incoming return from call to 0x1D9C at 0x0582 0583 5B JUMPDEST 0584 61 PUSH2 0x0e2b 0587 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e2b label_0588: // Incoming jump from 0x011D, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0589 msg.value } 0588 5B JUMPDEST 0589 34 CALLVALUE 058A 80 DUP1 058B 15 ISZERO 058C 61 PUSH2 0x0594 058F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0589 stack[0] = msg.value } // Block ends with conditional jump to 0x0594, if !msg.value label_0590: // Incoming jump from 0x058F, if not !msg.value // Inputs[1] { @0593 memory[0x00:0x00] } 0590 60 PUSH1 0x00 0592 80 DUP1 0593 FD *REVERT // Stack delta = +0 // Outputs[1] { @0593 revert(memory[0x00:0x00]); } // Block terminates label_0594: // Incoming jump from 0x058F, if !msg.value // Inputs[1] { @0598 storage[0x08] } 0594 5B JUMPDEST 0595 50 POP 0596 60 PUSH1 0x08 0598 54 SLOAD 0599 60 PUSH1 0x01 059B 60 PUSH1 0x01 059D 60 PUSH1 0xa0 059F 1B SHL 05A0 03 SUB 05A1 16 AND 05A2 61 PUSH2 0x0323 05A5 56 *JUMP // Stack delta = +0 // Outputs[1] { @05A1 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x08] } // Block ends with unconditional jump to 0x0323 label_05A6: // Incoming jump from 0x00EC, if 0x95d89b41 == stack[-1] // Inputs[1] { @05A7 msg.value } 05A6 5B JUMPDEST 05A7 34 CALLVALUE 05A8 80 DUP1 05A9 15 ISZERO 05AA 61 PUSH2 0x05b2 05AD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05A7 stack[0] = msg.value } // Block ends with conditional jump to 0x05b2, if !msg.value label_05AE: // Incoming jump from 0x05AD, if not !msg.value // Inputs[1] { @05B1 memory[0x00:0x00] } 05AE 60 PUSH1 0x00 05B0 80 DUP1 05B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B1 revert(memory[0x00:0x00]); } // Block terminates label_05B2: // Incoming jump from 0x05AD, if !msg.value 05B2 5B JUMPDEST 05B3 50 POP 05B4 61 PUSH2 0x02f6 05B7 61 PUSH2 0x0e78 05BA 56 *JUMP // Stack delta = +0 // Outputs[1] { @05B4 stack[-1] = 0x02f6 } // Block ends with call to 0x0e78, returns to 0x02F6 label_05BB: // Incoming jump from 0x00F7, if 0xa0712d68 == stack[-1] // Inputs[1] { @05C2 msg.data.length } 05BB 5B JUMPDEST 05BC 61 PUSH2 0x02df 05BF 61 PUSH2 0x05c9 05C2 36 CALLDATASIZE 05C3 60 PUSH1 0x04 05C5 61 PUSH2 0x1d9c 05C8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05BC stack[0] = 0x02df // @05BF stack[1] = 0x05c9 // @05C2 stack[2] = msg.data.length // @05C3 stack[3] = 0x04 // } // Block ends with call to 0x1d9c, returns to 0x05C9 label_05C9: // Incoming return from call to 0x1D9C at 0x05C8 05C9 5B JUMPDEST 05CA 61 PUSH2 0x0e87 05CD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e87 label_05CE: // Incoming jump from 0x0102, if 0xa22cb465 == stack[-1] // Inputs[1] { @05CF msg.value } 05CE 5B JUMPDEST 05CF 34 CALLVALUE 05D0 80 DUP1 05D1 15 ISZERO 05D2 61 PUSH2 0x05da 05D5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05CF stack[0] = msg.value } // Block ends with conditional jump to 0x05da, if !msg.value label_05D6: // Incoming jump from 0x05D5, if not !msg.value // Inputs[1] { @05D9 memory[0x00:0x00] } 05D6 60 PUSH1 0x00 05D8 80 DUP1 05D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @05D9 revert(memory[0x00:0x00]); } // Block terminates label_05DA: // Incoming jump from 0x05D5, if !msg.value // Inputs[1] { @05E2 msg.data.length } 05DA 5B JUMPDEST 05DB 50 POP 05DC 61 PUSH2 0x02df 05DF 61 PUSH2 0x05e9 05E2 36 CALLDATASIZE 05E3 60 PUSH1 0x04 05E5 61 PUSH2 0x1fdb 05E8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05DC stack[-1] = 0x02df // @05DF stack[0] = 0x05e9 // @05E2 stack[1] = msg.data.length // @05E3 stack[2] = 0x04 // } // Block ends with call to 0x1fdb, returns to 0x05E9 label_05E9: // Incoming return from call to 0x1FDB at 0x05E8 05E9 5B JUMPDEST 05EA 61 PUSH2 0x0f3e 05ED 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f3e label_05EE: // Incoming jump from 0x00BB, if 0xb88d4fde == stack[-1] // Inputs[1] { @05EF msg.value } 05EE 5B JUMPDEST 05EF 34 CALLVALUE 05F0 80 DUP1 05F1 15 ISZERO 05F2 61 PUSH2 0x05fa 05F5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05EF stack[0] = msg.value } // Block ends with conditional jump to 0x05fa, if !msg.value label_05F6: // Incoming jump from 0x05F5, if not !msg.value // Inputs[1] { @05F9 memory[0x00:0x00] } 05F6 60 PUSH1 0x00 05F8 80 DUP1 05F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @05F9 revert(memory[0x00:0x00]); } // Block terminates label_05FA: // Incoming jump from 0x05F5, if !msg.value // Inputs[1] { @0602 msg.data.length } 05FA 5B JUMPDEST 05FB 50 POP 05FC 61 PUSH2 0x02df 05FF 61 PUSH2 0x0609 0602 36 CALLDATASIZE 0603 60 PUSH1 0x04 0605 61 PUSH2 0x200e 0608 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05FC stack[-1] = 0x02df // @05FF stack[0] = 0x0609 // @0602 stack[1] = msg.data.length // @0603 stack[2] = 0x04 // } // Block ends with call to 0x200e, returns to 0x0609 label_0609: // Incoming return from call to 0x200E at 0x0608 0609 5B JUMPDEST 060A 61 PUSH2 0x0fd4 060D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fd4 label_060E: // Incoming jump from 0x00C6, if 0xbdb4b848 == stack[-1] // Inputs[1] { @060F msg.value } 060E 5B JUMPDEST 060F 34 CALLVALUE 0610 80 DUP1 0611 15 ISZERO 0612 61 PUSH2 0x061a 0615 57 *JUMPI // Stack delta = +1 // Outputs[1] { @060F stack[0] = msg.value } // Block ends with conditional jump to 0x061a, if !msg.value label_0616: // Incoming jump from 0x0615, if not !msg.value // Inputs[1] { @0619 memory[0x00:0x00] } 0616 60 PUSH1 0x00 0618 80 DUP1 0619 FD *REVERT // Stack delta = +0 // Outputs[1] { @0619 revert(memory[0x00:0x00]); } // Block terminates label_061A: // Incoming jump from 0x0615, if !msg.value // Inputs[1] { @0621 storage[0x0a] } 061A 5B JUMPDEST 061B 50 POP 061C 61 PUSH2 0x039c 061F 60 PUSH1 0x0a 0621 54 SLOAD 0622 81 DUP2 0623 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @061C stack[-1] = 0x039c // @0621 stack[0] = storage[0x0a] // } // Block ends with unconditional jump to 0x039c label_0624: // Incoming jump from 0x0095, if 0xc285e107 == stack[-1] // Inputs[1] { @0625 msg.value } 0624 5B JUMPDEST 0625 34 CALLVALUE 0626 80 DUP1 0627 15 ISZERO 0628 61 PUSH2 0x0630 062B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0625 stack[0] = msg.value } // Block ends with conditional jump to 0x0630, if !msg.value label_062C: // Incoming jump from 0x062B, if not !msg.value // Inputs[1] { @062F memory[0x00:0x00] } 062C 60 PUSH1 0x00 062E 80 DUP1 062F FD *REVERT // Stack delta = +0 // Outputs[1] { @062F revert(memory[0x00:0x00]); } // Block terminates label_0630: // Incoming jump from 0x062B, if !msg.value // Inputs[1] { @0637 storage[0x0c] } 0630 5B JUMPDEST 0631 50 POP 0632 61 PUSH2 0x039c 0635 60 PUSH1 0x0c 0637 54 SLOAD 0638 81 DUP2 0639 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0632 stack[-1] = 0x039c // @0637 stack[0] = storage[0x0c] // } // Block ends with unconditional jump to 0x039c label_063A: // Incoming jump from 0x00A0, if 0xc87b56dd == stack[-1] // Inputs[1] { @063B msg.value } 063A 5B JUMPDEST 063B 34 CALLVALUE 063C 80 DUP1 063D 15 ISZERO 063E 61 PUSH2 0x0646 0641 57 *JUMPI // Stack delta = +1 // Outputs[1] { @063B stack[0] = msg.value } // Block ends with conditional jump to 0x0646, if !msg.value label_0642: // Incoming jump from 0x0641, if not !msg.value // Inputs[1] { @0645 memory[0x00:0x00] } 0642 60 PUSH1 0x00 0644 80 DUP1 0645 FD *REVERT // Stack delta = +0 // Outputs[1] { @0645 revert(memory[0x00:0x00]); } // Block terminates label_0646: // Incoming jump from 0x0641, if !msg.value // Inputs[1] { @064E msg.data.length } 0646 5B JUMPDEST 0647 50 POP 0648 61 PUSH2 0x02f6 064B 61 PUSH2 0x0655 064E 36 CALLDATASIZE 064F 60 PUSH1 0x04 0651 61 PUSH2 0x1d9c 0654 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0648 stack[-1] = 0x02f6 // @064B stack[0] = 0x0655 // @064E stack[1] = msg.data.length // @064F stack[2] = 0x04 // } // Block ends with call to 0x1d9c, returns to 0x0655 label_0655: // Incoming return from call to 0x1D9C at 0x0654 0655 5B JUMPDEST 0656 61 PUSH2 0x1025 0659 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1025 label_065A: // Incoming jump from 0x00AB, if 0xd5abeb01 == stack[-1] // Inputs[1] { @065B msg.value } 065A 5B JUMPDEST 065B 34 CALLVALUE 065C 80 DUP1 065D 15 ISZERO 065E 61 PUSH2 0x0666 0661 57 *JUMPI // Stack delta = +1 // Outputs[1] { @065B stack[0] = msg.value } // Block ends with conditional jump to 0x0666, if !msg.value label_0662: // Incoming jump from 0x0661, if not !msg.value // Inputs[1] { @0665 memory[0x00:0x00] } 0662 60 PUSH1 0x00 0664 80 DUP1 0665 FD *REVERT // Stack delta = +0 // Outputs[1] { @0665 revert(memory[0x00:0x00]); } // Block terminates label_0666: // Incoming jump from 0x0661, if !msg.value // Inputs[1] { @066D storage[0x09] } 0666 5B JUMPDEST 0667 50 POP 0668 61 PUSH2 0x039c 066B 60 PUSH1 0x09 066D 54 SLOAD 066E 81 DUP2 066F 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0668 stack[-1] = 0x039c // @066D stack[0] = storage[0x09] // } // Block ends with unconditional jump to 0x039c label_0670: // Incoming jump from 0x006F, if 0xdb97d4f8 == stack[-1] // Inputs[1] { @0671 msg.value } 0670 5B JUMPDEST 0671 34 CALLVALUE 0672 80 DUP1 0673 15 ISZERO 0674 61 PUSH2 0x067c 0677 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0671 stack[0] = msg.value } // Block ends with conditional jump to 0x067c, if !msg.value label_0678: // Incoming jump from 0x0677, if not !msg.value // Inputs[1] { @067B memory[0x00:0x00] } 0678 60 PUSH1 0x00 067A 80 DUP1 067B FD *REVERT // Stack delta = +0 // Outputs[1] { @067B revert(memory[0x00:0x00]); } // Block terminates label_067C: // Incoming jump from 0x0677, if !msg.value 067C 5B JUMPDEST 067D 50 POP 067E 61 PUSH2 0x02f6 0681 61 PUSH2 0x1059 0684 56 *JUMP // Stack delta = +0 // Outputs[1] { @067E stack[-1] = 0x02f6 } // Block ends with call to 0x1059, returns to 0x02F6 label_0685: // Incoming jump from 0x007A, if 0xdd108ab5 == stack[-1] // Inputs[1] { @0686 msg.value } 0685 5B JUMPDEST 0686 34 CALLVALUE 0687 80 DUP1 0688 15 ISZERO 0689 61 PUSH2 0x0691 068C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0686 stack[0] = msg.value } // Block ends with conditional jump to 0x0691, if !msg.value label_068D: // Incoming jump from 0x068C, if not !msg.value // Inputs[1] { @0690 memory[0x00:0x00] } 068D 60 PUSH1 0x00 068F 80 DUP1 0690 FD *REVERT // Stack delta = +0 // Outputs[1] { @0690 revert(memory[0x00:0x00]); } // Block terminates label_0691: // Incoming jump from 0x068C, if !msg.value // Inputs[1] { @0699 msg.data.length } 0691 5B JUMPDEST 0692 50 POP 0693 61 PUSH2 0x02df 0696 61 PUSH2 0x06a0 0699 36 CALLDATASIZE 069A 60 PUSH1 0x04 069C 61 PUSH2 0x1d9c 069F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0693 stack[-1] = 0x02df // @0696 stack[0] = 0x06a0 // @0699 stack[1] = msg.data.length // @069A stack[2] = 0x04 // } // Block ends with call to 0x1d9c, returns to 0x06A0 label_06A0: // Incoming return from call to 0x1D9C at 0x069F 06A0 5B JUMPDEST 06A1 61 PUSH2 0x1066 06A4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1066 label_06A5: // Incoming jump from 0x0049, if 0xe985e9c5 == stack[-1] // Inputs[1] { @06A6 msg.value } 06A5 5B JUMPDEST 06A6 34 CALLVALUE 06A7 80 DUP1 06A8 15 ISZERO 06A9 61 PUSH2 0x06b1 06AC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06A6 stack[0] = msg.value } // Block ends with conditional jump to 0x06b1, if !msg.value label_06AD: // Incoming jump from 0x06AC, if not !msg.value // Inputs[1] { @06B0 memory[0x00:0x00] } 06AD 60 PUSH1 0x00 06AF 80 DUP1 06B0 FD *REVERT // Stack delta = +0 // Outputs[1] { @06B0 revert(memory[0x00:0x00]); } // Block terminates label_06B1: // Incoming jump from 0x06AC, if !msg.value // Inputs[1] { @06B9 msg.data.length } 06B1 5B JUMPDEST 06B2 50 POP 06B3 61 PUSH2 0x02aa 06B6 61 PUSH2 0x06c0 06B9 36 CALLDATASIZE 06BA 60 PUSH1 0x04 06BC 61 PUSH2 0x208a 06BF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06B3 stack[-1] = 0x02aa // @06B6 stack[0] = 0x06c0 // @06B9 stack[1] = msg.data.length // @06BA stack[2] = 0x04 // } // Block ends with call to 0x208a, returns to 0x06C0 label_06C0: // Incoming return from call to 0x208A at 0x06BF // Incoming call from 0x176F, returns to 0x1770 // Incoming call from 0x1290, returns to 0x1291 // Incoming call from 0x0909, returns to 0x090A // Inputs[6] // { // @06C9 stack[-2] // @06DC memory[0x00:0x40] // @06DD stack[-1] // @06E7 memory[0x00:0x40] // @06E8 storage[keccak256(memory[0x00:0x40])] // @06EC stack[-3] // } 06C0 5B JUMPDEST 06C1 60 PUSH1 0x01 06C3 60 PUSH1 0x01 06C5 60 PUSH1 0xa0 06C7 1B SHL 06C8 03 SUB 06C9 91 SWAP2 06CA 82 DUP3 06CB 16 AND 06CC 60 PUSH1 0x00 06CE 90 SWAP1 06CF 81 DUP2 06D0 52 MSTORE 06D1 60 PUSH1 0x07 06D3 60 PUSH1 0x20 06D5 90 SWAP1 06D6 81 DUP2 06D7 52 MSTORE 06D8 60 PUSH1 0x40 06DA 80 DUP1 06DB 83 DUP4 06DC 20 SHA3 06DD 93 SWAP4 06DE 90 SWAP1 06DF 94 SWAP5 06E0 16 AND 06E1 82 DUP3 06E2 52 MSTORE 06E3 91 SWAP2 06E4 90 SWAP1 06E5 91 SWAP2 06E6 52 MSTORE 06E7 20 SHA3 06E8 54 SLOAD 06E9 60 PUSH1 0xff 06EB 16 AND 06EC 90 SWAP1 06ED 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @06D0 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @06D7 memory[0x20:0x40] = 0x07 // @06E2 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @06E6 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @06EC stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_06EE: // Incoming jump from 0x0054, if 0xf2fde38b == stack[-1] // Inputs[1] { @06EF msg.value } 06EE 5B JUMPDEST 06EF 34 CALLVALUE 06F0 80 DUP1 06F1 15 ISZERO 06F2 61 PUSH2 0x06fa 06F5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06EF stack[0] = msg.value } // Block ends with conditional jump to 0x06fa, if !msg.value label_06F6: // Incoming jump from 0x06F5, if not !msg.value // Inputs[1] { @06F9 memory[0x00:0x00] } 06F6 60 PUSH1 0x00 06F8 80 DUP1 06F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @06F9 revert(memory[0x00:0x00]); } // Block terminates label_06FA: // Incoming jump from 0x06F5, if !msg.value // Inputs[1] { @0702 msg.data.length } 06FA 5B JUMPDEST 06FB 50 POP 06FC 61 PUSH2 0x02df 06FF 61 PUSH2 0x0709 0702 36 CALLDATASIZE 0703 60 PUSH1 0x04 0705 61 PUSH2 0x1fc0 0708 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06FC stack[-1] = 0x02df // @06FF stack[0] = 0x0709 // @0702 stack[1] = msg.data.length // @0703 stack[2] = 0x04 // } // Block ends with call to 0x1fc0, returns to 0x0709 label_0709: // Incoming return from call to 0x1FC0 at 0x0708 0709 5B JUMPDEST 070A 61 PUSH2 0x10b3 070D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10b3 label_070E: // Incoming jump from 0x005F, if 0xfb5d18cd == stack[-1] // Inputs[1] { @070F msg.value } 070E 5B JUMPDEST 070F 34 CALLVALUE 0710 80 DUP1 0711 15 ISZERO 0712 61 PUSH2 0x071a 0715 57 *JUMPI // Stack delta = +1 // Outputs[1] { @070F stack[0] = msg.value } // Block ends with conditional jump to 0x071a, if !msg.value label_0716: // Incoming jump from 0x0715, if not !msg.value // Inputs[1] { @0719 memory[0x00:0x00] } 0716 60 PUSH1 0x00 0718 80 DUP1 0719 FD *REVERT // Stack delta = +0 // Outputs[1] { @0719 revert(memory[0x00:0x00]); } // Block terminates label_071A: // Incoming jump from 0x0715, if !msg.value // Inputs[1] { @0721 storage[0x0b] } 071A 5B JUMPDEST 071B 50 POP 071C 61 PUSH2 0x039c 071F 60 PUSH1 0x0b 0721 54 SLOAD 0722 81 DUP2 0723 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @071C stack[-1] = 0x039c // @0721 stack[0] = storage[0x0b] // } // Block ends with unconditional jump to 0x039c label_0724: // Incoming jump from 0x02A9 // Inputs[1] { @0730 stack[-1] } 0724 5B JUMPDEST 0725 60 PUSH1 0x00 0727 60 PUSH1 0x01 0729 60 PUSH1 0x01 072B 60 PUSH1 0xe0 072D 1B SHL 072E 03 SUB 072F 19 NOT 0730 82 DUP3 0731 16 AND 0732 63 PUSH4 0x80ac58cd 0737 60 PUSH1 0xe0 0739 1B SHL 073A 14 EQ 073B 80 DUP1 073C 61 PUSH2 0x0755 073F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0725 stack[0] = 0x00 // @073A stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0755, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_0740: // Incoming jump from 0x073F, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @074A stack[-3] } 0740 50 POP 0741 60 PUSH1 0x01 0743 60 PUSH1 0x01 0745 60 PUSH1 0xe0 0747 1B SHL 0748 03 SUB 0749 19 NOT 074A 82 DUP3 074B 16 AND 074C 63 PUSH4 0x5b5e139f 0751 60 PUSH1 0xe0 0753 1B SHL 0754 14 EQ 0755 5B JUMPDEST 0756 80 DUP1 0757 61 PUSH2 0x0770 075A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0754 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0770, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_075B: // Incoming jump from 0x075A, if not stack[-1] // Incoming jump from 0x075A, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @076D stack[-3] } 075B 50 POP 075C 63 PUSH4 0x01ffc9a7 0761 60 PUSH1 0xe0 0763 1B SHL 0764 60 PUSH1 0x01 0766 60 PUSH1 0x01 0768 60 PUSH1 0xe0 076A 1B SHL 076B 03 SUB 076C 19 NOT 076D 83 DUP4 076E 16 AND 076F 14 EQ // Stack delta = +0 // Outputs[1] { @076F stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block continues label_0770: // Incoming jump from 0x075A, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x11A9, if !stack[-1] // Incoming jump from 0x075A, if stack[-1] // Incoming jump from 0x11A9, if !(stack[-3] < storage[0x00]) // Incoming return from call to 0x118F at 0x0B93 // Incoming jump from 0x076F // Inputs[3] // { // @0771 stack[-4] // @0771 stack[-1] // @0772 stack[-3] // } 0770 5B JUMPDEST 0771 92 SWAP3 0772 91 SWAP2 0773 50 POP 0774 50 POP 0775 56 *JUMP // Stack delta = -3 // Outputs[1] { @0771 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0776: // Incoming jump from 0x02DE // Inputs[2] // { // @0779 storage[0x08] // @0783 msg.sender // } 0776 5B JUMPDEST 0777 60 PUSH1 0x08 0779 54 SLOAD 077A 60 PUSH1 0x01 077C 60 PUSH1 0x01 077E 60 PUSH1 0xa0 0780 1B SHL 0781 03 SUB 0782 16 AND 0783 33 CALLER 0784 14 EQ 0785 61 PUSH2 0x07c3 0788 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07c3, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0789: // Incoming jump from 0x0788, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @078B memory[0x40:0x60] // @07A6 memory[0x00:0x20] // @07AF memory[0x00:0x20] // } 0789 60 PUSH1 0x40 078B 51 MLOAD 078C 62 PUSH3 0x461bcd 0790 60 PUSH1 0xe5 0792 1B SHL 0793 81 DUP2 0794 52 MSTORE 0795 60 PUSH1 0x20 0797 60 PUSH1 0x04 0799 82 DUP3 079A 01 ADD 079B 81 DUP2 079C 90 SWAP1 079D 52 MSTORE 079E 60 PUSH1 0x24 07A0 82 DUP3 07A1 01 ADD 07A2 52 MSTORE 07A3 60 PUSH1 0x00 07A5 80 DUP1 07A6 51 MLOAD 07A7 60 PUSH1 0x20 07A9 61 PUSH2 0x22fc 07AC 83 DUP4 07AD 39 CODECOPY 07AE 81 DUP2 07AF 51 MLOAD 07B0 91 SWAP2 07B1 52 MSTORE 07B2 60 PUSH1 0x44 07B4 82 DUP3 07B5 01 ADD 07B6 52 MSTORE 07B7 60 PUSH1 0x64 07B9 01 ADD // Stack delta = +1 // Outputs[7] // { // @0794 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @079D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @07A2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @07AD memory[0x00:0x20] = code[0x22fc:0x231c] // @07B1 memory[0x00:0x20] = memory[0x00:0x20] // @07B6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @07B9 stack[0] = 0x64 + memory[0x40:0x60] // } // Block continues label_07BA: // Incoming jump from 0x10FA // Incoming jump from 0x09EE // Incoming jump from 0x1176 // Incoming jump from 0x098C // Incoming jump from 0x10AD // Incoming jump from 0x0D76 // Incoming jump from 0x07B9 // Incoming jump from 0x0DCA // Incoming jump from 0x0BDB // Incoming jump from 0x0E17 // Incoming jump from 0x0CDA // Incoming jump from 0x0E72 // Inputs[3] // { // @07BD memory[0x40:0x60] // @07BF stack[-1] // @07C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 07BA 5B JUMPDEST 07BB 60 PUSH1 0x40 07BD 51 MLOAD 07BE 80 DUP1 07BF 91 SWAP2 07C0 03 SUB 07C1 90 SWAP1 07C2 FD *REVERT // Stack delta = -1 // Outputs[1] { @07C2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_07C3: // Incoming jump from 0x0788, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @07C7 storage[0x0d] // @07CC stack[-1] // @07D5 stack[-2] // } 07C3 5B JUMPDEST 07C4 60 PUSH1 0x0d 07C6 80 DUP1 07C7 54 SLOAD 07C8 60 PUSH1 0xff 07CA 19 NOT 07CB 16 AND 07CC 91 SWAP2 07CD 15 ISZERO 07CE 15 ISZERO 07CF 91 SWAP2 07D0 90 SWAP1 07D1 91 SWAP2 07D2 17 OR 07D3 90 SWAP1 07D4 55 SSTORE 07D5 56 *JUMP // Stack delta = -2 // Outputs[1] { @07D4 storage[0x0d] = !!stack[-1] | (~0xff & storage[0x0d]) } // Block ends with unconditional jump to stack[-2] label_07D6: // Incoming call from 0x02F5, returns to 0x02F6 // Inputs[1] { @07DC storage[0x02] } 07D6 5B JUMPDEST 07D7 60 PUSH1 0x60 07D9 60 PUSH1 0x02 07DB 80 DUP1 07DC 54 SLOAD 07DD 61 PUSH2 0x07e5 07E0 90 SWAP1 07E1 61 PUSH2 0x20b4 07E4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @07D7 stack[0] = 0x60 // @07D9 stack[1] = 0x02 // @07E0 stack[2] = 0x07e5 // @07E0 stack[3] = storage[0x02] // } // Block ends with call to 0x20b4, returns to 0x07E5 label_07E5: // Incoming return from call to 0x20B4 at 0x07E4 // Incoming return from call to 0x20B4 at 0x0E86 // Incoming return from call to 0x20B4 at 0x194D // Inputs[4] // { // @07E6 stack[-1] // @07F5 memory[0x40:0x60] // @07FD stack[-2] // @0808 storage[stack[-2]] // } 07E5 5B JUMPDEST 07E6 80 DUP1 07E7 60 PUSH1 0x1f 07E9 01 ADD 07EA 60 PUSH1 0x20 07EC 80 DUP1 07ED 91 SWAP2 07EE 04 DIV 07EF 02 MUL 07F0 60 PUSH1 0x20 07F2 01 ADD 07F3 60 PUSH1 0x40 07F5 51 MLOAD 07F6 90 SWAP1 07F7 81 DUP2 07F8 01 ADD 07F9 60 PUSH1 0x40 07FB 52 MSTORE 07FC 80 DUP1 07FD 92 SWAP3 07FE 91 SWAP2 07FF 90 SWAP1 0800 81 DUP2 0801 81 DUP2 0802 52 MSTORE 0803 60 PUSH1 0x20 0805 01 ADD 0806 82 DUP3 0807 80 DUP1 0808 54 SLOAD 0809 61 PUSH2 0x0811 080C 90 SWAP1 080D 61 PUSH2 0x20b4 0810 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @07FB memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @07FD stack[-2] = memory[0x40:0x60] // @07FE stack[-1] = stack[-2] // @07FF stack[0] = stack[-1] // @0802 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0805 stack[1] = 0x20 + memory[0x40:0x60] // @0806 stack[2] = stack[-2] // @080C stack[4] = storage[stack[-2]] // @080C stack[3] = 0x0811 // } // Block ends with call to 0x20b4, returns to 0x0811 label_0811: // Incoming return from call to 0x20B4 at 0x0810 // Inputs[1] { @0812 stack[-1] } 0811 5B JUMPDEST 0812 80 DUP1 0813 15 ISZERO 0814 61 PUSH2 0x085e 0817 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x085e, if !stack[-1] label_0818: // Incoming jump from 0x0817, if not !stack[-1] // Inputs[1] { @0818 stack[-1] } 0818 80 DUP1 0819 60 PUSH1 0x1f 081B 10 LT 081C 61 PUSH2 0x0833 081F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0833, if 0x1f < stack[-1] label_0820: // Incoming jump from 0x081F, if not 0x1f < stack[-1] // Inputs[4] // { // @0824 stack[-2] // @0825 storage[stack[-2]] // @0828 stack[-3] // @082A stack[-1] // } 0820 61 PUSH2 0x0100 0823 80 DUP1 0824 83 DUP4 0825 54 SLOAD 0826 04 DIV 0827 02 MUL 0828 83 DUP4 0829 52 MSTORE 082A 91 SWAP2 082B 60 PUSH1 0x20 082D 01 ADD 082E 91 SWAP2 082F 61 PUSH2 0x085e 0832 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0829 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @082E stack[-1] = stack[-1] // @082E stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x085e label_0833: // Incoming jump from 0x081F, if 0x1f < stack[-1] // Inputs[5] // { // @0834 stack[-3] // @0835 stack[-1] // @0837 stack[-2] // @083F memory[0x00:0x20] // @0843 storage[keccak256(memory[0x00:0x20])] // } 0833 5B JUMPDEST 0834 82 DUP3 0835 01 ADD 0836 91 SWAP2 0837 90 SWAP1 0838 60 PUSH1 0x00 083A 52 MSTORE 083B 60 PUSH1 0x20 083D 60 PUSH1 0x00 083F 20 SHA3 0840 90 SWAP1 0841 5B JUMPDEST 0842 81 DUP2 0843 54 SLOAD 0844 81 DUP2 0845 52 MSTORE 0846 90 SWAP1 0847 60 PUSH1 0x01 0849 01 ADD 084A 90 SWAP1 084B 60 PUSH1 0x20 084D 01 ADD 084E 80 DUP1 084F 83 DUP4 0850 11 GT 0851 61 PUSH2 0x0841 0854 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0836 stack[-3] = stack[-3] + stack[-1] // @083A memory[0x00:0x20] = stack[-2] // @0845 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @084A stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @084D stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0841, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0855: // Incoming jump from 0x0854, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0854, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0855 stack[-3] // @0856 stack[-1] // } 0855 82 DUP3 0856 90 SWAP1 0857 03 SUB 0858 60 PUSH1 0x1f 085A 16 AND 085B 82 DUP3 085C 01 ADD 085D 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @085D stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @085D stack[-1] = stack[-3] // } // Block continues label_085E: // Incoming jump from 0x0832 // Incoming jump from 0x085D // Incoming jump from 0x0817, if !stack[-1] // Inputs[3] // { // @0864 stack[-6] // @0864 stack[-7] // @0866 stack[-8] // } 085E 5B JUMPDEST 085F 50 POP 0860 50 POP 0861 50 POP 0862 50 POP 0863 50 POP 0864 90 SWAP1 0865 50 POP 0866 90 SWAP1 0867 56 *JUMP // Stack delta = -7 // Outputs[1] { @0866 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0868: // Incoming jump from 0x0322 // Incoming call from 0x177F, returns to 0x1780 // Incoming call from 0x12A0, returns to 0x12A1 // Inputs[1] { @086E stack[-1] } 0868 5B JUMPDEST 0869 60 PUSH1 0x00 086B 61 PUSH2 0x0873 086E 82 DUP3 086F 61 PUSH2 0x118f 0872 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0869 stack[0] = 0x00 // @086B stack[1] = 0x0873 // @086E stack[2] = stack[-1] // } // Block ends with call to 0x118f, returns to 0x0873 label_0873: // Incoming return from call to 0x118F at 0x0872 // Inputs[1] { @0877 stack[-1] } 0873 5B JUMPDEST 0874 61 PUSH2 0x0890 0877 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0890, if stack[-1] label_0878: // Incoming jump from 0x0877, if not stack[-1] // Inputs[3] // { // @087A memory[0x40:0x60] // @088A memory[0x40:0x60] // @088F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0878 60 PUSH1 0x40 087A 51 MLOAD 087B 63 PUSH4 0x33d1c039 0880 60 PUSH1 0xe2 0882 1B SHL 0883 81 DUP2 0884 52 MSTORE 0885 60 PUSH1 0x04 0887 01 ADD 0888 60 PUSH1 0x40 088A 51 MLOAD 088B 80 DUP1 088C 91 SWAP2 088D 03 SUB 088E 90 SWAP1 088F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0884 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x33d1c039 << 0xe2 // @088F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0890: // Incoming jump from 0x0877, if stack[-1] // Inputs[4] // { // @0894 stack[-2] // @089F memory[0x00:0x40] // @08A0 storage[keccak256(memory[0x00:0x40])] // @08AA stack[-3] // } 0890 5B JUMPDEST 0891 50 POP 0892 60 PUSH1 0x00 0894 90 SWAP1 0895 81 DUP2 0896 52 MSTORE 0897 60 PUSH1 0x06 0899 60 PUSH1 0x20 089B 52 MSTORE 089C 60 PUSH1 0x40 089E 90 SWAP1 089F 20 SHA3 08A0 54 SLOAD 08A1 60 PUSH1 0x01 08A3 60 PUSH1 0x01 08A5 60 PUSH1 0xa0 08A7 1B SHL 08A8 03 SUB 08A9 16 AND 08AA 90 SWAP1 08AB 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0896 memory[0x00:0x20] = stack[-2] // @089B memory[0x20:0x40] = 0x06 // @08AA stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_08AC: // Incoming jump from 0x035A // Inputs[1] { @08B2 stack[-1] } 08AC 5B JUMPDEST 08AD 60 PUSH1 0x00 08AF 61 PUSH2 0x08b7 08B2 82 DUP3 08B3 61 PUSH2 0x0bf3 08B6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @08AD stack[0] = 0x00 // @08AF stack[1] = 0x08b7 // @08B2 stack[2] = stack[-1] // } // Block ends with call to 0x0bf3, returns to 0x08B7 label_08B7: // Incoming return from call to 0x0BF3 at 0x08B6 // Inputs[3] // { // @08B8 stack[-2] // @08B8 stack[-1] // @08C4 stack[-4] // } 08B7 5B JUMPDEST 08B8 90 SWAP1 08B9 50 POP 08BA 80 DUP1 08BB 60 PUSH1 0x01 08BD 60 PUSH1 0x01 08BF 60 PUSH1 0xa0 08C1 1B SHL 08C2 03 SUB 08C3 16 AND 08C4 83 DUP4 08C5 60 PUSH1 0x01 08C7 60 PUSH1 0x01 08C9 60 PUSH1 0xa0 08CB 1B SHL 08CC 03 SUB 08CD 16 AND 08CE 14 EQ 08CF 15 ISZERO 08D0 61 PUSH2 0x08ec 08D3 57 *JUMPI // Stack delta = -1 // Outputs[1] { @08B8 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x08ec, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_08D4: // Incoming jump from 0x08D3, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @08D6 memory[0x40:0x60] // @08E6 memory[0x40:0x60] // @08EB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 08D4 60 PUSH1 0x40 08D6 51 MLOAD 08D7 63 PUSH4 0x250fdee3 08DC 60 PUSH1 0xe2 08DE 1B SHL 08DF 81 DUP2 08E0 52 MSTORE 08E1 60 PUSH1 0x04 08E3 01 ADD 08E4 60 PUSH1 0x40 08E6 51 MLOAD 08E7 80 DUP1 08E8 91 SWAP2 08E9 03 SUB 08EA 90 SWAP1 08EB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @08E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x250fdee3 << 0xe2 // @08EB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_08EC: // Incoming jump from 0x08D3, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @08ED msg.sender // @08F6 stack[-1] // } 08EC 5B JUMPDEST 08ED 33 CALLER 08EE 60 PUSH1 0x01 08F0 60 PUSH1 0x01 08F2 60 PUSH1 0xa0 08F4 1B SHL 08F5 03 SUB 08F6 82 DUP3 08F7 16 AND 08F8 14 EQ 08F9 80 DUP1 08FA 15 ISZERO 08FB 90 SWAP1 08FC 61 PUSH2 0x090c 08FF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08FB stack[0] = !(stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender) } // Block ends with conditional jump to 0x090c, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_0900: // Incoming jump from 0x08FF, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0904 stack[-2] // @0905 msg.sender // } 0900 50 POP 0901 61 PUSH2 0x090a 0904 81 DUP2 0905 33 CALLER 0906 61 PUSH2 0x06c0 0909 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0901 stack[-1] = 0x090a // @0904 stack[0] = stack[-2] // @0905 stack[1] = msg.sender // } // Block ends with call to 0x06c0, returns to 0x090A label_090A: // Incoming return from call to 0x06C0 at 0x0909 // Inputs[1] { @090B stack[-1] } 090A 5B JUMPDEST 090B 15 ISZERO // Stack delta = +0 // Outputs[1] { @090B stack[-1] = !stack[-1] } // Block continues label_090C: // Incoming jump from 0x090B // Incoming jump from 0x08FF, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @090D stack[-1] } 090C 5B JUMPDEST 090D 15 ISZERO 090E 61 PUSH2 0x092a 0911 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x092a, if !stack[-1] label_0912: // Incoming jump from 0x0911, if not !stack[-1] // Inputs[3] // { // @0914 memory[0x40:0x60] // @0924 memory[0x40:0x60] // @0929 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0912 60 PUSH1 0x40 0914 51 MLOAD 0915 63 PUSH4 0x67d9dca1 091A 60 PUSH1 0xe1 091C 1B SHL 091D 81 DUP2 091E 52 MSTORE 091F 60 PUSH1 0x04 0921 01 ADD 0922 60 PUSH1 0x40 0924 51 MLOAD 0925 80 DUP1 0926 91 SWAP2 0927 03 SUB 0928 90 SWAP1 0929 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @091E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x67d9dca1 << 0xe1 // @0929 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_092A: // Incoming jump from 0x0911, if !stack[-1] // Inputs[3] // { // @092E stack[-3] // @092F stack[-2] // @0930 stack[-1] // } 092A 5B JUMPDEST 092B 61 PUSH2 0x0935 092E 83 DUP4 092F 83 DUP4 0930 83 DUP4 0931 61 PUSH2 0x11c8 0934 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @092B stack[0] = 0x0935 // @092E stack[1] = stack[-3] // @092F stack[2] = stack[-2] // @0930 stack[3] = stack[-1] // } // Block ends with call to 0x11c8, returns to 0x0935 label_0935: // Incoming return from call to 0x1A64 at 0x193E // Incoming return from call to 0x11C8 at 0x0934 // Inputs[1] { @0939 stack[-4] } 0935 5B JUMPDEST 0936 50 POP 0937 50 POP 0938 50 POP 0939 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_093A: // Incoming jump from 0x03C9 // Inputs[3] // { // @093E stack[-3] // @093F stack[-2] // @0940 stack[-1] // } 093A 5B JUMPDEST 093B 61 PUSH2 0x0935 093E 83 DUP4 093F 83 DUP4 0940 83 DUP4 0941 61 PUSH2 0x1231 0944 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @093B stack[0] = 0x0935 // @093E stack[1] = stack[-3] // @093F stack[2] = stack[-2] // @0940 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1231 label_0945: // Incoming jump from 0x03E9 // Inputs[2] // { // @0948 storage[0x08] // @0952 msg.sender // } 0945 5B JUMPDEST 0946 60 PUSH1 0x08 0948 54 SLOAD 0949 60 PUSH1 0x01 094B 60 PUSH1 0x01 094D 60 PUSH1 0xa0 094F 1B SHL 0950 03 SUB 0951 16 AND 0952 33 CALLER 0953 14 EQ 0954 61 PUSH2 0x098d 0957 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x098d, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0958: // Incoming jump from 0x0957, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @095A memory[0x40:0x60] // @0975 memory[0x00:0x20] // @097E memory[0x00:0x20] // } 0958 60 PUSH1 0x40 095A 51 MLOAD 095B 62 PUSH3 0x461bcd 095F 60 PUSH1 0xe5 0961 1B SHL 0962 81 DUP2 0963 52 MSTORE 0964 60 PUSH1 0x20 0966 60 PUSH1 0x04 0968 82 DUP3 0969 01 ADD 096A 81 DUP2 096B 90 SWAP1 096C 52 MSTORE 096D 60 PUSH1 0x24 096F 82 DUP3 0970 01 ADD 0971 52 MSTORE 0972 60 PUSH1 0x00 0974 80 DUP1 0975 51 MLOAD 0976 60 PUSH1 0x20 0978 61 PUSH2 0x22fc 097B 83 DUP4 097C 39 CODECOPY 097D 81 DUP2 097E 51 MLOAD 097F 91 SWAP2 0980 52 MSTORE 0981 60 PUSH1 0x44 0983 82 DUP3 0984 01 ADD 0985 52 MSTORE 0986 60 PUSH1 0x64 0988 01 ADD 0989 61 PUSH2 0x07ba 098C 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @0963 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @096C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0971 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @097C memory[0x00:0x20] = code[0x22fc:0x231c] // @0980 memory[0x00:0x20] = memory[0x00:0x20] // @0985 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0988 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x07ba label_098D: // Incoming jump from 0x0957, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0991 storage[0x0d] // @0992 stack[-1] // @09A6 stack[-2] // } 098D 5B JUMPDEST 098E 60 PUSH1 0x0d 0990 80 DUP1 0991 54 SLOAD 0992 91 SWAP2 0993 15 ISZERO 0994 15 ISZERO 0995 61 PUSH2 0x0100 0998 02 MUL 0999 61 PUSH2 0xff00 099C 19 NOT 099D 90 SWAP1 099E 92 SWAP3 099F 16 AND 09A0 91 SWAP2 09A1 90 SWAP1 09A2 91 SWAP2 09A3 17 OR 09A4 90 SWAP1 09A5 55 SSTORE 09A6 56 *JUMP // Stack delta = -2 // Outputs[1] { @09A5 storage[0x0d] = (storage[0x0d] & ~0xff00) | 0x0100 * !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_09A7: // Incoming call from 0x0410, returns to 0x02DF // Inputs[2] // { // @09AA storage[0x08] // @09B4 msg.sender // } 09A7 5B JUMPDEST 09A8 60 PUSH1 0x08 09AA 54 SLOAD 09AB 60 PUSH1 0x01 09AD 60 PUSH1 0x01 09AF 60 PUSH1 0xa0 09B1 1B SHL 09B2 03 SUB 09B3 16 AND 09B4 33 CALLER 09B5 14 EQ 09B6 61 PUSH2 0x09ef 09B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09ef, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_09BA: // Incoming jump from 0x09B9, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @09BC memory[0x40:0x60] // @09D7 memory[0x00:0x20] // @09E0 memory[0x00:0x20] // } 09BA 60 PUSH1 0x40 09BC 51 MLOAD 09BD 62 PUSH3 0x461bcd 09C1 60 PUSH1 0xe5 09C3 1B SHL 09C4 81 DUP2 09C5 52 MSTORE 09C6 60 PUSH1 0x20 09C8 60 PUSH1 0x04 09CA 82 DUP3 09CB 01 ADD 09CC 81 DUP2 09CD 90 SWAP1 09CE 52 MSTORE 09CF 60 PUSH1 0x24 09D1 82 DUP3 09D2 01 ADD 09D3 52 MSTORE 09D4 60 PUSH1 0x00 09D6 80 DUP1 09D7 51 MLOAD 09D8 60 PUSH1 0x20 09DA 61 PUSH2 0x22fc 09DD 83 DUP4 09DE 39 CODECOPY 09DF 81 DUP2 09E0 51 MLOAD 09E1 91 SWAP2 09E2 52 MSTORE 09E3 60 PUSH1 0x44 09E5 82 DUP3 09E6 01 ADD 09E7 52 MSTORE 09E8 60 PUSH1 0x64 09EA 01 ADD 09EB 61 PUSH2 0x07ba 09EE 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @09C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09CE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09D3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @09DE memory[0x00:0x20] = code[0x22fc:0x231c] // @09E2 memory[0x00:0x20] = memory[0x00:0x20] // @09E7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @09EA stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x07ba label_09EF: // Incoming jump from 0x09B9, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[7] // { // @09F2 memory[0x40:0x60] // @0A0C address(this) // @0A0C address(this).balance // @0A14 msg.gas // @0A15 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0A15 address(0x0a2c099044c088a431b78a0d6bb5a137a5663297).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0A1A returndata.length // } 09EF 5B JUMPDEST 09F0 60 PUSH1 0x40 09F2 51 MLOAD 09F3 60 PUSH1 0x00 09F5 90 SWAP1 09F6 73 PUSH20 0x0a2c099044c088a431b78a0d6bb5a137a5663297 0A0B 90 SWAP1 0A0C 47 SELFBALANCE 0A0D 90 SWAP1 0A0E 83 DUP4 0A0F 81 DUP2 0A10 81 DUP2 0A11 81 DUP2 0A12 85 DUP6 0A13 87 DUP8 0A14 5A GAS 0A15 F1 CALL 0A16 92 SWAP3 0A17 50 POP 0A18 50 POP 0A19 50 POP 0A1A 3D RETURNDATASIZE 0A1B 80 DUP1 0A1C 60 PUSH1 0x00 0A1E 81 DUP2 0A1F 14 EQ 0A20 61 PUSH2 0x0a45 0A23 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @09F5 stack[0] = 0x00 // @0A15 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0x0a2c099044c088a431b78a0d6bb5a137a5663297).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0A16 stack[1] = address(0x0a2c099044c088a431b78a0d6bb5a137a5663297).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0A1A stack[2] = returndata.length // @0A1B stack[3] = returndata.length // } // Block ends with conditional jump to 0x0a45, if returndata.length == 0x00 label_0A24: // Incoming jump from 0x0A23, if not returndata.length == 0x00 // Inputs[6] // { // @0A26 memory[0x40:0x60] // @0A27 stack[-2] // @0A2E returndata.length // @0A36 returndata.length // @0A39 returndata.length // @0A40 returndata[0x00:0x00 + returndata.length] // } 0A24 60 PUSH1 0x40 0A26 51 MLOAD 0A27 91 SWAP2 0A28 50 POP 0A29 60 PUSH1 0x1f 0A2B 19 NOT 0A2C 60 PUSH1 0x3f 0A2E 3D RETURNDATASIZE 0A2F 01 ADD 0A30 16 AND 0A31 82 DUP3 0A32 01 ADD 0A33 60 PUSH1 0x40 0A35 52 MSTORE 0A36 3D RETURNDATASIZE 0A37 82 DUP3 0A38 52 MSTORE 0A39 3D RETURNDATASIZE 0A3A 60 PUSH1 0x00 0A3C 60 PUSH1 0x20 0A3E 84 DUP5 0A3F 01 ADD 0A40 3E RETURNDATACOPY 0A41 61 PUSH2 0x0a4a 0A44 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0A27 stack[-2] = memory[0x40:0x60] // @0A35 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0A38 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0A40 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0a4a label_0A45: // Incoming jump from 0x0A23, if returndata.length == 0x00 // Inputs[3] // { // @0A48 stack[-2] // @0A4D stack[-4] // @0A4D stack[-3] // } 0A45 5B JUMPDEST 0A46 60 PUSH1 0x60 0A48 91 SWAP2 0A49 50 POP 0A4A 5B JUMPDEST 0A4B 50 POP 0A4C 50 POP 0A4D 90 SWAP1 0A4E 50 POP 0A4F 80 DUP1 0A50 61 PUSH2 0x0a58 0A53 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0A4D stack[-4] = stack[-3] } // Block ends with conditional jump to 0x0a58, if stack[-3] label_0A54: // Incoming jump from 0x0A53, if not stack[-3] // Incoming jump from 0x0A53, if not stack[-3] // Inputs[1] { @0A57 memory[0x00:0x00] } 0A54 60 PUSH1 0x00 0A56 80 DUP1 0A57 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A57 revert(memory[0x00:0x00]); } // Block terminates label_0A58: // Incoming jump from 0x0A53, if stack[-3] // Incoming return from call to 0x156F at 0x117F // Incoming return from call to 0x173C at 0x142B // Incoming return from call to 0x142C at 0x0B6D // Incoming jump from 0x1CDF, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x142C at 0x0F3D // Incoming jump from 0x0A53, if stack[-3] // Inputs[1] { @0A5A stack[-2] } 0A58 5B JUMPDEST 0A59 50 POP 0A5A 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0A5B: // Incoming jump from 0x0423 // Inputs[1] { @0A5E storage[0x0d] } 0A5B 5B JUMPDEST 0A5C 60 PUSH1 0x0d 0A5E 54 SLOAD 0A5F 61 PUSH2 0x0100 0A62 90 SWAP1 0A63 04 DIV 0A64 60 PUSH1 0xff 0A66 16 AND 0A67 15 ISZERO 0A68 61 PUSH2 0x0a84 0A6B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a84, if !(0xff & storage[0x0d] / 0x0100) label_0A6C: // Incoming jump from 0x0A6B, if not !(0xff & storage[0x0d] / 0x0100) // Inputs[3] // { // @0A6E memory[0x40:0x60] // @0A7E memory[0x40:0x60] // @0A83 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A6C 60 PUSH1 0x40 0A6E 51 MLOAD 0A6F 63 PUSH4 0x6aac1fd3 0A74 60 PUSH1 0xe0 0A76 1B SHL 0A77 81 DUP2 0A78 52 MSTORE 0A79 60 PUSH1 0x04 0A7B 01 ADD 0A7C 60 PUSH1 0x40 0A7E 51 MLOAD 0A7F 80 DUP1 0A80 91 SWAP2 0A81 03 SUB 0A82 90 SWAP1 0A83 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A78 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6aac1fd3 << 0xe0 // @0A83 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0A84: // Incoming jump from 0x0A6B, if !(0xff & storage[0x0d] / 0x0100) // Inputs[4] // { // @0A87 storage[0x09] // @0A88 stack[-1] // @0A89 memory[stack[-1]:stack[-1] + 0x20] // @0A8C storage[0x00] // } 0A84 5B JUMPDEST 0A85 60 PUSH1 0x09 0A87 54 SLOAD 0A88 81 DUP2 0A89 51 MLOAD 0A8A 60 PUSH1 0x00 0A8C 54 SLOAD 0A8D 61 PUSH2 0x0a96 0A90 91 SWAP2 0A91 90 SWAP1 0A92 61 PUSH2 0x2105 0A95 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A87 stack[0] = storage[0x09] // @0A90 stack[1] = 0x0a96 // @0A91 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // @0A91 stack[3] = storage[0x00] // } // Block ends with call to 0x2105, returns to 0x0A96 label_0A96: // Incoming return from call to 0x2105 at 0x0A95 // Inputs[2] // { // @0A97 stack[-2] // @0A97 stack[-1] // } 0A96 5B JUMPDEST 0A97 11 GT 0A98 15 ISZERO 0A99 61 PUSH2 0x0ab5 0A9C 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0ab5, if !(stack[-1] > stack[-2]) label_0A9D: // Incoming jump from 0x0A9C, if not !(stack[-1] > stack[-2]) // Inputs[3] // { // @0A9F memory[0x40:0x60] // @0AAF memory[0x40:0x60] // @0AB4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A9D 60 PUSH1 0x40 0A9F 51 MLOAD 0AA0 63 PUSH4 0x07b8358f 0AA5 60 PUSH1 0xe0 0AA7 1B SHL 0AA8 81 DUP2 0AA9 52 MSTORE 0AAA 60 PUSH1 0x04 0AAC 01 ADD 0AAD 60 PUSH1 0x40 0AAF 51 MLOAD 0AB0 80 DUP1 0AB1 91 SWAP2 0AB2 03 SUB 0AB3 90 SWAP1 0AB4 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0AA9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x07b8358f << 0xe0 // @0AB4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0AB5: // Incoming jump from 0x0A9C, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @0AB8 storage[0x08] // @0AC2 msg.sender // } 0AB5 5B JUMPDEST 0AB6 60 PUSH1 0x08 0AB8 54 SLOAD 0AB9 60 PUSH1 0x01 0ABB 60 PUSH1 0x01 0ABD 60 PUSH1 0xa0 0ABF 1B SHL 0AC0 03 SUB 0AC1 16 AND 0AC2 33 CALLER 0AC3 14 EQ 0AC4 61 PUSH2 0x0ae2 0AC7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ae2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0AC8: // Incoming jump from 0x0AC7, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0AC8 stack[-1] // @0AC9 memory[stack[-1]:stack[-1] + 0x20] // @0ACC storage[0x0a] // } 0AC8 80 DUP1 0AC9 51 MLOAD 0ACA 60 PUSH1 0x0a 0ACC 54 SLOAD 0ACD 61 PUSH2 0x0ad6 0AD0 91 SWAP2 0AD1 90 SWAP1 0AD2 61 PUSH2 0x211d 0AD5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AD0 stack[0] = 0x0ad6 // @0AD1 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @0AD1 stack[2] = storage[0x0a] // } // Block ends with call to 0x211d, returns to 0x0AD6 label_0AD6: // Incoming return from call to 0x211D at 0x0AD5 // Inputs[2] // { // @0AD7 msg.value // @0AD8 stack[-1] // } 0AD6 5B JUMPDEST 0AD7 34 CALLVALUE 0AD8 10 LT 0AD9 15 ISZERO 0ADA 61 PUSH2 0x0ae2 0ADD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ae2, if !(msg.value < stack[-1]) label_0ADE: // Incoming jump from 0x0ADD, if not !(msg.value < stack[-1]) // Inputs[1] { @0AE1 memory[0x00:0x00] } 0ADE 60 PUSH1 0x00 0AE0 80 DUP1 0AE1 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AE1 revert(memory[0x00:0x00]); } // Block terminates label_0AE2: // Incoming jump from 0x0ADD, if !(msg.value < stack[-1]) // Incoming jump from 0x0AC7, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0AE6 stack[-1] // @0AE7 memory[stack[-1]:stack[-1] + 0x20] // } 0AE2 5B JUMPDEST 0AE3 60 PUSH1 0x00 0AE5 5B JUMPDEST 0AE6 81 DUP2 0AE7 51 MLOAD 0AE8 81 DUP2 0AE9 10 LT 0AEA 15 ISZERO 0AEB 61 PUSH2 0x0b62 0AEE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0AE3 stack[0] = 0x00 } // Block ends with conditional jump to 0x0b62, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0AEF: // Incoming jump from 0x0AEE, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0AF1 stack[-2] // @0AF2 stack[-1] // @0AF4 memory[stack[-2]:stack[-2] + 0x20] // } 0AEF 60 PUSH1 0x00 0AF1 82 DUP3 0AF2 82 DUP3 0AF3 81 DUP2 0AF4 51 MLOAD 0AF5 81 DUP2 0AF6 10 LT 0AF7 61 PUSH2 0x0b02 0AFA 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0AEF stack[0] = 0x00 // @0AF1 stack[1] = stack[-2] // @0AF2 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x0b02, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_0AFB: // Incoming jump from 0x0AFA, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 0AFB 61 PUSH2 0x0b02 0AFE 61 PUSH2 0x213c 0B01 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AFB stack[0] = 0x0b02 } // Block ends with unconditional jump to 0x213c label_0B02: // Incoming jump from 0x0AFA, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @0B05 stack[-1] // @0B09 stack[-2] // @0B0A memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0B0B stack[-3] // } 0B02 5B JUMPDEST 0B03 60 PUSH1 0x20 0B05 02 MUL 0B06 60 PUSH1 0x20 0B08 01 ADD 0B09 01 ADD 0B0A 51 MLOAD 0B0B 90 SWAP1 0B0C 50 POP 0B0D 61 PUSH2 0x0b15 0B10 81 DUP2 0B11 61 PUSH2 0x0bf3 0B14 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0B0B stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0B0D stack[-2] = 0x0b15 // @0B10 stack[-1] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } // Block ends with call to 0x0bf3, returns to 0x0B15 label_0B15: // Incoming return from call to 0x0BF3 at 0x0B14 // Inputs[2] // { // @0B1E stack[-1] // @0B1F msg.sender // } 0B15 5B JUMPDEST 0B16 60 PUSH1 0x01 0B18 60 PUSH1 0x01 0B1A 60 PUSH1 0xa0 0B1C 1B SHL 0B1D 03 SUB 0B1E 16 AND 0B1F 33 CALLER 0B20 60 PUSH1 0x01 0B22 60 PUSH1 0x01 0B24 60 PUSH1 0xa0 0B26 1B SHL 0B27 03 SUB 0B28 16 AND 0B29 14 EQ 0B2A 61 PUSH2 0x0b46 0B2D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b46, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] label_0B2E: // Incoming jump from 0x0B2D, if not (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[3] // { // @0B30 memory[0x40:0x60] // @0B40 memory[0x40:0x60] // @0B45 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B2E 60 PUSH1 0x40 0B30 51 MLOAD 0B31 63 PUSH4 0x1694e3a5 0B36 60 PUSH1 0xe1 0B38 1B SHL 0B39 81 DUP2 0B3A 52 MSTORE 0B3B 60 PUSH1 0x04 0B3D 01 ADD 0B3E 60 PUSH1 0x40 0B40 51 MLOAD 0B41 80 DUP1 0B42 91 SWAP2 0B43 03 SUB 0B44 90 SWAP1 0B45 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B3A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1694e3a5 << 0xe1 // @0B45 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0B46: // Incoming jump from 0x0B2D, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[1] { @0B4A stack[-1] } 0B46 5B JUMPDEST 0B47 61 PUSH2 0x0b4f 0B4A 81 DUP2 0B4B 61 PUSH2 0x1421 0B4E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B47 stack[0] = 0x0b4f // @0B4A stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x1421 0B4F 5B JUMPDEST 0B50 50 POP 0B51 80 DUP1 0B52 61 PUSH2 0x0b5a 0B55 81 DUP2 0B56 61 PUSH2 0x2152 0B59 56 *JUMP 0B5A 5B JUMPDEST 0B5B 91 SWAP2 0B5C 50 POP 0B5D 50 POP 0B5E 61 PUSH2 0x0ae5 0B61 56 *JUMP label_0B62: // Incoming jump from 0x0AEE, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0B67 msg.sender // @0B68 stack[-2] // @0B69 memory[stack[-2]:stack[-2] + 0x20] // } 0B62 5B JUMPDEST 0B63 50 POP 0B64 61 PUSH2 0x0a58 0B67 33 CALLER 0B68 82 DUP3 0B69 51 MLOAD 0B6A 61 PUSH2 0x142c 0B6D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B64 stack[-1] = 0x0a58 // @0B67 stack[0] = msg.sender // @0B69 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x142c, returns to 0x0A58 label_0B6E: // Incoming jump from 0x0443 // Inputs[4] // { // @0B72 stack[-3] // @0B73 stack[-2] // @0B74 stack[-1] // @0B77 memory[0x40:0x60] // } 0B6E 5B JUMPDEST 0B6F 61 PUSH2 0x0935 0B72 83 DUP4 0B73 83 DUP4 0B74 83 DUP4 0B75 60 PUSH1 0x40 0B77 51 MLOAD 0B78 80 DUP1 0B79 60 PUSH1 0x20 0B7B 01 ADD 0B7C 60 PUSH1 0x40 0B7E 52 MSTORE 0B7F 80 DUP1 0B80 60 PUSH1 0x00 0B82 81 DUP2 0B83 52 MSTORE 0B84 50 POP 0B85 61 PUSH2 0x0fd4 0B88 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0B6F stack[0] = 0x0935 // @0B72 stack[1] = stack[-3] // @0B73 stack[2] = stack[-2] // @0B74 stack[3] = stack[-1] // @0B77 stack[4] = memory[0x40:0x60] // @0B7E memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0B83 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x0fd4 label_0B89: // Incoming jump from 0x0463 // Inputs[1] { @0B8F stack[-1] } 0B89 5B JUMPDEST 0B8A 60 PUSH1 0x00 0B8C 61 PUSH2 0x0770 0B8F 82 DUP3 0B90 61 PUSH2 0x118f 0B93 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B8A stack[0] = 0x00 // @0B8C stack[1] = 0x0770 // @0B8F stack[2] = stack[-1] // } // Block ends with call to 0x118f, returns to 0x0770 label_0B94: // Incoming jump from 0x0483 // Inputs[2] // { // @0B97 storage[0x08] // @0BA1 msg.sender // } 0B94 5B JUMPDEST 0B95 60 PUSH1 0x08 0B97 54 SLOAD 0B98 60 PUSH1 0x01 0B9A 60 PUSH1 0x01 0B9C 60 PUSH1 0xa0 0B9E 1B SHL 0B9F 03 SUB 0BA0 16 AND 0BA1 33 CALLER 0BA2 14 EQ 0BA3 61 PUSH2 0x0bdc 0BA6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bdc, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0BA7: // Incoming jump from 0x0BA6, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0BA9 memory[0x40:0x60] // @0BC4 memory[0x00:0x20] // @0BCD memory[0x00:0x20] // } 0BA7 60 PUSH1 0x40 0BA9 51 MLOAD 0BAA 62 PUSH3 0x461bcd 0BAE 60 PUSH1 0xe5 0BB0 1B SHL 0BB1 81 DUP2 0BB2 52 MSTORE 0BB3 60 PUSH1 0x20 0BB5 60 PUSH1 0x04 0BB7 82 DUP3 0BB8 01 ADD 0BB9 81 DUP2 0BBA 90 SWAP1 0BBB 52 MSTORE 0BBC 60 PUSH1 0x24 0BBE 82 DUP3 0BBF 01 ADD 0BC0 52 MSTORE 0BC1 60 PUSH1 0x00 0BC3 80 DUP1 0BC4 51 MLOAD 0BC5 60 PUSH1 0x20 0BC7 61 PUSH2 0x22fc 0BCA 83 DUP4 0BCB 39 CODECOPY 0BCC 81 DUP2 0BCD 51 MLOAD 0BCE 91 SWAP2 0BCF 52 MSTORE 0BD0 60 PUSH1 0x44 0BD2 82 DUP3 0BD3 01 ADD 0BD4 52 MSTORE 0BD5 60 PUSH1 0x64 0BD7 01 ADD 0BD8 61 PUSH2 0x07ba 0BDB 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @0BB2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BBB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BC0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0BCB memory[0x00:0x20] = code[0x22fc:0x231c] // @0BCF memory[0x00:0x20] = memory[0x00:0x20] // @0BD4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0BD7 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x07ba label_0BDC: // Incoming jump from 0x0BA6, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0BDD stack[-1] // @0BDE memory[stack[-1]:stack[-1] + 0x20] // } 0BDC 5B JUMPDEST 0BDD 80 DUP1 0BDE 51 MLOAD 0BDF 61 PUSH2 0x0bef 0BE2 90 SWAP1 0BE3 60 PUSH1 0x0e 0BE5 90 SWAP1 0BE6 60 PUSH1 0x20 0BE8 84 DUP5 0BE9 01 ADD 0BEA 90 SWAP1 0BEB 61 PUSH2 0x1c35 0BEE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0BE2 stack[0] = 0x0bef // @0BE5 stack[1] = 0x0e // @0BEA stack[2] = stack[-1] + 0x20 // @0BEA stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1c35 label_0BEF: // Incoming return from call to 0x1932 at 0x1445 // Inputs[1] { @0BF2 stack[-3] } 0BEF 5B JUMPDEST 0BF0 50 POP 0BF1 50 POP 0BF2 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0BF3: // Incoming jump from 0x04BD // Incoming call from 0x08B6, returns to 0x08B7 // Incoming call from 0x0B14, returns to 0x0B15 // Inputs[1] { @0BF9 stack[-1] } 0BF3 5B JUMPDEST 0BF4 60 PUSH1 0x00 0BF6 61 PUSH2 0x0bfe 0BF9 82 DUP3 0BFA 61 PUSH2 0x1446 0BFD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BF4 stack[0] = 0x00 // @0BF6 stack[1] = 0x0bfe // @0BF9 stack[2] = stack[-1] // } // Block ends with call to 0x1446, returns to 0x0BFE label_0BFE: // Incoming return from call to 0x1446 at 0x0BFD // Inputs[4] // { // @0BFF stack[-1] // @0BFF memory[stack[-1]:stack[-1] + 0x20] // @0C00 stack[-4] // @0C01 stack[-3] // } 0BFE 5B JUMPDEST 0BFF 51 MLOAD 0C00 92 SWAP3 0C01 91 SWAP2 0C02 50 POP 0C03 50 POP 0C04 56 *JUMP // Stack delta = -3 // Outputs[1] { @0C00 stack[-4] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-4] label_0C05: // Incoming call from 0x04D2, returns to 0x02F6 // Inputs[1] { @0C09 storage[0x0e] } 0C05 5B JUMPDEST 0C06 60 PUSH1 0x0e 0C08 80 DUP1 0C09 54 SLOAD 0C0A 61 PUSH2 0x0c12 0C0D 90 SWAP1 0C0E 61 PUSH2 0x20b4 0C11 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C06 stack[0] = 0x0e // @0C0D stack[1] = 0x0c12 // @0C0D stack[2] = storage[0x0e] // } // Block ends with call to 0x20b4, returns to 0x0C12 label_0C12: // Incoming return from call to 0x20B4 at 0x1065 // Incoming return from call to 0x20B4 at 0x0C11 // Inputs[4] // { // @0C13 stack[-1] // @0C22 memory[0x40:0x60] // @0C2A stack[-2] // @0C35 storage[stack[-2]] // } 0C12 5B JUMPDEST 0C13 80 DUP1 0C14 60 PUSH1 0x1f 0C16 01 ADD 0C17 60 PUSH1 0x20 0C19 80 DUP1 0C1A 91 SWAP2 0C1B 04 DIV 0C1C 02 MUL 0C1D 60 PUSH1 0x20 0C1F 01 ADD 0C20 60 PUSH1 0x40 0C22 51 MLOAD 0C23 90 SWAP1 0C24 81 DUP2 0C25 01 ADD 0C26 60 PUSH1 0x40 0C28 52 MSTORE 0C29 80 DUP1 0C2A 92 SWAP3 0C2B 91 SWAP2 0C2C 90 SWAP1 0C2D 81 DUP2 0C2E 81 DUP2 0C2F 52 MSTORE 0C30 60 PUSH1 0x20 0C32 01 ADD 0C33 82 DUP3 0C34 80 DUP1 0C35 54 SLOAD 0C36 61 PUSH2 0x0c3e 0C39 90 SWAP1 0C3A 61 PUSH2 0x20b4 0C3D 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0C28 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0C2A stack[-2] = memory[0x40:0x60] // @0C2B stack[-1] = stack[-2] // @0C2C stack[0] = stack[-1] // @0C2F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0C32 stack[1] = 0x20 + memory[0x40:0x60] // @0C33 stack[2] = stack[-2] // @0C39 stack[4] = storage[stack[-2]] // @0C39 stack[3] = 0x0c3e // } // Block ends with call to 0x20b4, returns to 0x0C3E label_0C3E: // Incoming return from call to 0x20B4 at 0x0C3D // Inputs[1] { @0C3F stack[-1] } 0C3E 5B JUMPDEST 0C3F 80 DUP1 0C40 15 ISZERO 0C41 61 PUSH2 0x0c8b 0C44 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c8b, if !stack[-1] label_0C45: // Incoming jump from 0x0C44, if not !stack[-1] // Inputs[1] { @0C45 stack[-1] } 0C45 80 DUP1 0C46 60 PUSH1 0x1f 0C48 10 LT 0C49 61 PUSH2 0x0c60 0C4C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c60, if 0x1f < stack[-1] label_0C4D: // Incoming jump from 0x0C4C, if not 0x1f < stack[-1] // Inputs[4] // { // @0C51 stack[-2] // @0C52 storage[stack[-2]] // @0C55 stack[-3] // @0C57 stack[-1] // } 0C4D 61 PUSH2 0x0100 0C50 80 DUP1 0C51 83 DUP4 0C52 54 SLOAD 0C53 04 DIV 0C54 02 MUL 0C55 83 DUP4 0C56 52 MSTORE 0C57 91 SWAP2 0C58 60 PUSH1 0x20 0C5A 01 ADD 0C5B 91 SWAP2 0C5C 61 PUSH2 0x0c8b 0C5F 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0C56 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0C5B stack[-1] = stack[-1] // @0C5B stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0c8b label_0C60: // Incoming jump from 0x0C4C, if 0x1f < stack[-1] // Inputs[5] // { // @0C61 stack[-3] // @0C62 stack[-1] // @0C64 stack[-2] // @0C6C memory[0x00:0x20] // @0C70 storage[keccak256(memory[0x00:0x20])] // } 0C60 5B JUMPDEST 0C61 82 DUP3 0C62 01 ADD 0C63 91 SWAP2 0C64 90 SWAP1 0C65 60 PUSH1 0x00 0C67 52 MSTORE 0C68 60 PUSH1 0x20 0C6A 60 PUSH1 0x00 0C6C 20 SHA3 0C6D 90 SWAP1 0C6E 5B JUMPDEST 0C6F 81 DUP2 0C70 54 SLOAD 0C71 81 DUP2 0C72 52 MSTORE 0C73 90 SWAP1 0C74 60 PUSH1 0x01 0C76 01 ADD 0C77 90 SWAP1 0C78 60 PUSH1 0x20 0C7A 01 ADD 0C7B 80 DUP1 0C7C 83 DUP4 0C7D 11 GT 0C7E 61 PUSH2 0x0c6e 0C81 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0C63 stack[-3] = stack[-3] + stack[-1] // @0C67 memory[0x00:0x20] = stack[-2] // @0C72 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0C77 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0C7A stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0c6e, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0C82: // Incoming jump from 0x0C81, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0C81, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0C82 stack[-3] // @0C83 stack[-1] // } 0C82 82 DUP3 0C83 90 SWAP1 0C84 03 SUB 0C85 60 PUSH1 0x1f 0C87 16 AND 0C88 82 DUP3 0C89 01 ADD 0C8A 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0C8A stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0C8A stack[-1] = stack[-3] // } // Block continues label_0C8B: // Incoming jump from 0x0C8A // Incoming jump from 0x0C5F // Incoming jump from 0x0C44, if !stack[-1] // Inputs[1] { @0C91 stack[-7] } 0C8B 5B JUMPDEST 0C8C 50 POP 0C8D 50 POP 0C8E 50 POP 0C8F 50 POP 0C90 50 POP 0C91 81 DUP2 0C92 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0C93: // Incoming jump from 0x04F2 // Inputs[2] // { // @0C96 storage[0x08] // @0CA0 msg.sender // } 0C93 5B JUMPDEST 0C94 60 PUSH1 0x08 0C96 54 SLOAD 0C97 60 PUSH1 0x01 0C99 60 PUSH1 0x01 0C9B 60 PUSH1 0xa0 0C9D 1B SHL 0C9E 03 SUB 0C9F 16 AND 0CA0 33 CALLER 0CA1 14 EQ 0CA2 61 PUSH2 0x0cdb 0CA5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cdb, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0CA6: // Incoming jump from 0x0CA5, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0CA8 memory[0x40:0x60] // @0CC3 memory[0x00:0x20] // @0CCC memory[0x00:0x20] // } 0CA6 60 PUSH1 0x40 0CA8 51 MLOAD 0CA9 62 PUSH3 0x461bcd 0CAD 60 PUSH1 0xe5 0CAF 1B SHL 0CB0 81 DUP2 0CB1 52 MSTORE 0CB2 60 PUSH1 0x20 0CB4 60 PUSH1 0x04 0CB6 82 DUP3 0CB7 01 ADD 0CB8 81 DUP2 0CB9 90 SWAP1 0CBA 52 MSTORE 0CBB 60 PUSH1 0x24 0CBD 82 DUP3 0CBE 01 ADD 0CBF 52 MSTORE 0CC0 60 PUSH1 0x00 0CC2 80 DUP1 0CC3 51 MLOAD 0CC4 60 PUSH1 0x20 0CC6 61 PUSH2 0x22fc 0CC9 83 DUP4 0CCA 39 CODECOPY 0CCB 81 DUP2 0CCC 51 MLOAD 0CCD 91 SWAP2 0CCE 52 MSTORE 0CCF 60 PUSH1 0x44 0CD1 82 DUP3 0CD2 01 ADD 0CD3 52 MSTORE 0CD4 60 PUSH1 0x64 0CD6 01 ADD 0CD7 61 PUSH2 0x07ba 0CDA 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @0CB1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CBA memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0CBF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0CCA memory[0x00:0x20] = code[0x22fc:0x231c] // @0CCE memory[0x00:0x20] = memory[0x00:0x20] // @0CD3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0CD6 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x07ba label_0CDB: // Incoming jump from 0x0CA5, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0CDE stack[-1] // @0CDF stack[-2] // } 0CDB 5B JUMPDEST 0CDC 60 PUSH1 0x09 0CDE 55 SSTORE 0CDF 56 *JUMP // Stack delta = -2 // Outputs[1] { @0CDE storage[0x09] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0CE0: // Incoming jump from 0x0512 // Inputs[1] { @0CEB stack[-1] } 0CE0 5B JUMPDEST 0CE1 60 PUSH1 0x00 0CE3 60 PUSH1 0x01 0CE5 60 PUSH1 0x01 0CE7 60 PUSH1 0xa0 0CE9 1B SHL 0CEA 03 SUB 0CEB 82 DUP3 0CEC 16 AND 0CED 61 PUSH2 0x0d09 0CF0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0CE1 stack[0] = 0x00 } // Block ends with conditional jump to 0x0d09, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0CF1: // Incoming jump from 0x0CF0, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0CF3 memory[0x40:0x60] // @0D03 memory[0x40:0x60] // @0D08 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0CF1 60 PUSH1 0x40 0CF3 51 MLOAD 0CF4 63 PUSH4 0x23d3ad81 0CF9 60 PUSH1 0xe2 0CFB 1B SHL 0CFC 81 DUP2 0CFD 52 MSTORE 0CFE 60 PUSH1 0x04 0D00 01 ADD 0D01 60 PUSH1 0x40 0D03 51 MLOAD 0D04 80 DUP1 0D05 91 SWAP2 0D06 03 SUB 0D07 90 SWAP1 0D08 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0CFD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x23d3ad81 << 0xe2 // @0D08 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0D09: // Incoming jump from 0x0CF0, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0D13 stack[-2] // @0D21 memory[0x00:0x40] // @0D22 storage[keccak256(memory[0x00:0x40])] // @0D2D stack[-3] // } 0D09 5B JUMPDEST 0D0A 50 POP 0D0B 60 PUSH1 0x01 0D0D 60 PUSH1 0x01 0D0F 60 PUSH1 0xa0 0D11 1B SHL 0D12 03 SUB 0D13 16 AND 0D14 60 PUSH1 0x00 0D16 90 SWAP1 0D17 81 DUP2 0D18 52 MSTORE 0D19 60 PUSH1 0x05 0D1B 60 PUSH1 0x20 0D1D 52 MSTORE 0D1E 60 PUSH1 0x40 0D20 90 SWAP1 0D21 20 SHA3 0D22 54 SLOAD 0D23 67 PUSH8 0xffffffffffffffff 0D2C 16 AND 0D2D 90 SWAP1 0D2E 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0D18 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0D1D memory[0x20:0x40] = 0x05 // @0D2D stack[-3] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0D2F: // Incoming call from 0x0527, returns to 0x02DF // Inputs[2] // { // @0D32 storage[0x08] // @0D3C msg.sender // } 0D2F 5B JUMPDEST 0D30 60 PUSH1 0x08 0D32 54 SLOAD 0D33 60 PUSH1 0x01 0D35 60 PUSH1 0x01 0D37 60 PUSH1 0xa0 0D39 1B SHL 0D3A 03 SUB 0D3B 16 AND 0D3C 33 CALLER 0D3D 14 EQ 0D3E 61 PUSH2 0x0d77 0D41 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d77, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0D42: // Incoming jump from 0x0D41, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0D44 memory[0x40:0x60] // @0D5F memory[0x00:0x20] // @0D68 memory[0x00:0x20] // } 0D42 60 PUSH1 0x40 0D44 51 MLOAD 0D45 62 PUSH3 0x461bcd 0D49 60 PUSH1 0xe5 0D4B 1B SHL 0D4C 81 DUP2 0D4D 52 MSTORE 0D4E 60 PUSH1 0x20 0D50 60 PUSH1 0x04 0D52 82 DUP3 0D53 01 ADD 0D54 81 DUP2 0D55 90 SWAP1 0D56 52 MSTORE 0D57 60 PUSH1 0x24 0D59 82 DUP3 0D5A 01 ADD 0D5B 52 MSTORE 0D5C 60 PUSH1 0x00 0D5E 80 DUP1 0D5F 51 MLOAD 0D60 60 PUSH1 0x20 0D62 61 PUSH2 0x22fc 0D65 83 DUP4 0D66 39 CODECOPY 0D67 81 DUP2 0D68 51 MLOAD 0D69 91 SWAP2 0D6A 52 MSTORE 0D6B 60 PUSH1 0x44 0D6D 82 DUP3 0D6E 01 ADD 0D6F 52 MSTORE 0D70 60 PUSH1 0x64 0D72 01 ADD 0D73 61 PUSH2 0x07ba 0D76 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @0D4D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D56 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D5B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0D66 memory[0x00:0x20] = code[0x22fc:0x231c] // @0D6A memory[0x00:0x20] = memory[0x00:0x20] // @0D6F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0D72 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x07ba label_0D77: // Incoming jump from 0x0D41, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] 0D77 5B JUMPDEST 0D78 61 PUSH2 0x0d81 0D7B 60 PUSH1 0x00 0D7D 61 PUSH2 0x156f 0D80 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D78 stack[0] = 0x0d81 // @0D7B stack[1] = 0x00 // } // Block ends with call to 0x156f, returns to 0x0D81 label_0D81: // Incoming return from call to 0x156F at 0x0D80 // Inputs[1] { @0D82 stack[-1] } 0D81 5B JUMPDEST 0D82 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0D83: // Incoming jump from 0x0547 // Inputs[2] // { // @0D86 storage[0x08] // @0D90 msg.sender // } 0D83 5B JUMPDEST 0D84 60 PUSH1 0x08 0D86 54 SLOAD 0D87 60 PUSH1 0x01 0D89 60 PUSH1 0x01 0D8B 60 PUSH1 0xa0 0D8D 1B SHL 0D8E 03 SUB 0D8F 16 AND 0D90 33 CALLER 0D91 14 EQ 0D92 61 PUSH2 0x0dcb 0D95 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dcb, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0D96: // Incoming jump from 0x0D95, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0D98 memory[0x40:0x60] // @0DB3 memory[0x00:0x20] // @0DBC memory[0x00:0x20] // } 0D96 60 PUSH1 0x40 0D98 51 MLOAD 0D99 62 PUSH3 0x461bcd 0D9D 60 PUSH1 0xe5 0D9F 1B SHL 0DA0 81 DUP2 0DA1 52 MSTORE 0DA2 60 PUSH1 0x20 0DA4 60 PUSH1 0x04 0DA6 82 DUP3 0DA7 01 ADD 0DA8 81 DUP2 0DA9 90 SWAP1 0DAA 52 MSTORE 0DAB 60 PUSH1 0x24 0DAD 82 DUP3 0DAE 01 ADD 0DAF 52 MSTORE 0DB0 60 PUSH1 0x00 0DB2 80 DUP1 0DB3 51 MLOAD 0DB4 60 PUSH1 0x20 0DB6 61 PUSH2 0x22fc 0DB9 83 DUP4 0DBA 39 CODECOPY 0DBB 81 DUP2 0DBC 51 MLOAD 0DBD 91 SWAP2 0DBE 52 MSTORE 0DBF 60 PUSH1 0x44 0DC1 82 DUP3 0DC2 01 ADD 0DC3 52 MSTORE 0DC4 60 PUSH1 0x64 0DC6 01 ADD 0DC7 61 PUSH2 0x07ba 0DCA 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @0DA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DAA memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DAF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0DBA memory[0x00:0x20] = code[0x22fc:0x231c] // @0DBE memory[0x00:0x20] = memory[0x00:0x20] // @0DC3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0DC6 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x07ba label_0DCB: // Incoming jump from 0x0D95, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0DCE stack[-1] // @0DCF stack[-2] // } 0DCB 5B JUMPDEST 0DCC 60 PUSH1 0x0c 0DCE 55 SSTORE 0DCF 56 *JUMP // Stack delta = -2 // Outputs[1] { @0DCE storage[0x0c] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0DD0: // Incoming jump from 0x0567 // Inputs[2] // { // @0DD3 storage[0x08] // @0DDD msg.sender // } 0DD0 5B JUMPDEST 0DD1 60 PUSH1 0x08 0DD3 54 SLOAD 0DD4 60 PUSH1 0x01 0DD6 60 PUSH1 0x01 0DD8 60 PUSH1 0xa0 0DDA 1B SHL 0DDB 03 SUB 0DDC 16 AND 0DDD 33 CALLER 0DDE 14 EQ 0DDF 61 PUSH2 0x0e18 0DE2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e18, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0DE3: // Incoming jump from 0x0DE2, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0DE5 memory[0x40:0x60] // @0E00 memory[0x00:0x20] // @0E09 memory[0x00:0x20] // } 0DE3 60 PUSH1 0x40 0DE5 51 MLOAD 0DE6 62 PUSH3 0x461bcd 0DEA 60 PUSH1 0xe5 0DEC 1B SHL 0DED 81 DUP2 0DEE 52 MSTORE 0DEF 60 PUSH1 0x20 0DF1 60 PUSH1 0x04 0DF3 82 DUP3 0DF4 01 ADD 0DF5 81 DUP2 0DF6 90 SWAP1 0DF7 52 MSTORE 0DF8 60 PUSH1 0x24 0DFA 82 DUP3 0DFB 01 ADD 0DFC 52 MSTORE 0DFD 60 PUSH1 0x00 0DFF 80 DUP1 0E00 51 MLOAD 0E01 60 PUSH1 0x20 0E03 61 PUSH2 0x22fc 0E06 83 DUP4 0E07 39 CODECOPY 0E08 81 DUP2 0E09 51 MLOAD 0E0A 91 SWAP2 0E0B 52 MSTORE 0E0C 60 PUSH1 0x44 0E0E 82 DUP3 0E0F 01 ADD 0E10 52 MSTORE 0E11 60 PUSH1 0x64 0E13 01 ADD 0E14 61 PUSH2 0x07ba 0E17 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @0DEE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DF7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DFC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0E07 memory[0x00:0x20] = code[0x22fc:0x231c] // @0E0B memory[0x00:0x20] = memory[0x00:0x20] // @0E10 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0E13 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x07ba label_0E18: // Incoming jump from 0x0DE2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0E19 stack[-1] // @0E1A memory[stack[-1]:stack[-1] + 0x20] // } 0E18 5B JUMPDEST 0E19 80 DUP1 0E1A 51 MLOAD 0E1B 61 PUSH2 0x0bef 0E1E 90 SWAP1 0E1F 60 PUSH1 0x0f 0E21 90 SWAP1 0E22 60 PUSH1 0x20 0E24 84 DUP5 0E25 01 ADD 0E26 90 SWAP1 0E27 61 PUSH2 0x1c35 0E2A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E1E stack[0] = 0x0bef // @0E21 stack[1] = 0x0f // @0E26 stack[2] = stack[-1] + 0x20 // @0E26 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1c35 label_0E2B: // Incoming jump from 0x0587 // Inputs[2] // { // @0E2E storage[0x08] // @0E38 msg.sender // } 0E2B 5B JUMPDEST 0E2C 60 PUSH1 0x08 0E2E 54 SLOAD 0E2F 60 PUSH1 0x01 0E31 60 PUSH1 0x01 0E33 60 PUSH1 0xa0 0E35 1B SHL 0E36 03 SUB 0E37 16 AND 0E38 33 CALLER 0E39 14 EQ 0E3A 61 PUSH2 0x0e73 0E3D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e73, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0E3E: // Incoming jump from 0x0E3D, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0E40 memory[0x40:0x60] // @0E5B memory[0x00:0x20] // @0E64 memory[0x00:0x20] // } 0E3E 60 PUSH1 0x40 0E40 51 MLOAD 0E41 62 PUSH3 0x461bcd 0E45 60 PUSH1 0xe5 0E47 1B SHL 0E48 81 DUP2 0E49 52 MSTORE 0E4A 60 PUSH1 0x20 0E4C 60 PUSH1 0x04 0E4E 82 DUP3 0E4F 01 ADD 0E50 81 DUP2 0E51 90 SWAP1 0E52 52 MSTORE 0E53 60 PUSH1 0x24 0E55 82 DUP3 0E56 01 ADD 0E57 52 MSTORE 0E58 60 PUSH1 0x00 0E5A 80 DUP1 0E5B 51 MLOAD 0E5C 60 PUSH1 0x20 0E5E 61 PUSH2 0x22fc 0E61 83 DUP4 0E62 39 CODECOPY 0E63 81 DUP2 0E64 51 MLOAD 0E65 91 SWAP2 0E66 52 MSTORE 0E67 60 PUSH1 0x44 0E69 82 DUP3 0E6A 01 ADD 0E6B 52 MSTORE 0E6C 60 PUSH1 0x64 0E6E 01 ADD 0E6F 61 PUSH2 0x07ba 0E72 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @0E49 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E52 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E57 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0E62 memory[0x00:0x20] = code[0x22fc:0x231c] // @0E66 memory[0x00:0x20] = memory[0x00:0x20] // @0E6B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0E6E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x07ba label_0E73: // Incoming jump from 0x0E3D, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0E76 stack[-1] // @0E77 stack[-2] // } 0E73 5B JUMPDEST 0E74 60 PUSH1 0x0a 0E76 55 SSTORE 0E77 56 *JUMP // Stack delta = -2 // Outputs[1] { @0E76 storage[0x0a] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0E78: // Incoming call from 0x05BA, returns to 0x02F6 // Inputs[1] { @0E7E storage[0x03] } 0E78 5B JUMPDEST 0E79 60 PUSH1 0x60 0E7B 60 PUSH1 0x03 0E7D 80 DUP1 0E7E 54 SLOAD 0E7F 61 PUSH2 0x07e5 0E82 90 SWAP1 0E83 61 PUSH2 0x20b4 0E86 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E79 stack[0] = 0x60 // @0E7B stack[1] = 0x03 // @0E82 stack[2] = 0x07e5 // @0E82 stack[3] = storage[0x03] // } // Block ends with call to 0x20b4, returns to 0x07E5 label_0E87: // Incoming jump from 0x05CD // Inputs[1] { @0E8A storage[0x0d] } 0E87 5B JUMPDEST 0E88 60 PUSH1 0x0d 0E8A 54 SLOAD 0E8B 60 PUSH1 0xff 0E8D 16 AND 0E8E 15 ISZERO 0E8F 61 PUSH2 0x0eab 0E92 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0eab, if !(0xff & storage[0x0d]) label_0E93: // Incoming jump from 0x0E92, if not !(0xff & storage[0x0d]) // Inputs[3] // { // @0E95 memory[0x40:0x60] // @0EA5 memory[0x40:0x60] // @0EAA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E93 60 PUSH1 0x40 0E95 51 MLOAD 0E96 63 PUSH4 0x6be9245d 0E9B 60 PUSH1 0xe1 0E9D 1B SHL 0E9E 81 DUP2 0E9F 52 MSTORE 0EA0 60 PUSH1 0x04 0EA2 01 ADD 0EA3 60 PUSH1 0x40 0EA5 51 MLOAD 0EA6 80 DUP1 0EA7 91 SWAP2 0EA8 03 SUB 0EA9 90 SWAP1 0EAA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0E9F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6be9245d << 0xe1 // @0EAA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0EAB: // Incoming jump from 0x0E92, if !(0xff & storage[0x0d]) // Inputs[4] // { // @0EAE storage[0x09] // @0EB1 storage[0x01] // @0EB4 storage[0x00] // @0EB5 stack[-1] // } 0EAB 5B JUMPDEST 0EAC 60 PUSH1 0x09 0EAE 54 SLOAD 0EAF 60 PUSH1 0x01 0EB1 54 SLOAD 0EB2 60 PUSH1 0x00 0EB4 54 SLOAD 0EB5 83 DUP4 0EB6 91 SWAP2 0EB7 90 SWAP1 0EB8 03 SUB 0EB9 60 PUSH1 0x00 0EBB 19 NOT 0EBC 01 ADD 0EBD 61 PUSH2 0x0ec6 0EC0 91 SWAP2 0EC1 90 SWAP1 0EC2 61 PUSH2 0x2105 0EC5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EAE stack[0] = storage[0x09] // @0EC0 stack[1] = 0x0ec6 // @0EC1 stack[2] = stack[-1] // @0EC1 stack[3] = ~0x00 + (storage[0x00] - storage[0x01]) // } // Block ends with call to 0x2105, returns to 0x0EC6 label_0EC6: // Incoming return from call to 0x2105 at 0x0EC5 // Inputs[2] // { // @0EC7 stack[-2] // @0EC7 stack[-1] // } 0EC6 5B JUMPDEST 0EC7 11 GT 0EC8 15 ISZERO 0EC9 61 PUSH2 0x0ee5 0ECC 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0ee5, if !(stack[-1] > stack[-2]) label_0ECD: // Incoming jump from 0x0ECC, if not !(stack[-1] > stack[-2]) // Inputs[3] // { // @0ECF memory[0x40:0x60] // @0EDF memory[0x40:0x60] // @0EE4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0ECD 60 PUSH1 0x40 0ECF 51 MLOAD 0ED0 63 PUSH4 0x07b8358f 0ED5 60 PUSH1 0xe0 0ED7 1B SHL 0ED8 81 DUP2 0ED9 52 MSTORE 0EDA 60 PUSH1 0x04 0EDC 01 ADD 0EDD 60 PUSH1 0x40 0EDF 51 MLOAD 0EE0 80 DUP1 0EE1 91 SWAP2 0EE2 03 SUB 0EE3 90 SWAP1 0EE4 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0ED9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x07b8358f << 0xe0 // @0EE4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0EE5: // Incoming jump from 0x0ECC, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @0EE8 storage[0x0c] // @0EE9 stack[-1] // } 0EE5 5B JUMPDEST 0EE6 60 PUSH1 0x0c 0EE8 54 SLOAD 0EE9 81 DUP2 0EEA 11 GT 0EEB 15 ISZERO 0EEC 61 PUSH2 0x0f08 0EEF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f08, if !(stack[-1] > storage[0x0c]) label_0EF0: // Incoming jump from 0x0EEF, if not !(stack[-1] > storage[0x0c]) // Inputs[3] // { // @0EF2 memory[0x40:0x60] // @0F02 memory[0x40:0x60] // @0F07 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0EF0 60 PUSH1 0x40 0EF2 51 MLOAD 0EF3 63 PUSH4 0x5307908d 0EF8 60 PUSH1 0xe0 0EFA 1B SHL 0EFB 81 DUP2 0EFC 52 MSTORE 0EFD 60 PUSH1 0x04 0EFF 01 ADD 0F00 60 PUSH1 0x40 0F02 51 MLOAD 0F03 80 DUP1 0F04 91 SWAP2 0F05 03 SUB 0F06 90 SWAP1 0F07 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0EFC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5307908d << 0xe0 // @0F07 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F08: // Incoming jump from 0x0EEF, if !(stack[-1] > storage[0x0c]) // Inputs[2] // { // @0F0B storage[0x08] // @0F15 msg.sender // } 0F08 5B JUMPDEST 0F09 60 PUSH1 0x08 0F0B 54 SLOAD 0F0C 60 PUSH1 0x01 0F0E 60 PUSH1 0x01 0F10 60 PUSH1 0xa0 0F12 1B SHL 0F13 03 SUB 0F14 16 AND 0F15 33 CALLER 0F16 14 EQ 0F17 61 PUSH2 0x0f34 0F1A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f34, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0F1B: // Incoming jump from 0x0F1A, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0F1B stack[-1] // @0F1E storage[0x0a] // } 0F1B 80 DUP1 0F1C 60 PUSH1 0x0a 0F1E 54 SLOAD 0F1F 61 PUSH2 0x0f28 0F22 91 SWAP2 0F23 90 SWAP1 0F24 61 PUSH2 0x211d 0F27 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F22 stack[0] = 0x0f28 // @0F23 stack[1] = stack[-1] // @0F23 stack[2] = storage[0x0a] // } // Block ends with call to 0x211d, returns to 0x0F28 label_0F28: // Incoming return from call to 0x211D at 0x0F27 // Inputs[2] // { // @0F29 msg.value // @0F2A stack[-1] // } 0F28 5B JUMPDEST 0F29 34 CALLVALUE 0F2A 10 LT 0F2B 15 ISZERO 0F2C 61 PUSH2 0x0f34 0F2F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f34, if !(msg.value < stack[-1]) label_0F30: // Incoming jump from 0x0F2F, if not !(msg.value < stack[-1]) // Inputs[1] { @0F33 memory[0x00:0x00] } 0F30 60 PUSH1 0x00 0F32 80 DUP1 0F33 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F33 revert(memory[0x00:0x00]); } // Block terminates label_0F34: // Incoming jump from 0x0F2F, if !(msg.value < stack[-1]) // Incoming jump from 0x0F1A, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0F38 msg.sender // @0F39 stack[-1] // } 0F34 5B JUMPDEST 0F35 61 PUSH2 0x0a58 0F38 33 CALLER 0F39 82 DUP3 0F3A 61 PUSH2 0x142c 0F3D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F35 stack[0] = 0x0a58 // @0F38 stack[1] = msg.sender // @0F39 stack[2] = stack[-1] // } // Block ends with call to 0x142c, returns to 0x0A58 label_0F3E: // Incoming jump from 0x05ED // Inputs[2] // { // @0F47 stack[-2] // @0F49 msg.sender // } 0F3E 5B JUMPDEST 0F3F 60 PUSH1 0x01 0F41 60 PUSH1 0x01 0F43 60 PUSH1 0xa0 0F45 1B SHL 0F46 03 SUB 0F47 82 DUP3 0F48 16 AND 0F49 33 CALLER 0F4A 14 EQ 0F4B 15 ISZERO 0F4C 61 PUSH2 0x0f68 0F4F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f68, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) label_0F50: // Incoming jump from 0x0F4F, if not !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @0F52 memory[0x40:0x60] // @0F62 memory[0x40:0x60] // @0F67 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F50 60 PUSH1 0x40 0F52 51 MLOAD 0F53 63 PUSH4 0xb06307db 0F58 60 PUSH1 0xe0 0F5A 1B SHL 0F5B 81 DUP2 0F5C 52 MSTORE 0F5D 60 PUSH1 0x04 0F5F 01 ADD 0F60 60 PUSH1 0x40 0F62 51 MLOAD 0F63 80 DUP1 0F64 91 SWAP2 0F65 03 SUB 0F66 90 SWAP1 0F67 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F5C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb06307db << 0xe0 // @0F67 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F68: // Incoming jump from 0x0F4F, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[10] // { // @0F69 msg.sender // @0F7A memory[0x00:0x40] // @0F83 stack[-2] // @0F8E memory[0x00:0x40] // @0F90 storage[keccak256(memory[0x00:0x40])] // @0F95 stack[-1] // @0F9F memory[0x40:0x60] // @0FCB memory[0x40:0x60] // @0FD0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0FD3 stack[-3] // } 0F68 5B JUMPDEST 0F69 33 CALLER 0F6A 60 PUSH1 0x00 0F6C 81 DUP2 0F6D 81 DUP2 0F6E 52 MSTORE 0F6F 60 PUSH1 0x07 0F71 60 PUSH1 0x20 0F73 90 SWAP1 0F74 81 DUP2 0F75 52 MSTORE 0F76 60 PUSH1 0x40 0F78 80 DUP1 0F79 83 DUP4 0F7A 20 SHA3 0F7B 60 PUSH1 0x01 0F7D 60 PUSH1 0x01 0F7F 60 PUSH1 0xa0 0F81 1B SHL 0F82 03 SUB 0F83 87 DUP8 0F84 16 AND 0F85 80 DUP1 0F86 85 DUP6 0F87 52 MSTORE 0F88 90 SWAP1 0F89 83 DUP4 0F8A 52 MSTORE 0F8B 92 SWAP3 0F8C 81 DUP2 0F8D 90 SWAP1 0F8E 20 SHA3 0F8F 80 DUP1 0F90 54 SLOAD 0F91 60 PUSH1 0xff 0F93 19 NOT 0F94 16 AND 0F95 86 DUP7 0F96 15 ISZERO 0F97 15 ISZERO 0F98 90 SWAP1 0F99 81 DUP2 0F9A 17 OR 0F9B 90 SWAP1 0F9C 91 SWAP2 0F9D 55 SSTORE 0F9E 90 SWAP1 0F9F 51 MLOAD 0FA0 90 SWAP1 0FA1 81 DUP2 0FA2 52 MSTORE 0FA3 91 SWAP2 0FA4 92 SWAP3 0FA5 91 SWAP2 0FA6 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0FC7 91 SWAP2 0FC8 01 ADD 0FC9 60 PUSH1 0x40 0FCB 51 MLOAD 0FCC 80 DUP1 0FCD 91 SWAP2 0FCE 03 SUB 0FCF 90 SWAP1 0FD0 A3 LOG3 0FD1 50 POP 0FD2 50 POP 0FD3 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0F6E memory[0x00:0x20] = msg.sender // @0F75 memory[0x20:0x40] = 0x07 // @0F87 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0F8A memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0F9D storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0FA2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0FD0 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_0FD4: // Incoming jump from 0x0B88 // Incoming jump from 0x060D // Inputs[3] // { // @0FD8 stack[-4] // @0FD9 stack[-3] // @0FDA stack[-2] // } 0FD4 5B JUMPDEST 0FD5 61 PUSH2 0x0fdf 0FD8 84 DUP5 0FD9 84 DUP5 0FDA 84 DUP5 0FDB 61 PUSH2 0x1231 0FDE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0FD5 stack[0] = 0x0fdf // @0FD8 stack[1] = stack[-4] // @0FD9 stack[2] = stack[-3] // @0FDA stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1231 0FDF 5B JUMPDEST 0FE0 60 PUSH1 0x01 0FE2 60 PUSH1 0x01 0FE4 60 PUSH1 0xa0 0FE6 1B SHL 0FE7 03 SUB 0FE8 83 DUP4 0FE9 16 AND 0FEA 3B EXTCODESIZE 0FEB 15 ISZERO 0FEC 15 ISZERO 0FED 80 DUP1 0FEE 15 ISZERO 0FEF 61 PUSH2 0x1001 0FF2 57 *JUMPI 0FF3 50 POP 0FF4 61 PUSH2 0x0fff 0FF7 84 DUP5 0FF8 84 DUP5 0FF9 84 DUP5 0FFA 84 DUP5 0FFB 61 PUSH2 0x15ce 0FFE 56 *JUMP 0FFF 5B JUMPDEST 1000 15 ISZERO 1001 5B JUMPDEST 1002 15 ISZERO 1003 61 PUSH2 0x101f 1006 57 *JUMPI 1007 60 PUSH1 0x40 1009 51 MLOAD 100A 63 PUSH4 0x68d2bf6b 100F 60 PUSH1 0xe1 1011 1B SHL 1012 81 DUP2 1013 52 MSTORE 1014 60 PUSH1 0x04 1016 01 ADD 1017 60 PUSH1 0x40 1019 51 MLOAD 101A 80 DUP1 101B 91 SWAP2 101C 03 SUB 101D 90 SWAP1 101E FD *REVERT label_101F: // Incoming jump from 0x1D54, if !(stack[-1] > stack[-4]) // Inputs[1] { @1024 stack[-5] } 101F 5B JUMPDEST 1020 50 POP 1021 50 POP 1022 50 POP 1023 50 POP 1024 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_1025: // Incoming jump from 0x0659 // Inputs[1] { @102B stack[-1] } 1025 5B JUMPDEST 1026 60 PUSH1 0x60 1028 61 PUSH2 0x1030 102B 82 DUP3 102C 61 PUSH2 0x16b7 102F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1026 stack[0] = 0x60 // @1028 stack[1] = 0x1030 // @102B stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x16b7 1030 5B JUMPDEST 1031 60 PUSH1 0x0f 1033 60 PUSH1 0x40 1035 51 MLOAD 1036 60 PUSH1 0x20 1038 01 ADD 1039 61 PUSH2 0x1043 103C 92 SWAP3 103D 91 SWAP2 103E 90 SWAP1 103F 61 PUSH2 0x216d 1042 56 *JUMP 1043 5B JUMPDEST 1044 60 PUSH1 0x40 1046 51 MLOAD 1047 60 PUSH1 0x20 1049 81 DUP2 104A 83 DUP4 104B 03 SUB 104C 03 SUB 104D 81 DUP2 104E 52 MSTORE 104F 90 SWAP1 1050 60 PUSH1 0x40 1052 52 MSTORE 1053 90 SWAP1 1054 50 POP 1055 91 SWAP2 1056 90 SWAP1 1057 50 POP 1058 56 *JUMP label_1059: // Incoming call from 0x0684, returns to 0x02F6 // Inputs[1] { @105D storage[0x0f] } 1059 5B JUMPDEST 105A 60 PUSH1 0x0f 105C 80 DUP1 105D 54 SLOAD 105E 61 PUSH2 0x0c12 1061 90 SWAP1 1062 61 PUSH2 0x20b4 1065 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @105A stack[0] = 0x0f // @1061 stack[1] = 0x0c12 // @1061 stack[2] = storage[0x0f] // } // Block ends with call to 0x20b4, returns to 0x0C12 label_1066: // Incoming jump from 0x06A4 // Inputs[2] // { // @1069 storage[0x08] // @1073 msg.sender // } 1066 5B JUMPDEST 1067 60 PUSH1 0x08 1069 54 SLOAD 106A 60 PUSH1 0x01 106C 60 PUSH1 0x01 106E 60 PUSH1 0xa0 1070 1B SHL 1071 03 SUB 1072 16 AND 1073 33 CALLER 1074 14 EQ 1075 61 PUSH2 0x10ae 1078 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10ae, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_1079: // Incoming jump from 0x1078, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @107B memory[0x40:0x60] // @1096 memory[0x00:0x20] // @109F memory[0x00:0x20] // } 1079 60 PUSH1 0x40 107B 51 MLOAD 107C 62 PUSH3 0x461bcd 1080 60 PUSH1 0xe5 1082 1B SHL 1083 81 DUP2 1084 52 MSTORE 1085 60 PUSH1 0x20 1087 60 PUSH1 0x04 1089 82 DUP3 108A 01 ADD 108B 81 DUP2 108C 90 SWAP1 108D 52 MSTORE 108E 60 PUSH1 0x24 1090 82 DUP3 1091 01 ADD 1092 52 MSTORE 1093 60 PUSH1 0x00 1095 80 DUP1 1096 51 MLOAD 1097 60 PUSH1 0x20 1099 61 PUSH2 0x22fc 109C 83 DUP4 109D 39 CODECOPY 109E 81 DUP2 109F 51 MLOAD 10A0 91 SWAP2 10A1 52 MSTORE 10A2 60 PUSH1 0x44 10A4 82 DUP3 10A5 01 ADD 10A6 52 MSTORE 10A7 60 PUSH1 0x64 10A9 01 ADD 10AA 61 PUSH2 0x07ba 10AD 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @1084 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @108D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1092 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @109D memory[0x00:0x20] = code[0x22fc:0x231c] // @10A1 memory[0x00:0x20] = memory[0x00:0x20] // @10A6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @10A9 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x07ba label_10AE: // Incoming jump from 0x1078, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @10B1 stack[-1] // @10B2 stack[-2] // } 10AE 5B JUMPDEST 10AF 60 PUSH1 0x0b 10B1 55 SSTORE 10B2 56 *JUMP // Stack delta = -2 // Outputs[1] { @10B1 storage[0x0b] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_10B3: // Incoming jump from 0x070D // Inputs[2] // { // @10B6 storage[0x08] // @10C0 msg.sender // } 10B3 5B JUMPDEST 10B4 60 PUSH1 0x08 10B6 54 SLOAD 10B7 60 PUSH1 0x01 10B9 60 PUSH1 0x01 10BB 60 PUSH1 0xa0 10BD 1B SHL 10BE 03 SUB 10BF 16 AND 10C0 33 CALLER 10C1 14 EQ 10C2 61 PUSH2 0x10fb 10C5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10fb, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_10C6: // Incoming jump from 0x10C5, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @10C8 memory[0x40:0x60] // @10E3 memory[0x00:0x20] // @10EC memory[0x00:0x20] // } 10C6 60 PUSH1 0x40 10C8 51 MLOAD 10C9 62 PUSH3 0x461bcd 10CD 60 PUSH1 0xe5 10CF 1B SHL 10D0 81 DUP2 10D1 52 MSTORE 10D2 60 PUSH1 0x20 10D4 60 PUSH1 0x04 10D6 82 DUP3 10D7 01 ADD 10D8 81 DUP2 10D9 90 SWAP1 10DA 52 MSTORE 10DB 60 PUSH1 0x24 10DD 82 DUP3 10DE 01 ADD 10DF 52 MSTORE 10E0 60 PUSH1 0x00 10E2 80 DUP1 10E3 51 MLOAD 10E4 60 PUSH1 0x20 10E6 61 PUSH2 0x22fc 10E9 83 DUP4 10EA 39 CODECOPY 10EB 81 DUP2 10EC 51 MLOAD 10ED 91 SWAP2 10EE 52 MSTORE 10EF 60 PUSH1 0x44 10F1 82 DUP3 10F2 01 ADD 10F3 52 MSTORE 10F4 60 PUSH1 0x64 10F6 01 ADD 10F7 61 PUSH2 0x07ba 10FA 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @10D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10DA memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10DF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @10EA memory[0x00:0x20] = code[0x22fc:0x231c] // @10EE memory[0x00:0x20] = memory[0x00:0x20] // @10F3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @10F6 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x07ba label_10FB: // Incoming jump from 0x10C5, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @1104 stack[-1] } 10FB 5B JUMPDEST 10FC 60 PUSH1 0x01 10FE 60 PUSH1 0x01 1100 60 PUSH1 0xa0 1102 1B SHL 1103 03 SUB 1104 81 DUP2 1105 16 AND 1106 61 PUSH2 0x1177 1109 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1177, if stack[-1] & (0x01 << 0xa0) - 0x01 label_110A: // Incoming jump from 0x1109, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @110C memory[0x40:0x60] } 110A 60 PUSH1 0x40 110C 51 MLOAD 110D 62 PUSH3 0x461bcd 1111 60 PUSH1 0xe5 1113 1B SHL 1114 81 DUP2 1115 52 MSTORE 1116 60 PUSH1 0x20 1118 60 PUSH1 0x04 111A 82 DUP3 111B 01 ADD 111C 52 MSTORE 111D 60 PUSH1 0x26 111F 60 PUSH1 0x24 1121 82 DUP3 1122 01 ADD 1123 52 MSTORE 1124 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 1145 60 PUSH1 0x44 1147 82 DUP3 1148 01 ADD 1149 52 MSTORE 114A 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 116B 60 PUSH1 0x64 116D 82 DUP3 116E 01 ADD 116F 52 MSTORE 1170 60 PUSH1 0x84 1172 01 ADD 1173 61 PUSH2 0x07ba 1176 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1115 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @111C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1123 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1149 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @116F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // @1172 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x07ba label_1177: // Incoming jump from 0x1109, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @117B stack[-1] } 1177 5B JUMPDEST 1178 61 PUSH2 0x0a58 117B 81 DUP2 117C 61 PUSH2 0x156f 117F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1178 stack[0] = 0x0a58 // @117B stack[1] = stack[-1] // } // Block ends with call to 0x156f, returns to 0x0A58 1180 5B JUMPDEST 1181 60 PUSH1 0x01 1183 60 PUSH1 0x01 1185 60 PUSH1 0xa0 1187 1B SHL 1188 03 SUB 1189 16 AND 118A 3B EXTCODESIZE 118B 15 ISZERO 118C 15 ISZERO 118D 90 SWAP1 118E 56 *JUMP label_118F: // Incoming call from 0x0872, returns to 0x0873 // Incoming call from 0x16C1, returns to 0x16C2 // Incoming call from 0x0B93, returns to 0x0770 // Inputs[1] { @1192 stack[-1] } 118F 5B JUMPDEST 1190 60 PUSH1 0x00 1192 81 DUP2 1193 60 PUSH1 0x01 1195 11 GT 1196 15 ISZERO 1197 80 DUP1 1198 15 ISZERO 1199 61 PUSH2 0x11a3 119C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1190 stack[0] = 0x00 // @1196 stack[1] = !(0x01 > stack[-1]) // } // Block ends with conditional jump to 0x11a3, if !!(0x01 > stack[-1]) label_119D: // Incoming jump from 0x119C, if not !!(0x01 > stack[-1]) // Inputs[2] // { // @11A0 storage[0x00] // @11A1 stack[-3] // } 119D 50 POP 119E 60 PUSH1 0x00 11A0 54 SLOAD 11A1 82 DUP3 11A2 10 LT 11A3 5B JUMPDEST 11A4 80 DUP1 11A5 15 ISZERO 11A6 61 PUSH2 0x0770 11A9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @11A2 stack[-1] = stack[-3] < storage[0x00] } // Block ends with conditional jump to 0x0770, if !(stack[-3] < storage[0x00]) label_11AA: // Incoming jump from 0x11A9, if not !stack[-1] // Incoming jump from 0x11A9, if not !(stack[-3] < storage[0x00]) // Inputs[4] // { // @11AE stack[-3] // @11B9 memory[0x00:0x40] // @11BA storage[keccak256(memory[0x00:0x40])] // @11C6 stack[-4] // } 11AA 50 POP 11AB 50 POP 11AC 60 PUSH1 0x00 11AE 90 SWAP1 11AF 81 DUP2 11B0 52 MSTORE 11B1 60 PUSH1 0x04 11B3 60 PUSH1 0x20 11B5 52 MSTORE 11B6 60 PUSH1 0x40 11B8 90 SWAP1 11B9 20 SHA3 11BA 54 SLOAD 11BB 60 PUSH1 0x01 11BD 60 PUSH1 0xe0 11BF 1B SHL 11C0 90 SWAP1 11C1 04 DIV 11C2 60 PUSH1 0xff 11C4 16 AND 11C5 15 ISZERO 11C6 90 SWAP1 11C7 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @11B0 memory[0x00:0x20] = stack[-3] // @11B5 memory[0x20:0x40] = 0x04 // @11C6 stack[-4] = !(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with unconditional jump to stack[-4] label_11C8: // Incoming call from 0x0934, returns to 0x0935 // Incoming call from 0x12FE, returns to 0x12FF // Incoming call from 0x17B8, returns to 0x17B9 // Inputs[8] // { // @11CB stack[-2] // @11D7 memory[0x00:0x40] // @11D9 storage[keccak256(memory[0x00:0x40])] // @11F9 stack[-3] // @1203 memory[0x40:0x60] // @1207 stack[-1] // @122C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1230 stack[-4] // } 11C8 5B JUMPDEST 11C9 60 PUSH1 0x00 11CB 82 DUP3 11CC 81 DUP2 11CD 52 MSTORE 11CE 60 PUSH1 0x06 11D0 60 PUSH1 0x20 11D2 52 MSTORE 11D3 60 PUSH1 0x40 11D5 80 DUP1 11D6 82 DUP3 11D7 20 SHA3 11D8 80 DUP1 11D9 54 SLOAD 11DA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11EF 19 NOT 11F0 16 AND 11F1 60 PUSH1 0x01 11F3 60 PUSH1 0x01 11F5 60 PUSH1 0xa0 11F7 1B SHL 11F8 03 SUB 11F9 87 DUP8 11FA 81 DUP2 11FB 16 AND 11FC 91 SWAP2 11FD 82 DUP3 11FE 17 OR 11FF 90 SWAP1 1200 92 SWAP3 1201 55 SSTORE 1202 91 SWAP2 1203 51 MLOAD 1204 85 DUP6 1205 93 SWAP4 1206 91 SWAP2 1207 85 DUP6 1208 16 AND 1209 91 SWAP2 120A 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 122B 91 SWAP2 122C A4 LOG4 122D 50 POP 122E 50 POP 122F 50 POP 1230 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @11CD memory[0x00:0x20] = stack[-2] // @11D2 memory[0x20:0x40] = 0x06 // @1201 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @122C 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_1231: // Incoming jump from 0x0FDE // Incoming jump from 0x0944 // Inputs[1] { @1237 stack[-1] } 1231 5B JUMPDEST 1232 60 PUSH1 0x00 1234 61 PUSH2 0x123c 1237 82 DUP3 1238 61 PUSH2 0x1446 123B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1232 stack[0] = 0x00 // @1234 stack[1] = 0x123c // @1237 stack[2] = stack[-1] // } // Block ends with call to 0x1446, returns to 0x123C label_123C: // Incoming return from call to 0x1446 at 0x123B // Inputs[4] // { // @123D stack[-1] // @123D stack[-2] // @123F stack[-5] // @124D memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } 123C 5B JUMPDEST 123D 90 SWAP1 123E 50 POP 123F 83 DUP4 1240 60 PUSH1 0x01 1242 60 PUSH1 0x01 1244 60 PUSH1 0xa0 1246 1B SHL 1247 03 SUB 1248 16 AND 1249 81 DUP2 124A 60 PUSH1 0x00 124C 01 ADD 124D 51 MLOAD 124E 60 PUSH1 0x01 1250 60 PUSH1 0x01 1252 60 PUSH1 0xa0 1254 1B SHL 1255 03 SUB 1256 16 AND 1257 14 EQ 1258 61 PUSH2 0x1273 125B 57 *JUMPI // Stack delta = -1 // Outputs[1] { @123D stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1273, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] label_125C: // Incoming jump from 0x125B, if not (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @125E memory[0x40:0x60] // @126D memory[0x40:0x60] // @1272 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 125C 60 PUSH1 0x40 125E 51 MLOAD 125F 62 PUSH3 0xa11481 1263 60 PUSH1 0xe8 1265 1B SHL 1266 81 DUP2 1267 52 MSTORE 1268 60 PUSH1 0x04 126A 01 ADD 126B 60 PUSH1 0x40 126D 51 MLOAD 126E 80 DUP1 126F 91 SWAP2 1270 03 SUB 1271 90 SWAP1 1272 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1267 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa11481 << 0xe8 // @1272 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1273: // Incoming jump from 0x125B, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[2] // { // @1276 msg.sender // @127F stack[-4] // } 1273 5B JUMPDEST 1274 60 PUSH1 0x00 1276 33 CALLER 1277 60 PUSH1 0x01 1279 60 PUSH1 0x01 127B 60 PUSH1 0xa0 127D 1B SHL 127E 03 SUB 127F 86 DUP7 1280 16 AND 1281 14 EQ 1282 80 DUP1 1283 61 PUSH2 0x1291 1286 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1274 stack[0] = 0x00 // @1281 stack[1] = stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // } // Block ends with conditional jump to 0x1291, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender label_1287: // Incoming jump from 0x1286, if not stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @128B stack[-6] // @128C msg.sender // } 1287 50 POP 1288 61 PUSH2 0x1291 128B 85 DUP6 128C 33 CALLER 128D 61 PUSH2 0x06c0 1290 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1288 stack[-1] = 0x1291 // @128B stack[0] = stack[-6] // @128C stack[1] = msg.sender // } // Block ends with call to 0x06c0, returns to 0x1291 label_1291: // Incoming jump from 0x1286, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming return from call to 0x06C0 at 0x1290 // Inputs[1] { @1292 stack[-1] } 1291 5B JUMPDEST 1292 80 DUP1 1293 61 PUSH2 0x12ac 1296 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12ac, if stack[-1] label_1297: // Incoming jump from 0x1296, if not stack[-1] // Inputs[2] // { // @1298 msg.sender // @129C stack[-4] // } 1297 50 POP 1298 33 CALLER 1299 61 PUSH2 0x12a1 129C 84 DUP5 129D 61 PUSH2 0x0868 12A0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1298 stack[-1] = msg.sender // @1299 stack[0] = 0x12a1 // @129C stack[1] = stack[-4] // } // Block ends with call to 0x0868, returns to 0x12A1 label_12A1: // Incoming return from call to 0x0868 at 0x12A0 // Inputs[2] // { // @12AA stack[-1] // @12AB stack[-2] // } 12A1 5B JUMPDEST 12A2 60 PUSH1 0x01 12A4 60 PUSH1 0x01 12A6 60 PUSH1 0xa0 12A8 1B SHL 12A9 03 SUB 12AA 16 AND 12AB 14 EQ // Stack delta = -1 // Outputs[1] { @12AB stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_12AC: // Incoming jump from 0x12AB // Incoming jump from 0x1296, if stack[-1] // Inputs[2] // { // @12AD stack[-1] // @12AD stack[-2] // } 12AC 5B JUMPDEST 12AD 90 SWAP1 12AE 50 POP 12AF 80 DUP1 12B0 61 PUSH2 0x12cc 12B3 57 *JUMPI // Stack delta = -1 // Outputs[1] { @12AD stack[-2] = stack[-1] } // Block ends with conditional jump to 0x12cc, if stack[-1] label_12B4: // Incoming jump from 0x12B3, if not stack[-1] // Inputs[3] // { // @12B6 memory[0x40:0x60] // @12C6 memory[0x40:0x60] // @12CB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 12B4 60 PUSH1 0x40 12B6 51 MLOAD 12B7 63 PUSH4 0x2ce44b5f 12BC 60 PUSH1 0xe1 12BE 1B SHL 12BF 81 DUP2 12C0 52 MSTORE 12C1 60 PUSH1 0x04 12C3 01 ADD 12C4 60 PUSH1 0x40 12C6 51 MLOAD 12C7 80 DUP1 12C8 91 SWAP2 12C9 03 SUB 12CA 90 SWAP1 12CB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @12C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @12CB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_12CC: // Incoming jump from 0x12B3, if stack[-1] // Inputs[1] { @12D5 stack[-4] } 12CC 5B JUMPDEST 12CD 60 PUSH1 0x01 12CF 60 PUSH1 0x01 12D1 60 PUSH1 0xa0 12D3 1B SHL 12D4 03 SUB 12D5 84 DUP5 12D6 16 AND 12D7 61 PUSH2 0x12f3 12DA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12f3, if stack[-4] & (0x01 << 0xa0) - 0x01 label_12DB: // Incoming jump from 0x12DA, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @12DD memory[0x40:0x60] // @12ED memory[0x40:0x60] // @12F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 12DB 60 PUSH1 0x40 12DD 51 MLOAD 12DE 63 PUSH4 0x3a954ecd 12E3 60 PUSH1 0xe2 12E5 1B SHL 12E6 81 DUP2 12E7 52 MSTORE 12E8 60 PUSH1 0x04 12EA 01 ADD 12EB 60 PUSH1 0x40 12ED 51 MLOAD 12EE 80 DUP1 12EF 91 SWAP2 12F0 03 SUB 12F1 90 SWAP1 12F2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @12E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3a954ecd << 0xe2 // @12F2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_12F3: // Incoming jump from 0x12DA, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @12F9 stack[-3] // @12FA stack[-5] // } 12F3 5B JUMPDEST 12F4 61 PUSH2 0x12ff 12F7 60 PUSH1 0x00 12F9 84 DUP5 12FA 87 DUP8 12FB 61 PUSH2 0x11c8 12FE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @12F4 stack[0] = 0x12ff // @12F7 stack[1] = 0x00 // @12F9 stack[2] = stack[-3] // @12FA stack[3] = stack[-5] // } // Block ends with call to 0x11c8, returns to 0x12FF label_12FF: // Incoming return from call to 0x11C8 at 0x12FE // Inputs[12] // { // @1308 stack[-5] // @131B memory[0x00:0x40] // @131D storage[keccak256(memory[0x00:0x40])] // @1341 stack[-4] // @1349 memory[0x00:0x40] // @134B storage[keccak256(memory[0x00:0x40])] // @135F stack[-3] // @1369 memory[0x00:0x40] // @136B storage[keccak256(memory[0x00:0x40])] // @137E block.timestamp // @138F memory[0x00:0x40] // @1391 storage[keccak256(memory[0x00:0x40])] // } 12FF 5B JUMPDEST 1300 60 PUSH1 0x01 1302 60 PUSH1 0x01 1304 60 PUSH1 0xa0 1306 1B SHL 1307 03 SUB 1308 85 DUP6 1309 81 DUP2 130A 16 AND 130B 60 PUSH1 0x00 130D 90 SWAP1 130E 81 DUP2 130F 52 MSTORE 1310 60 PUSH1 0x05 1312 60 PUSH1 0x20 1314 90 SWAP1 1315 81 DUP2 1316 52 MSTORE 1317 60 PUSH1 0x40 1319 80 DUP1 131A 83 DUP4 131B 20 SHA3 131C 80 DUP1 131D 54 SLOAD 131E 67 PUSH8 0xffffffffffffffff 1327 19 NOT 1328 80 DUP1 1329 82 DUP3 132A 16 AND 132B 67 PUSH8 0xffffffffffffffff 1334 92 SWAP3 1335 83 DUP4 1336 16 AND 1337 60 PUSH1 0x00 1339 19 NOT 133A 01 ADD 133B 83 DUP4 133C 16 AND 133D 17 OR 133E 90 SWAP1 133F 92 SWAP3 1340 55 SSTORE 1341 89 DUP10 1342 86 DUP7 1343 16 AND 1344 80 DUP1 1345 86 DUP7 1346 52 MSTORE 1347 83 DUP4 1348 86 DUP7 1349 20 SHA3 134A 80 DUP1 134B 54 SLOAD 134C 93 SWAP4 134D 84 DUP5 134E 16 AND 134F 93 SWAP4 1350 83 DUP4 1351 16 AND 1352 60 PUSH1 0x01 1354 90 SWAP1 1355 81 DUP2 1356 01 ADD 1357 84 DUP5 1358 16 AND 1359 94 SWAP5 135A 90 SWAP1 135B 94 SWAP5 135C 17 OR 135D 90 SWAP1 135E 55 SSTORE 135F 89 DUP10 1360 86 DUP7 1361 52 MSTORE 1362 60 PUSH1 0x04 1364 90 SWAP1 1365 94 SWAP5 1366 52 MSTORE 1367 82 DUP3 1368 85 DUP6 1369 20 SHA3 136A 80 DUP1 136B 54 SLOAD 136C 60 PUSH1 0x01 136E 60 PUSH1 0x01 1370 60 PUSH1 0xe0 1372 1B SHL 1373 03 SUB 1374 19 NOT 1375 16 AND 1376 90 SWAP1 1377 94 SWAP5 1378 17 OR 1379 60 PUSH1 0x01 137B 60 PUSH1 0xa0 137D 1B SHL 137E 42 TIMESTAMP 137F 90 SWAP1 1380 92 SWAP3 1381 16 AND 1382 91 SWAP2 1383 90 SWAP1 1384 91 SWAP2 1385 02 MUL 1386 17 OR 1387 83 DUP4 1388 55 SSTORE 1389 87 DUP8 138A 01 ADD 138B 80 DUP1 138C 84 DUP5 138D 52 MSTORE 138E 92 SWAP3 138F 20 SHA3 1390 80 DUP1 1391 54 SLOAD 1392 91 SWAP2 1393 93 SWAP4 1394 90 SWAP1 1395 91 SWAP2 1396 16 AND 1397 61 PUSH2 0x13d5 139A 57 *JUMPI // Stack delta = +3 // Outputs[12] // { // @130F memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1316 memory[0x20:0x40] = 0x05 // @1340 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & ~0x00 + (0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @1346 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @135E storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & 0x01 + (0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @1361 memory[0x00:0x20] = stack[-3] // @1366 memory[0x20:0x40] = 0x04 // @1388 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | ((0x01 << 0xa0) - 0x01 & stack[-4]) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @138D memory[0x00:0x20] = stack[-3] + 0x01 // @138E stack[1] = stack[-3] + 0x01 // @1393 stack[0] = keccak256(memory[0x00:0x40]) // @1395 stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x13d5, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_139B: // Incoming jump from 0x139A, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @139D storage[0x00] // @139E stack[-2] // } 139B 60 PUSH1 0x00 139D 54 SLOAD 139E 82 DUP3 139F 14 EQ 13A0 61 PUSH2 0x13d5 13A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13d5, if stack[-2] == storage[0x00] label_13A4: // Incoming jump from 0x13A3, if not stack[-2] == storage[0x00] // Inputs[5] // { // @13A4 stack[-1] // @13A5 storage[stack[-1]] // @13A8 stack[-5] // @13AA memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @13CF stack[-8] // } 13A4 80 DUP1 13A5 54 SLOAD 13A6 60 PUSH1 0x20 13A8 86 DUP7 13A9 01 ADD 13AA 51 MLOAD 13AB 67 PUSH8 0xffffffffffffffff 13B4 16 AND 13B5 60 PUSH1 0x01 13B7 60 PUSH1 0xa0 13B9 1B SHL 13BA 02 MUL 13BB 60 PUSH1 0x01 13BD 60 PUSH1 0x01 13BF 60 PUSH1 0xe0 13C1 1B SHL 13C2 03 SUB 13C3 19 NOT 13C4 90 SWAP1 13C5 91 SWAP2 13C6 16 AND 13C7 60 PUSH1 0x01 13C9 60 PUSH1 0x01 13CB 60 PUSH1 0xa0 13CD 1B SHL 13CE 03 SUB 13CF 8A DUP11 13D0 16 AND 13D1 17 OR 13D2 17 OR 13D3 81 DUP2 13D4 55 SSTORE // Stack delta = +0 // Outputs[1] { @13D4 storage[stack[-1]] = (stack[-8] & (0x01 << 0xa0) - 0x01) | (storage[stack[-1]] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * (0xffffffffffffffff & memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20]) } // Block continues label_13D5: // Incoming jump from 0x13A3, if stack[-2] == storage[0x00] // Incoming jump from 0x13D4 // Incoming jump from 0x139A, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @13D9 stack[-6] // @13DA stack[-7] // @13E4 stack[-8] // @1411 memory[0x40:0x60] // @1414 memory[0x40:0x60] // @1419 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 13D5 5B JUMPDEST 13D6 50 POP 13D7 50 POP 13D8 50 POP 13D9 82 DUP3 13DA 84 DUP5 13DB 60 PUSH1 0x01 13DD 60 PUSH1 0x01 13DF 60 PUSH1 0xa0 13E1 1B SHL 13E2 03 SUB 13E3 16 AND 13E4 86 DUP7 13E5 60 PUSH1 0x01 13E7 60 PUSH1 0x01 13E9 60 PUSH1 0xa0 13EB 1B SHL 13EC 03 SUB 13ED 16 AND 13EE 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 140F 60 PUSH1 0x40 1411 51 MLOAD 1412 60 PUSH1 0x40 1414 51 MLOAD 1415 80 DUP1 1416 91 SWAP2 1417 03 SUB 1418 90 SWAP1 1419 A4 LOG4 // Stack delta = -3 // Outputs[1] { @1419 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-8] & (0x01 << 0xa0) - 0x01, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-6]]); } // Block continues label_141A: // Incoming jump from 0x1419 // Incoming jump from 0x1C34 // Inputs[1] { @1420 stack[-6] } 141A 5B JUMPDEST 141B 50 POP 141C 50 POP 141D 50 POP 141E 50 POP 141F 50 POP 1420 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_1421: // Incoming jump from 0x0B4E // Inputs[1] { @1425 stack[-1] } 1421 5B JUMPDEST 1422 61 PUSH2 0x0a58 1425 81 DUP2 1426 60 PUSH1 0x00 1428 61 PUSH2 0x173c 142B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1422 stack[0] = 0x0a58 // @1425 stack[1] = stack[-1] // @1426 stack[2] = 0x00 // } // Block ends with call to 0x173c, returns to 0x0A58 label_142C: // Incoming call from 0x0F3D, returns to 0x0A58 // Incoming call from 0x0B6D, returns to 0x0A58 // Inputs[3] // { // @1430 stack[-2] // @1431 stack[-1] // @1434 memory[0x40:0x60] // } 142C 5B JUMPDEST 142D 61 PUSH2 0x0bef 1430 82 DUP3 1431 82 DUP3 1432 60 PUSH1 0x40 1434 51 MLOAD 1435 80 DUP1 1436 60 PUSH1 0x20 1438 01 ADD 1439 60 PUSH1 0x40 143B 52 MSTORE 143C 80 DUP1 143D 60 PUSH1 0x00 143F 81 DUP2 1440 52 MSTORE 1441 50 POP 1442 61 PUSH2 0x1932 1445 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @142D stack[0] = 0x0bef // @1430 stack[1] = stack[-2] // @1431 stack[2] = stack[-1] // @1434 stack[3] = memory[0x40:0x60] // @143B memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1440 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x1932, returns to 0x0BEF label_1446: // Incoming call from 0x0BFD, returns to 0x0BFE // Incoming call from 0x123B, returns to 0x123C // Incoming call from 0x1746, returns to 0x1747 // Inputs[2] // { // @144A memory[0x40:0x60] // @1464 stack[-1] // } 1446 5B JUMPDEST 1447 60 PUSH1 0x40 1449 80 DUP1 144A 51 MLOAD 144B 60 PUSH1 0x60 144D 81 DUP2 144E 01 ADD 144F 82 DUP3 1450 52 MSTORE 1451 60 PUSH1 0x00 1453 80 DUP1 1454 82 DUP3 1455 52 MSTORE 1456 60 PUSH1 0x20 1458 82 DUP3 1459 01 ADD 145A 81 DUP2 145B 90 SWAP1 145C 52 MSTORE 145D 91 SWAP2 145E 81 DUP2 145F 01 ADD 1460 91 SWAP2 1461 90 SWAP1 1462 91 SWAP2 1463 52 MSTORE 1464 81 DUP2 1465 80 DUP1 1466 60 PUSH1 0x01 1468 11 GT 1469 15 ISZERO 146A 80 DUP1 146B 15 ISZERO 146C 61 PUSH2 0x1476 146F 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @1450 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1455 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @145C memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @1462 stack[0] = memory[0x40:0x60] // @1463 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @1464 stack[1] = stack[-1] // @1469 stack[2] = !(0x01 > stack[-1]) // } // Block ends with conditional jump to 0x1476, if !!(0x01 > stack[-1]) label_1470: // Incoming jump from 0x146F, if not !!(0x01 > stack[-1]) // Inputs[2] // { // @1473 storage[0x00] // @1474 stack[-2] // } 1470 50 POP 1471 60 PUSH1 0x00 1473 54 SLOAD 1474 81 DUP2 1475 10 LT 1476 5B JUMPDEST 1477 15 ISZERO 1478 61 PUSH2 0x1556 147B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1556, if !(stack[-2] < storage[0x00]) label_147C: // Incoming jump from 0x147B, if not !(stack[-2] < storage[0x00]) // Incoming jump from 0x147B, if not !stack[-1] // Inputs[4] // { // @147E stack[-1] // @148D memory[0x00:0x40] // @148F memory[0x40:0x60] // @1497 storage[keccak256(memory[0x00:0x40])] // } 147C 60 PUSH1 0x00 147E 81 DUP2 147F 81 DUP2 1480 52 MSTORE 1481 60 PUSH1 0x04 1483 60 PUSH1 0x20 1485 90 SWAP1 1486 81 DUP2 1487 52 MSTORE 1488 60 PUSH1 0x40 148A 91 SWAP2 148B 82 DUP3 148C 90 SWAP1 148D 20 SHA3 148E 82 DUP3 148F 51 MLOAD 1490 60 PUSH1 0x60 1492 81 DUP2 1493 01 ADD 1494 84 DUP5 1495 52 MSTORE 1496 90 SWAP1 1497 54 SLOAD 1498 60 PUSH1 0x01 149A 60 PUSH1 0x01 149C 60 PUSH1 0xa0 149E 1B SHL 149F 03 SUB 14A0 81 DUP2 14A1 16 AND 14A2 82 DUP3 14A3 52 MSTORE 14A4 60 PUSH1 0x01 14A6 60 PUSH1 0xa0 14A8 1B SHL 14A9 81 DUP2 14AA 04 DIV 14AB 67 PUSH8 0xffffffffffffffff 14B4 16 AND 14B5 92 SWAP3 14B6 82 DUP3 14B7 01 ADD 14B8 92 SWAP3 14B9 90 SWAP1 14BA 92 SWAP3 14BB 52 MSTORE 14BC 60 PUSH1 0x01 14BE 60 PUSH1 0xe0 14C0 1B SHL 14C1 90 SWAP1 14C2 91 SWAP2 14C3 04 DIV 14C4 60 PUSH1 0xff 14C6 16 AND 14C7 15 ISZERO 14C8 15 ISZERO 14C9 91 SWAP2 14CA 81 DUP2 14CB 01 ADD 14CC 82 DUP3 14CD 90 SWAP1 14CE 52 MSTORE 14CF 90 SWAP1 14D0 61 PUSH2 0x1554 14D3 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @1480 memory[0x00:0x20] = stack[-1] // @1487 memory[0x20:0x40] = 0x04 // @1495 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @14A3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @14BB memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @14CE memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // @14CF stack[0] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x1554, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) label_14D4: // Incoming jump from 0x14D3, if not !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // Inputs[2] // { // @14D4 stack[-1] // @14D5 memory[stack[-1]:stack[-1] + 0x20] // } 14D4 80 DUP1 14D5 51 MLOAD 14D6 60 PUSH1 0x01 14D8 60 PUSH1 0x01 14DA 60 PUSH1 0xa0 14DC 1B SHL 14DD 03 SUB 14DE 16 AND 14DF 15 ISZERO 14E0 61 PUSH2 0x14ea 14E3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14ea, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) label_14E4: // Incoming jump from 0x14E3, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @14E4 stack[-1] // @14E4 stack[-5] // @14E5 stack[-4] // } 14E4 93 SWAP4 14E5 92 SWAP3 14E6 50 POP 14E7 50 POP 14E8 50 POP 14E9 56 *JUMP // Stack delta = -4 // Outputs[1] { @14E4 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_14EA: // Incoming jump from 0x1553 // Incoming jump from 0x14E3, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @14EF stack[-2] // @1501 memory[0x00:0x40] // @1503 memory[0x40:0x60] // @150B storage[keccak256(memory[0x00:0x40])] // } 14EA 5B JUMPDEST 14EB 50 POP 14EC 60 PUSH1 0x00 14EE 19 NOT 14EF 01 ADD 14F0 60 PUSH1 0x00 14F2 81 DUP2 14F3 81 DUP2 14F4 52 MSTORE 14F5 60 PUSH1 0x04 14F7 60 PUSH1 0x20 14F9 90 SWAP1 14FA 81 DUP2 14FB 52 MSTORE 14FC 60 PUSH1 0x40 14FE 91 SWAP2 14FF 82 DUP3 1500 90 SWAP1 1501 20 SHA3 1502 82 DUP3 1503 51 MLOAD 1504 60 PUSH1 0x60 1506 81 DUP2 1507 01 ADD 1508 84 DUP5 1509 52 MSTORE 150A 90 SWAP1 150B 54 SLOAD 150C 60 PUSH1 0x01 150E 60 PUSH1 0x01 1510 60 PUSH1 0xa0 1512 1B SHL 1513 03 SUB 1514 81 DUP2 1515 16 AND 1516 80 DUP1 1517 83 DUP4 1518 52 MSTORE 1519 60 PUSH1 0x01 151B 60 PUSH1 0xa0 151D 1B SHL 151E 82 DUP3 151F 04 DIV 1520 67 PUSH8 0xffffffffffffffff 1529 16 AND 152A 93 SWAP4 152B 83 DUP4 152C 01 ADD 152D 93 SWAP4 152E 90 SWAP1 152F 93 SWAP4 1530 52 MSTORE 1531 60 PUSH1 0x01 1533 60 PUSH1 0xe0 1535 1B SHL 1536 90 SWAP1 1537 04 DIV 1538 60 PUSH1 0xff 153A 16 AND 153B 15 ISZERO 153C 15 ISZERO 153D 92 SWAP3 153E 81 DUP2 153F 01 ADD 1540 92 SWAP3 1541 90 SWAP1 1542 92 SWAP3 1543 52 MSTORE 1544 15 ISZERO 1545 61 PUSH2 0x154f 1548 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @14EF stack[-2] = ~0x00 + stack[-2] // @14F4 memory[0x00:0x20] = ~0x00 + stack[-2] // @14FB memory[0x20:0x40] = 0x04 // @1509 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1518 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @1530 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @1542 stack[-1] = memory[0x40:0x60] // @1543 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with conditional jump to 0x154f, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_1549: // Incoming jump from 0x1548, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @1549 stack[-5] // @1549 stack[-1] // @154A stack[-4] // } 1549 93 SWAP4 154A 92 SWAP3 154B 50 POP 154C 50 POP 154D 50 POP 154E 56 *JUMP // Stack delta = -4 // Outputs[1] { @1549 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_154F: // Incoming jump from 0x1548, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) 154F 5B JUMPDEST 1550 61 PUSH2 0x14ea 1553 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x14ea label_1554: // Incoming jump from 0x14D3, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) 1554 5B JUMPDEST 1555 50 POP // Stack delta = -1 // Block continues label_1556: // Incoming jump from 0x147B, if !stack[-1] // Incoming jump from 0x1555 // Incoming jump from 0x147B, if !(stack[-2] < storage[0x00]) // Inputs[3] // { // @1559 memory[0x40:0x60] // @1569 memory[0x40:0x60] // @156E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1556 5B JUMPDEST 1557 60 PUSH1 0x40 1559 51 MLOAD 155A 63 PUSH4 0x6f96cda1 155F 60 PUSH1 0xe1 1561 1B SHL 1562 81 DUP2 1563 52 MSTORE 1564 60 PUSH1 0x04 1566 01 ADD 1567 60 PUSH1 0x40 1569 51 MLOAD 156A 80 DUP1 156B 91 SWAP2 156C 03 SUB 156D 90 SWAP1 156E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1563 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @156E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_156F: // Incoming call from 0x117F, returns to 0x0A58 // Incoming call from 0x0D80, returns to 0x0D81 // Inputs[5] // { // @1573 storage[0x08] // @157C stack[-1] // @159E memory[0x40:0x60] // @15CA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @15CD stack[-2] // } 156F 5B JUMPDEST 1570 60 PUSH1 0x08 1572 80 DUP1 1573 54 SLOAD 1574 60 PUSH1 0x01 1576 60 PUSH1 0x01 1578 60 PUSH1 0xa0 157A 1B SHL 157B 03 SUB 157C 83 DUP4 157D 81 DUP2 157E 16 AND 157F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1594 19 NOT 1595 83 DUP4 1596 16 AND 1597 81 DUP2 1598 17 OR 1599 90 SWAP1 159A 93 SWAP4 159B 55 SSTORE 159C 60 PUSH1 0x40 159E 51 MLOAD 159F 91 SWAP2 15A0 16 AND 15A1 91 SWAP2 15A2 90 SWAP1 15A3 82 DUP3 15A4 90 SWAP1 15A5 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 15C6 90 SWAP1 15C7 60 PUSH1 0x00 15C9 90 SWAP1 15CA A3 LOG3 15CB 50 POP 15CC 50 POP 15CD 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @159B storage[0x08] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x08] & ~0xffffffffffffffffffffffffffffffffffffffff) // @15CA log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x08] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_15CE: // Incoming jump from 0x1BAD // Inputs[6] // { // @15D1 memory[0x40:0x60] // @15E7 stack[-3] // @15F4 msg.sender // @15F6 stack[-4] // @15F8 stack[-2] // @15FA stack[-1] // } 15CE 5B JUMPDEST 15CF 60 PUSH1 0x40 15D1 51 MLOAD 15D2 63 PUSH4 0x0a85bd01 15D7 60 PUSH1 0xe1 15D9 1B SHL 15DA 81 DUP2 15DB 52 MSTORE 15DC 60 PUSH1 0x00 15DE 90 SWAP1 15DF 60 PUSH1 0x01 15E1 60 PUSH1 0x01 15E3 60 PUSH1 0xa0 15E5 1B SHL 15E6 03 SUB 15E7 85 DUP6 15E8 16 AND 15E9 90 SWAP1 15EA 63 PUSH4 0x150b7a02 15EF 90 SWAP1 15F0 61 PUSH2 0x1603 15F3 90 SWAP1 15F4 33 CALLER 15F5 90 SWAP1 15F6 89 DUP10 15F7 90 SWAP1 15F8 88 DUP9 15F9 90 SWAP1 15FA 88 DUP9 15FB 90 SWAP1 15FC 60 PUSH1 0x04 15FE 01 ADD 15FF 61 PUSH2 0x221e 1602 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @15DB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @15DE stack[0] = 0x00 // @15E9 stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @15EF stack[2] = 0x150b7a02 // @15F3 stack[3] = 0x1603 // @15F5 stack[4] = msg.sender // @15F7 stack[5] = stack[-4] // @15F9 stack[6] = stack[-2] // @15FB stack[7] = stack[-1] // @15FE stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x221e, returns to 0x1603 label_1603: // Incoming return from call to 0x221E at 0x1602 // Inputs[6] // { // @1608 memory[0x40:0x60] // @160A stack[-1] // @160F stack[-3] // @1610 msg.gas // @1611 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @1611 address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } 1603 5B JUMPDEST 1604 60 PUSH1 0x20 1606 60 PUSH1 0x40 1608 51 MLOAD 1609 80 DUP1 160A 83 DUP4 160B 03 SUB 160C 81 DUP2 160D 60 PUSH1 0x00 160F 87 DUP8 1610 5A GAS 1611 F1 CALL 1612 92 SWAP3 1613 50 POP 1614 50 POP 1615 50 POP 1616 80 DUP1 1617 15 ISZERO 1618 61 PUSH2 0x163e 161B 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1611 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]]) // @1612 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 0x163e, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_161C: // Incoming jump from 0x161B, if not !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[2] // { // @1620 memory[0x40:0x60] // @1623 returndata.length // } 161C 50 POP 161D 60 PUSH1 0x40 161F 80 DUP1 1620 51 MLOAD 1621 60 PUSH1 0x1f 1623 3D RETURNDATASIZE 1624 90 SWAP1 1625 81 DUP2 1626 01 ADD 1627 60 PUSH1 0x1f 1629 19 NOT 162A 16 AND 162B 82 DUP3 162C 01 ADD 162D 90 SWAP1 162E 92 SWAP3 162F 52 MSTORE 1630 61 PUSH2 0x163b 1633 91 SWAP2 1634 81 DUP2 1635 01 ADD 1636 90 SWAP1 1637 61 PUSH2 0x225a 163A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @162F memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1633 stack[-1] = 0x163b // @1636 stack[1] = memory[0x40:0x60] // @1636 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x225a 163B 5B JUMPDEST 163C 60 PUSH1 0x01 label_163E: // Incoming jump from 0x161B, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[1] { @1642 stack[-1] } 163E 5B JUMPDEST 163F 61 PUSH2 0x1699 1642 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1699, if stack[-1] label_1643: // Incoming jump from 0x1642, if not stack[-1] // Inputs[1] { @1643 returndata.length } 1643 3D RETURNDATASIZE 1644 80 DUP1 1645 80 DUP1 1646 15 ISZERO 1647 61 PUSH2 0x166c 164A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1643 stack[0] = returndata.length // @1644 stack[1] = returndata.length // } // Block ends with conditional jump to 0x166c, if !returndata.length label_164B: // Incoming jump from 0x164A, if not !returndata.length // Inputs[6] // { // @164D memory[0x40:0x60] // @164E stack[-2] // @1655 returndata.length // @165D returndata.length // @1660 returndata.length // @1667 returndata[0x00:0x00 + returndata.length] // } 164B 60 PUSH1 0x40 164D 51 MLOAD 164E 91 SWAP2 164F 50 POP 1650 60 PUSH1 0x1f 1652 19 NOT 1653 60 PUSH1 0x3f 1655 3D RETURNDATASIZE 1656 01 ADD 1657 16 AND 1658 82 DUP3 1659 01 ADD 165A 60 PUSH1 0x40 165C 52 MSTORE 165D 3D RETURNDATASIZE 165E 82 DUP3 165F 52 MSTORE 1660 3D RETURNDATASIZE 1661 60 PUSH1 0x00 1663 60 PUSH1 0x20 1665 84 DUP5 1666 01 ADD 1667 3E RETURNDATACOPY 1668 61 PUSH2 0x1671 166B 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @164E stack[-2] = memory[0x40:0x60] // @165C memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @165F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1667 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1671 label_166C: // Incoming jump from 0x164A, if !returndata.length // Inputs[2] // { // @166F stack[-2] // @1674 memory[0x60:0x80] // } 166C 5B JUMPDEST 166D 60 PUSH1 0x60 166F 91 SWAP2 1670 50 POP 1671 5B JUMPDEST 1672 50 POP 1673 80 DUP1 1674 51 MLOAD 1675 61 PUSH2 0x1691 1678 57 *JUMPI // Stack delta = -1 // Outputs[1] { @166F stack[-2] = 0x60 } // Block ends with conditional jump to 0x1691, if memory[0x60:0x80] label_1679: // Incoming jump from 0x1678, if not memory[0x60:0x80] // Incoming jump from 0x1678, if not memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @167B memory[0x40:0x60] // @168B memory[0x40:0x60] // @1690 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1679 60 PUSH1 0x40 167B 51 MLOAD 167C 63 PUSH4 0x68d2bf6b 1681 60 PUSH1 0xe1 1683 1B SHL 1684 81 DUP2 1685 52 MSTORE 1686 60 PUSH1 0x04 1688 01 ADD 1689 60 PUSH1 0x40 168B 51 MLOAD 168C 80 DUP1 168D 91 SWAP2 168E 03 SUB 168F 90 SWAP1 1690 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1685 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @1690 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1691: // Incoming jump from 0x1678, if memory[0x60:0x80] // Incoming jump from 0x1678, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @1692 stack[-1] // @1693 memory[stack[-1]:stack[-1] + 0x20] // @1698 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 1691 5B JUMPDEST 1692 80 DUP1 1693 51 MLOAD 1694 81 DUP2 1695 60 PUSH1 0x20 1697 01 ADD 1698 FD *REVERT // Stack delta = +0 // Outputs[1] { @1698 revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_1699: // Incoming jump from 0x1642, if stack[-1] // Inputs[2] // { // @16A3 stack[-1] // @16AD stack[-2] // } 1699 5B JUMPDEST 169A 60 PUSH1 0x01 169C 60 PUSH1 0x01 169E 60 PUSH1 0xe0 16A0 1B SHL 16A1 03 SUB 16A2 19 NOT 16A3 16 AND 16A4 63 PUSH4 0x0a85bd01 16A9 60 PUSH1 0xe1 16AB 1B SHL 16AC 14 EQ 16AD 90 SWAP1 16AE 50 POP // Stack delta = -1 // Outputs[1] { @16AD stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block continues label_16AF: // Incoming jump from 0x16AE // Incoming return from call to 0x1F1F at 0x1FBF // Inputs[3] // { // @16B0 stack[-6] // @16B0 stack[-1] // @16B1 stack[-5] // } 16AF 5B JUMPDEST 16B0 94 SWAP5 16B1 93 SWAP4 16B2 50 POP 16B3 50 POP 16B4 50 POP 16B5 50 POP 16B6 56 *JUMP // Stack delta = -5 // Outputs[1] { @16B0 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_16B7: // Incoming jump from 0x102F // Inputs[1] { @16BD stack[-1] } 16B7 5B JUMPDEST 16B8 60 PUSH1 0x60 16BA 61 PUSH2 0x16c2 16BD 82 DUP3 16BE 61 PUSH2 0x118f 16C1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @16B8 stack[0] = 0x60 // @16BA stack[1] = 0x16c2 // @16BD stack[2] = stack[-1] // } // Block ends with call to 0x118f, returns to 0x16C2 label_16C2: // Incoming return from call to 0x118F at 0x16C1 // Inputs[1] { @16C6 stack[-1] } 16C2 5B JUMPDEST 16C3 61 PUSH2 0x16df 16C6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x16df, if stack[-1] label_16C7: // Incoming jump from 0x16C6, if not stack[-1] // Inputs[3] // { // @16C9 memory[0x40:0x60] // @16D9 memory[0x40:0x60] // @16DE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 16C7 60 PUSH1 0x40 16C9 51 MLOAD 16CA 63 PUSH4 0x0a14c4b5 16CF 60 PUSH1 0xe4 16D1 1B SHL 16D2 81 DUP2 16D3 52 MSTORE 16D4 60 PUSH1 0x04 16D6 01 ADD 16D7 60 PUSH1 0x40 16D9 51 MLOAD 16DA 80 DUP1 16DB 91 SWAP2 16DC 03 SUB 16DD 90 SWAP1 16DE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @16D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a14c4b5 << 0xe4 // @16DE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_16DF: // Incoming jump from 0x16C6, if stack[-1] 16DF 5B JUMPDEST 16E0 60 PUSH1 0x00 16E2 61 PUSH2 0x16e9 16E5 61 PUSH2 0x193f 16E8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @16E0 stack[0] = 0x00 // @16E2 stack[1] = 0x16e9 // } // Block ends with unconditional jump to 0x193f 16E9 5B JUMPDEST 16EA 90 SWAP1 16EB 50 POP 16EC 80 DUP1 16ED 51 MLOAD 16EE 60 PUSH1 0x00 16F0 14 EQ 16F1 15 ISZERO 16F2 61 PUSH2 0x170a 16F5 57 *JUMPI 16F6 60 PUSH1 0x40 16F8 51 MLOAD 16F9 80 DUP1 16FA 60 PUSH1 0x20 16FC 01 ADD 16FD 60 PUSH1 0x40 16FF 52 MSTORE 1700 80 DUP1 1701 60 PUSH1 0x00 1703 81 DUP2 1704 52 MSTORE 1705 50 POP 1706 61 PUSH2 0x1735 1709 56 *JUMP 170A 5B JUMPDEST 170B 80 DUP1 170C 61 PUSH2 0x1714 170F 84 DUP5 1710 61 PUSH2 0x194e 1713 56 *JUMP 1714 5B JUMPDEST 1715 60 PUSH1 0x40 1717 51 MLOAD 1718 60 PUSH1 0x20 171A 01 ADD 171B 61 PUSH2 0x1725 171E 92 SWAP3 171F 91 SWAP2 1720 90 SWAP1 1721 61 PUSH2 0x2277 1724 56 *JUMP 1725 5B JUMPDEST 1726 60 PUSH1 0x40 1728 51 MLOAD 1729 60 PUSH1 0x20 172B 81 DUP2 172C 83 DUP4 172D 03 SUB 172E 03 SUB 172F 81 DUP2 1730 52 MSTORE 1731 90 SWAP1 1732 60 PUSH1 0x40 1734 52 MSTORE label_1735: // Incoming return from call to 0x1DB5 at 0x1FDA // Incoming return from call to 0x1D01 at 0x1D30 // Incoming return from call to 0x1CCE at 0x2276 // Incoming return from call to 0x1D5D at 0x1D9B // Incoming return from call to 0x1CCE at 0x1D00 // Inputs[3] // { // @1736 stack[-1] // @1736 stack[-5] // @1737 stack[-4] // } 1735 5B JUMPDEST 1736 93 SWAP4 1737 92 SWAP3 1738 50 POP 1739 50 POP 173A 50 POP 173B 56 *JUMP // Stack delta = -4 // Outputs[1] { @1736 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_173C: // Incoming call from 0x142B, returns to 0x0A58 // Inputs[1] { @1742 stack[-2] } 173C 5B JUMPDEST 173D 60 PUSH1 0x00 173F 61 PUSH2 0x1747 1742 83 DUP4 1743 61 PUSH2 0x1446 1746 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @173D stack[0] = 0x00 // @173F stack[1] = 0x1747 // @1742 stack[2] = stack[-2] // } // Block ends with call to 0x1446, returns to 0x1747 label_1747: // Incoming return from call to 0x1446 at 0x1746 // Inputs[4] // { // @1748 stack[-1] // @1749 memory[stack[-1]:stack[-1] + 0x20] // @174B stack[-2] // @174D stack[-3] // } 1747 5B JUMPDEST 1748 80 DUP1 1749 51 MLOAD 174A 90 SWAP1 174B 91 SWAP2 174C 50 POP 174D 82 DUP3 174E 15 ISZERO 174F 61 PUSH2 0x17ad 1752 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @174A stack[-1] = memory[stack[-1]:stack[-1] + 0x20] // @174B stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x17ad, if !stack[-3] label_1753: // Incoming jump from 0x1752, if not !stack[-3] // Inputs[2] // { // @1755 msg.sender // @175E stack[-1] // } 1753 60 PUSH1 0x00 1755 33 CALLER 1756 60 PUSH1 0x01 1758 60 PUSH1 0x01 175A 60 PUSH1 0xa0 175C 1B SHL 175D 03 SUB 175E 83 DUP4 175F 16 AND 1760 14 EQ 1761 80 DUP1 1762 61 PUSH2 0x1770 1765 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1753 stack[0] = 0x00 // @1760 stack[1] = stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // } // Block ends with conditional jump to 0x1770, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_1766: // Incoming jump from 0x1765, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @176A stack[-3] // @176B msg.sender // } 1766 50 POP 1767 61 PUSH2 0x1770 176A 82 DUP3 176B 33 CALLER 176C 61 PUSH2 0x06c0 176F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1767 stack[-1] = 0x1770 // @176A stack[0] = stack[-3] // @176B stack[1] = msg.sender // } // Block ends with call to 0x06c0, returns to 0x1770 label_1770: // Incoming jump from 0x1765, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming return from call to 0x06C0 at 0x176F // Inputs[1] { @1771 stack[-1] } 1770 5B JUMPDEST 1771 80 DUP1 1772 61 PUSH2 0x178b 1775 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x178b, if stack[-1] label_1776: // Incoming jump from 0x1775, if not stack[-1] // Inputs[2] // { // @1777 msg.sender // @177B stack[-6] // } 1776 50 POP 1777 33 CALLER 1778 61 PUSH2 0x1780 177B 86 DUP7 177C 61 PUSH2 0x0868 177F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1777 stack[-1] = msg.sender // @1778 stack[0] = 0x1780 // @177B stack[1] = stack[-6] // } // Block ends with call to 0x0868, returns to 0x1780 label_1780: // Incoming return from call to 0x0868 at 0x177F // Inputs[2] // { // @1789 stack[-1] // @178A stack[-2] // } 1780 5B JUMPDEST 1781 60 PUSH1 0x01 1783 60 PUSH1 0x01 1785 60 PUSH1 0xa0 1787 1B SHL 1788 03 SUB 1789 16 AND 178A 14 EQ // Stack delta = -1 // Outputs[1] { @178A stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_178B: // Incoming jump from 0x1775, if stack[-1] // Incoming jump from 0x178A // Inputs[2] // { // @178C stack[-1] // @178C stack[-2] // } 178B 5B JUMPDEST 178C 90 SWAP1 178D 50 POP 178E 80 DUP1 178F 61 PUSH2 0x17ab 1792 57 *JUMPI // Stack delta = -1 // Outputs[1] { @178C stack[-2] = stack[-1] } // Block ends with conditional jump to 0x17ab, if stack[-1] label_1793: // Incoming jump from 0x1792, if not stack[-1] // Inputs[3] // { // @1795 memory[0x40:0x60] // @17A5 memory[0x40:0x60] // @17AA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1793 60 PUSH1 0x40 1795 51 MLOAD 1796 63 PUSH4 0x2ce44b5f 179B 60 PUSH1 0xe1 179D 1B SHL 179E 81 DUP2 179F 52 MSTORE 17A0 60 PUSH1 0x04 17A2 01 ADD 17A3 60 PUSH1 0x40 17A5 51 MLOAD 17A6 80 DUP1 17A7 91 SWAP2 17A8 03 SUB 17A9 90 SWAP1 17AA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @179F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @17AA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_17AB: // Incoming jump from 0x1792, if stack[-1] 17AB 5B JUMPDEST 17AC 50 POP // Stack delta = -1 // Block continues label_17AD: // Incoming jump from 0x1752, if !stack[-3] // Incoming jump from 0x17AC // Inputs[2] // { // @17B3 stack[-4] // @17B4 stack[-1] // } 17AD 5B JUMPDEST 17AE 61 PUSH2 0x17b9 17B1 60 PUSH1 0x00 17B3 85 DUP6 17B4 83 DUP4 17B5 61 PUSH2 0x11c8 17B8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @17AE stack[0] = 0x17b9 // @17B1 stack[1] = 0x00 // @17B3 stack[2] = stack[-4] // @17B4 stack[3] = stack[-1] // } // Block ends with call to 0x11c8, returns to 0x17B9 label_17B9: // Incoming return from call to 0x11C8 at 0x17B8 // Inputs[9] // { // @17C3 stack[-1] // @17D5 memory[0x00:0x40] // @17D7 storage[keccak256(memory[0x00:0x40])] // @1847 stack[-4] // @1851 memory[0x00:0x40] // @1853 storage[keccak256(memory[0x00:0x40])] // @1875 block.timestamp // @18A2 memory[0x00:0x40] // @18A4 storage[keccak256(memory[0x00:0x40])] // } 17B9 5B JUMPDEST 17BA 60 PUSH1 0x01 17BC 60 PUSH1 0x01 17BE 60 PUSH1 0xa0 17C0 1B SHL 17C1 03 SUB 17C2 80 DUP1 17C3 82 DUP3 17C4 16 AND 17C5 60 PUSH1 0x00 17C7 81 DUP2 17C8 81 DUP2 17C9 52 MSTORE 17CA 60 PUSH1 0x05 17CC 60 PUSH1 0x20 17CE 90 SWAP1 17CF 81 DUP2 17D0 52 MSTORE 17D1 60 PUSH1 0x40 17D3 80 DUP1 17D4 83 DUP4 17D5 20 SHA3 17D6 80 DUP1 17D7 54 SLOAD 17D8 70 PUSH17 0x0100000000000000000000000000000000 17EA 60 PUSH1 0x00 17EC 19 NOT 17ED 67 PUSH8 0xffffffffffffffff 17F6 80 DUP1 17F7 84 DUP5 17F8 16 AND 17F9 91 SWAP2 17FA 90 SWAP1 17FB 91 SWAP2 17FC 01 ADD 17FD 81 DUP2 17FE 16 AND 17FF 67 PUSH8 0xffffffffffffffff 1808 19 NOT 1809 84 DUP5 180A 16 AND 180B 81 DUP2 180C 17 OR 180D 83 DUP4 180E 90 SWAP1 180F 04 DIV 1810 82 DUP3 1811 16 AND 1812 60 PUSH1 0x01 1814 90 SWAP1 1815 81 DUP2 1816 01 ADD 1817 83 DUP4 1818 16 AND 1819 90 SWAP1 181A 93 SWAP4 181B 02 MUL 181C 7F PUSH32 0xffffffffffffffff0000000000000000ffffffffffffffff0000000000000000 183D 90 SWAP1 183E 94 SWAP5 183F 16 AND 1840 17 OR 1841 92 SWAP3 1842 90 SWAP1 1843 92 SWAP3 1844 17 OR 1845 83 DUP4 1846 55 SSTORE 1847 8B DUP12 1848 86 DUP7 1849 52 MSTORE 184A 60 PUSH1 0x04 184C 90 SWAP1 184D 94 SWAP5 184E 52 MSTORE 184F 82 DUP3 1850 85 DUP6 1851 20 SHA3 1852 80 DUP1 1853 54 SLOAD 1854 7F PUSH32 0xffffff00ffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1875 42 TIMESTAMP 1876 90 SWAP1 1877 93 SWAP4 1878 16 AND 1879 60 PUSH1 0x01 187B 60 PUSH1 0xa0 187D 1B SHL 187E 02 MUL 187F 60 PUSH1 0x01 1881 60 PUSH1 0x01 1883 60 PUSH1 0xe0 1885 1B SHL 1886 03 SUB 1887 19 NOT 1888 90 SWAP1 1889 91 SWAP2 188A 16 AND 188B 90 SWAP1 188C 97 SWAP8 188D 17 OR 188E 96 SWAP7 188F 90 SWAP1 1890 96 SWAP7 1891 17 OR 1892 16 AND 1893 60 PUSH1 0x01 1895 60 PUSH1 0xe0 1897 1B SHL 1898 17 OR 1899 85 DUP6 189A 55 SSTORE 189B 91 SWAP2 189C 89 DUP10 189D 01 ADD 189E 80 DUP1 189F 84 DUP5 18A0 52 MSTORE 18A1 92 SWAP3 18A2 20 SHA3 18A3 80 DUP1 18A4 54 SLOAD 18A5 91 SWAP2 18A6 94 SWAP5 18A7 90 SWAP1 18A8 91 SWAP2 18A9 16 AND 18AA 61 PUSH2 0x18e8 18AD 57 *JUMPI // Stack delta = +4 // Outputs[11] // { // @17C9 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @17D0 memory[0x20:0x40] = 0x05 // @1846 storage[keccak256(memory[0x00:0x40])] = (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff0000000000000000ffffffffffffffff0000000000000000) | (0xffffffffffffffff & (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff) + ~0x00) | 0x0100000000000000000000000000000000 * (0xffffffffffffffff & 0x01 + (0xffffffffffffffff & ((0xffffffffffffffff & (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff) + ~0x00) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff)) / 0x0100000000000000000000000000000000)) // @1849 memory[0x00:0x20] = stack[-4] // @184E memory[0x20:0x40] = 0x04 // @1890 stack[1] = keccak256(memory[0x00:0x40]) // @189A storage[keccak256(memory[0x00:0x40])] = (0x01 << 0xe0) | (((stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * (0xffffffffffffffff & block.timestamp)) & 0xffffff00ffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // @18A0 memory[0x00:0x20] = stack[-4] + 0x01 // @18A1 stack[2] = stack[-4] + 0x01 // @18A6 stack[0] = keccak256(memory[0x00:0x40]) // @18A8 stack[3] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x18e8, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_18AE: // Incoming jump from 0x18AD, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @18B0 storage[0x00] // @18B1 stack[-2] // } 18AE 60 PUSH1 0x00 18B0 54 SLOAD 18B1 82 DUP3 18B2 14 EQ 18B3 61 PUSH2 0x18e8 18B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x18e8, if stack[-2] == storage[0x00] label_18B7: // Incoming jump from 0x18B6, if not stack[-2] == storage[0x00] // Inputs[5] // { // @18B7 stack[-1] // @18B8 storage[stack[-1]] // @18BB stack[-6] // @18BD memory[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @18E2 stack[-5] // } 18B7 80 DUP1 18B8 54 SLOAD 18B9 60 PUSH1 0x20 18BB 87 DUP8 18BC 01 ADD 18BD 51 MLOAD 18BE 67 PUSH8 0xffffffffffffffff 18C7 16 AND 18C8 60 PUSH1 0x01 18CA 60 PUSH1 0xa0 18CC 1B SHL 18CD 02 MUL 18CE 60 PUSH1 0x01 18D0 60 PUSH1 0x01 18D2 60 PUSH1 0xe0 18D4 1B SHL 18D5 03 SUB 18D6 19 NOT 18D7 90 SWAP1 18D8 91 SWAP2 18D9 16 AND 18DA 60 PUSH1 0x01 18DC 60 PUSH1 0x01 18DE 60 PUSH1 0xa0 18E0 1B SHL 18E1 03 SUB 18E2 87 DUP8 18E3 16 AND 18E4 17 OR 18E5 17 OR 18E6 81 DUP2 18E7 55 SSTORE // Stack delta = +0 // Outputs[1] { @18E7 storage[stack[-1]] = (stack[-5] & (0x01 << 0xa0) - 0x01) | (storage[stack[-1]] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * (0xffffffffffffffff & memory[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20]) } // Block continues label_18E8: // Incoming jump from 0x18AD, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x18B6, if stack[-2] == storage[0x00] // Incoming jump from 0x18E7 // Inputs[8] // { // @18ED memory[0x40:0x60] // @18EE stack[-8] // @18EF stack[-4] // @18F3 stack[-3] // @18FD stack[-5] // @1924 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @192A storage[0x01] // @1931 stack[-9] // } 18E8 5B JUMPDEST 18E9 50 POP 18EA 50 POP 18EB 60 PUSH1 0x40 18ED 51 MLOAD 18EE 86 DUP7 18EF 92 SWAP3 18F0 50 POP 18F1 60 PUSH1 0x00 18F3 91 SWAP2 18F4 50 POP 18F5 60 PUSH1 0x01 18F7 60 PUSH1 0x01 18F9 60 PUSH1 0xa0 18FB 1B SHL 18FC 03 SUB 18FD 84 DUP5 18FE 16 AND 18FF 90 SWAP1 1900 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1921 90 SWAP1 1922 83 DUP4 1923 90 SWAP1 1924 A4 LOG4 1925 50 POP 1926 50 POP 1927 60 PUSH1 0x01 1929 80 DUP1 192A 54 SLOAD 192B 81 DUP2 192C 01 ADD 192D 90 SWAP1 192E 55 SSTORE 192F 50 POP 1930 50 POP 1931 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @1924 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-5] & (0x01 << 0xa0) - 0x01, 0x00, stack[-8]]); // @192E storage[0x01] = 0x01 + storage[0x01] // } // Block ends with unconditional jump to stack[-9] label_1932: // Incoming call from 0x1445, returns to 0x0BEF // Inputs[3] // { // @1936 stack[-3] // @1937 stack[-2] // @1938 stack[-1] // } 1932 5B JUMPDEST 1933 61 PUSH2 0x0935 1936 83 DUP4 1937 83 DUP4 1938 83 DUP4 1939 60 PUSH1 0x01 193B 61 PUSH2 0x1a64 193E 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1933 stack[0] = 0x0935 // @1936 stack[1] = stack[-3] // @1937 stack[2] = stack[-2] // @1938 stack[3] = stack[-1] // @1939 stack[4] = 0x01 // } // Block ends with call to 0x1a64, returns to 0x0935 label_193F: // Incoming jump from 0x16E8 // Inputs[1] { @1945 storage[0x0e] } 193F 5B JUMPDEST 1940 60 PUSH1 0x60 1942 60 PUSH1 0x0e 1944 80 DUP1 1945 54 SLOAD 1946 61 PUSH2 0x07e5 1949 90 SWAP1 194A 61 PUSH2 0x20b4 194D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1940 stack[0] = 0x60 // @1942 stack[1] = 0x0e // @1949 stack[2] = 0x07e5 // @1949 stack[3] = storage[0x0e] // } // Block ends with call to 0x20b4, returns to 0x07E5 194E 5B JUMPDEST 194F 60 PUSH1 0x60 1951 81 DUP2 1952 61 PUSH2 0x1972 1955 57 *JUMPI 1956 50 POP 1957 50 POP 1958 60 PUSH1 0x40 195A 80 DUP1 195B 51 MLOAD 195C 80 DUP1 195D 82 DUP3 195E 01 ADD 195F 90 SWAP1 1960 91 SWAP2 1961 52 MSTORE 1962 60 PUSH1 0x01 1964 81 DUP2 1965 52 MSTORE 1966 60 PUSH1 0x03 1968 60 PUSH1 0xfc 196A 1B SHL 196B 60 PUSH1 0x20 196D 82 DUP3 196E 01 ADD 196F 52 MSTORE 1970 90 SWAP1 1971 56 *JUMP 1972 5B JUMPDEST 1973 81 DUP2 1974 60 PUSH1 0x00 1976 5B JUMPDEST 1977 81 DUP2 1978 15 ISZERO 1979 61 PUSH2 0x199c 197C 57 *JUMPI 197D 80 DUP1 197E 61 PUSH2 0x1986 1981 81 DUP2 1982 61 PUSH2 0x2152 1985 56 *JUMP 1986 5B JUMPDEST 1987 91 SWAP2 1988 50 POP 1989 61 PUSH2 0x1995 198C 90 SWAP1 198D 50 POP 198E 60 PUSH1 0x0a 1990 83 DUP4 1991 61 PUSH2 0x22bc 1994 56 *JUMP 1995 5B JUMPDEST 1996 91 SWAP2 1997 50 POP 1998 61 PUSH2 0x1976 199B 56 *JUMP 199C 5B JUMPDEST 199D 60 PUSH1 0x00 199F 81 DUP2 19A0 67 PUSH8 0xffffffffffffffff 19A9 81 DUP2 19AA 11 GT 19AB 15 ISZERO 19AC 61 PUSH2 0x19b7 19AF 57 *JUMPI 19B0 61 PUSH2 0x19b7 19B3 61 PUSH2 0x1e32 19B6 56 *JUMP 19B7 5B JUMPDEST 19B8 60 PUSH1 0x40 19BA 51 MLOAD 19BB 90 SWAP1 19BC 80 DUP1 19BD 82 DUP3 19BE 52 MSTORE 19BF 80 DUP1 19C0 60 PUSH1 0x1f 19C2 01 ADD 19C3 60 PUSH1 0x1f 19C5 19 NOT 19C6 16 AND 19C7 60 PUSH1 0x20 19C9 01 ADD 19CA 82 DUP3 19CB 01 ADD 19CC 60 PUSH1 0x40 19CE 52 MSTORE 19CF 80 DUP1 19D0 15 ISZERO 19D1 61 PUSH2 0x19e1 19D4 57 *JUMPI 19D5 60 PUSH1 0x20 19D7 82 DUP3 19D8 01 ADD 19D9 81 DUP2 19DA 80 DUP1 19DB 36 CALLDATASIZE 19DC 83 DUP4 19DD 37 CALLDATACOPY 19DE 01 ADD 19DF 90 SWAP1 19E0 50 POP 19E1 5B JUMPDEST 19E2 50 POP 19E3 90 SWAP1 19E4 50 POP 19E5 5B JUMPDEST 19E6 84 DUP5 19E7 15 ISZERO 19E8 61 PUSH2 0x16af 19EB 57 *JUMPI 19EC 61 PUSH2 0x19f6 19EF 60 PUSH1 0x01 19F1 83 DUP4 19F2 61 PUSH2 0x22d0 19F5 56 *JUMP 19F6 5B JUMPDEST 19F7 91 SWAP2 19F8 50 POP 19F9 61 PUSH2 0x1a03 19FC 60 PUSH1 0x0a 19FE 86 DUP7 19FF 61 PUSH2 0x22e7 1A02 56 *JUMP 1A03 5B JUMPDEST 1A04 61 PUSH2 0x1a0e 1A07 90 SWAP1 1A08 60 PUSH1 0x30 1A0A 61 PUSH2 0x2105 1A0D 56 *JUMP 1A0E 5B JUMPDEST 1A0F 60 PUSH1 0xf8 1A11 1B SHL 1A12 81 DUP2 1A13 83 DUP4 1A14 81 DUP2 1A15 51 MLOAD 1A16 81 DUP2 1A17 10 LT 1A18 61 PUSH2 0x1a23 1A1B 57 *JUMPI 1A1C 61 PUSH2 0x1a23 1A1F 61 PUSH2 0x213c 1A22 56 *JUMP 1A23 5B JUMPDEST 1A24 60 PUSH1 0x20 1A26 01 ADD 1A27 01 ADD 1A28 90 SWAP1 1A29 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1A49 19 NOT 1A4A 16 AND 1A4B 90 SWAP1 1A4C 81 DUP2 1A4D 60 PUSH1 0x00 1A4F 1A BYTE 1A50 90 SWAP1 1A51 53 MSTORE8 1A52 50 POP 1A53 61 PUSH2 0x1a5d 1A56 60 PUSH1 0x0a 1A58 86 DUP7 1A59 61 PUSH2 0x22bc 1A5C 56 *JUMP 1A5D 5B JUMPDEST 1A5E 94 SWAP5 1A5F 50 POP 1A60 61 PUSH2 0x19e5 1A63 56 *JUMP label_1A64: // Incoming call from 0x193E, returns to 0x0935 // Inputs[2] // { // @1A67 storage[0x00] // @1A70 stack[-4] // } 1A64 5B JUMPDEST 1A65 60 PUSH1 0x00 1A67 54 SLOAD 1A68 60 PUSH1 0x01 1A6A 60 PUSH1 0x01 1A6C 60 PUSH1 0xa0 1A6E 1B SHL 1A6F 03 SUB 1A70 85 DUP6 1A71 16 AND 1A72 61 PUSH2 0x1a8d 1A75 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A67 stack[0] = storage[0x00] } // Block ends with conditional jump to 0x1a8d, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1A76: // Incoming jump from 0x1A75, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1A78 memory[0x40:0x60] // @1A87 memory[0x40:0x60] // @1A8C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1A76 60 PUSH1 0x40 1A78 51 MLOAD 1A79 62 PUSH3 0x2e0763 1A7D 60 PUSH1 0xe8 1A7F 1B SHL 1A80 81 DUP2 1A81 52 MSTORE 1A82 60 PUSH1 0x04 1A84 01 ADD 1A85 60 PUSH1 0x40 1A87 51 MLOAD 1A88 80 DUP1 1A89 91 SWAP2 1A8A 03 SUB 1A8B 90 SWAP1 1A8C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1A81 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e0763 << 0xe8 // @1A8C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1A8D: // Incoming jump from 0x1A75, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1A8E stack[-4] } 1A8D 5B JUMPDEST 1A8E 83 DUP4 1A8F 61 PUSH2 0x1aab 1A92 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1aab, if stack[-4] label_1A93: // Incoming jump from 0x1A92, if not stack[-4] // Inputs[3] // { // @1A95 memory[0x40:0x60] // @1AA5 memory[0x40:0x60] // @1AAA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1A93 60 PUSH1 0x40 1A95 51 MLOAD 1A96 63 PUSH4 0xb562e8dd 1A9B 60 PUSH1 0xe0 1A9D 1B SHL 1A9E 81 DUP2 1A9F 52 MSTORE 1AA0 60 PUSH1 0x04 1AA2 01 ADD 1AA3 60 PUSH1 0x40 1AA5 51 MLOAD 1AA6 80 DUP1 1AA7 91 SWAP2 1AA8 03 SUB 1AA9 90 SWAP1 1AAA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1A9F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd << 0xe0 // @1AAA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1AAB: // Incoming jump from 0x1A92, if stack[-4] // Inputs[9] // { // @1AB4 stack[-5] // @1AC6 memory[0x00:0x40] // @1AC8 storage[keccak256(memory[0x00:0x40])] // @1AE9 stack[-4] // @1B1A stack[-1] // @1B24 memory[0x00:0x40] // @1B26 storage[keccak256(memory[0x00:0x40])] // @1B39 block.timestamp // @1B48 stack[-2] // } 1AAB 5B JUMPDEST 1AAC 60 PUSH1 0x01 1AAE 60 PUSH1 0x01 1AB0 60 PUSH1 0xa0 1AB2 1B SHL 1AB3 03 SUB 1AB4 85 DUP6 1AB5 16 AND 1AB6 60 PUSH1 0x00 1AB8 81 DUP2 1AB9 81 DUP2 1ABA 52 MSTORE 1ABB 60 PUSH1 0x05 1ABD 60 PUSH1 0x20 1ABF 90 SWAP1 1AC0 81 DUP2 1AC1 52 MSTORE 1AC2 60 PUSH1 0x40 1AC4 80 DUP1 1AC5 83 DUP4 1AC6 20 SHA3 1AC7 80 DUP1 1AC8 54 SLOAD 1AC9 6F PUSH16 0xffffffffffffffffffffffffffffffff 1ADA 19 NOT 1ADB 81 DUP2 1ADC 16 AND 1ADD 67 PUSH8 0xffffffffffffffff 1AE6 80 DUP1 1AE7 83 DUP4 1AE8 16 AND 1AE9 8C DUP13 1AEA 01 ADD 1AEB 81 DUP2 1AEC 16 AND 1AED 91 SWAP2 1AEE 82 DUP3 1AEF 17 OR 1AF0 68 PUSH9 0x010000000000000000 1AFA 67 PUSH8 0xffffffffffffffff 1B03 19 NOT 1B04 90 SWAP1 1B05 94 SWAP5 1B06 16 AND 1B07 90 SWAP1 1B08 92 SWAP3 1B09 17 OR 1B0A 83 DUP4 1B0B 90 SWAP1 1B0C 04 DIV 1B0D 81 DUP2 1B0E 16 AND 1B0F 8C DUP13 1B10 01 ADD 1B11 81 DUP2 1B12 16 AND 1B13 90 SWAP1 1B14 92 SWAP3 1B15 02 MUL 1B16 17 OR 1B17 90 SWAP1 1B18 91 SWAP2 1B19 55 SSTORE 1B1A 85 DUP6 1B1B 84 DUP5 1B1C 52 MSTORE 1B1D 60 PUSH1 0x04 1B1F 90 SWAP1 1B20 92 SWAP3 1B21 52 MSTORE 1B22 90 SWAP1 1B23 91 SWAP2 1B24 20 SHA3 1B25 80 DUP1 1B26 54 SLOAD 1B27 60 PUSH1 0x01 1B29 60 PUSH1 0x01 1B2B 60 PUSH1 0xe0 1B2D 1B SHL 1B2E 03 SUB 1B2F 19 NOT 1B30 16 AND 1B31 90 SWAP1 1B32 92 SWAP3 1B33 17 OR 1B34 60 PUSH1 0x01 1B36 60 PUSH1 0xa0 1B38 1B SHL 1B39 42 TIMESTAMP 1B3A 90 SWAP1 1B3B 92 SWAP3 1B3C 16 AND 1B3D 91 SWAP2 1B3E 90 SWAP1 1B3F 91 SWAP2 1B40 02 MUL 1B41 17 OR 1B42 90 SWAP1 1B43 55 SSTORE 1B44 80 DUP1 1B45 80 DUP1 1B46 85 DUP6 1B47 01 ADD 1B48 83 DUP4 1B49 80 DUP1 1B4A 15 ISZERO 1B4B 61 PUSH2 0x1b5d 1B4E 57 *JUMPI // Stack delta = +3 // Outputs[9] // { // @1ABA memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1AC1 memory[0x20:0x40] = 0x05 // @1B19 storage[keccak256(memory[0x00:0x40])] = 0x010000000000000000 * (0xffffffffffffffff & stack[-4] + (0xffffffffffffffff & ((0xffffffffffffffff & stack[-4] + (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff)) / 0x010000000000000000)) | (0xffffffffffffffff & stack[-4] + (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffffffffffffffffffff) // @1B1C memory[0x00:0x20] = stack[-1] // @1B21 memory[0x20:0x40] = 0x04 // @1B43 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1B44 stack[0] = stack[-1] // @1B47 stack[1] = stack[-4] + stack[-1] // @1B48 stack[2] = stack[-2] // } // Block ends with conditional jump to 0x1b5d, if !stack[-2] label_1B4F: // Incoming jump from 0x1B4E, if not !stack[-2] // Inputs[2] // { // @1B58 stack[-8] // @1B5A address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // } 1B4F 50 POP 1B50 60 PUSH1 0x01 1B52 60 PUSH1 0x01 1B54 60 PUSH1 0xa0 1B56 1B SHL 1B57 03 SUB 1B58 87 DUP8 1B59 16 AND 1B5A 3B EXTCODESIZE 1B5B 15 ISZERO 1B5C 15 ISZERO 1B5D 5B JUMPDEST 1B5E 15 ISZERO 1B5F 61 PUSH2 0x1be6 1B62 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1be6, if !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length label_1B63: // Incoming jump from 0x1B62, if not !stack[-1] // Incoming jump from 0x1B62, if not !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Inputs[5] // { // @1B66 memory[0x40:0x60] // @1B67 stack[-2] // @1B71 stack[-7] // @1B9B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1BA9 stack[-5] // } 1B63 5B JUMPDEST 1B64 60 PUSH1 0x40 1B66 51 MLOAD 1B67 82 DUP3 1B68 90 SWAP1 1B69 60 PUSH1 0x01 1B6B 60 PUSH1 0x01 1B6D 60 PUSH1 0xa0 1B6F 1B SHL 1B70 03 SUB 1B71 89 DUP10 1B72 16 AND 1B73 90 SWAP1 1B74 60 PUSH1 0x00 1B76 90 SWAP1 1B77 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1B98 90 SWAP1 1B99 82 DUP3 1B9A 90 SWAP1 1B9B A4 LOG4 1B9C 61 PUSH2 0x1bae 1B9F 60 PUSH1 0x00 1BA1 88 DUP9 1BA2 84 DUP5 1BA3 80 DUP1 1BA4 60 PUSH1 0x01 1BA6 01 ADD 1BA7 95 SWAP6 1BA8 50 POP 1BA9 88 DUP9 1BAA 61 PUSH2 0x15ce 1BAD 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1B9B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // @1B9C stack[0] = 0x1bae // @1B9F stack[1] = 0x00 // @1BA1 stack[2] = stack[-7] // @1BA2 stack[3] = stack[-2] // @1BA7 stack[-2] = 0x01 + stack[-2] // @1BA9 stack[4] = stack[-5] // } // Block ends with unconditional jump to 0x15ce 1BAE 5B JUMPDEST 1BAF 61 PUSH2 0x1bcb 1BB2 57 *JUMPI 1BB3 60 PUSH1 0x40 1BB5 51 MLOAD 1BB6 63 PUSH4 0x68d2bf6b 1BBB 60 PUSH1 0xe1 1BBD 1B SHL 1BBE 81 DUP2 1BBF 52 MSTORE 1BC0 60 PUSH1 0x04 1BC2 01 ADD 1BC3 60 PUSH1 0x40 1BC5 51 MLOAD 1BC6 80 DUP1 1BC7 91 SWAP2 1BC8 03 SUB 1BC9 90 SWAP1 1BCA FD *REVERT 1BCB 5B JUMPDEST 1BCC 80 DUP1 1BCD 82 DUP3 1BCE 14 EQ 1BCF 15 ISZERO 1BD0 61 PUSH2 0x1b63 1BD3 57 *JUMPI 1BD4 82 DUP3 1BD5 60 PUSH1 0x00 1BD7 54 SLOAD 1BD8 14 EQ 1BD9 61 PUSH2 0x1be1 1BDC 57 *JUMPI 1BDD 60 PUSH1 0x00 1BDF 80 DUP1 1BE0 FD *REVERT 1BE1 5B JUMPDEST 1BE2 61 PUSH2 0x1c2c 1BE5 56 *JUMP label_1BE6: // Incoming jump from 0x1B62, if !stack[-1] // Incoming jump from 0x1B62, if !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Inputs[5] // { // @1BEA memory[0x40:0x60] // @1BED stack[-2] // @1BF9 stack[-7] // @1C23 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1C24 stack[-1] // } 1BE6 5B JUMPDEST 1BE7 5B JUMPDEST 1BE8 60 PUSH1 0x40 1BEA 51 MLOAD 1BEB 60 PUSH1 0x01 1BED 83 DUP4 1BEE 01 ADD 1BEF 92 SWAP3 1BF0 90 SWAP1 1BF1 60 PUSH1 0x01 1BF3 60 PUSH1 0x01 1BF5 60 PUSH1 0xa0 1BF7 1B SHL 1BF8 03 SUB 1BF9 89 DUP10 1BFA 16 AND 1BFB 90 SWAP1 1BFC 60 PUSH1 0x00 1BFE 90 SWAP1 1BFF 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1C20 90 SWAP1 1C21 82 DUP3 1C22 90 SWAP1 1C23 A4 LOG4 1C24 80 DUP1 1C25 82 DUP3 1C26 14 EQ 1C27 15 ISZERO 1C28 61 PUSH2 0x1be7 1C2B 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1BEF stack[-2] = stack[-2] + 0x01 // @1C23 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with conditional jump to 0x1be7, if !(stack[-2] + 0x01 == stack[-1]) label_1C2C: // Incoming jump from 0x1C2B, if not !(stack[-2] + 0x01 == stack[-1]) // Incoming jump from 0x1C2B, if not !(stack[-2] + 0x01 == stack[-1]) // Inputs[1] { @1C30 stack[-2] } 1C2C 5B JUMPDEST 1C2D 50 POP 1C2E 60 PUSH1 0x00 1C30 55 SSTORE 1C31 61 PUSH2 0x141a 1C34 56 *JUMP // Stack delta = -2 // Outputs[1] { @1C30 storage[0x00] = stack[-2] } // Block ends with unconditional jump to 0x141a label_1C35: // Incoming jump from 0x0E2A // Incoming jump from 0x0BEE // Inputs[2] // { // @1C36 stack[-3] // @1C38 storage[stack[-3]] // } 1C35 5B JUMPDEST 1C36 82 DUP3 1C37 80 DUP1 1C38 54 SLOAD 1C39 61 PUSH2 0x1c41 1C3C 90 SWAP1 1C3D 61 PUSH2 0x20b4 1C40 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C36 stack[0] = stack[-3] // @1C3C stack[1] = 0x1c41 // @1C3C stack[2] = storage[stack[-3]] // } // Block ends with call to 0x20b4, returns to 0x1C41 label_1C41: // Incoming return from call to 0x20B4 at 0x1C40 // Inputs[5] // { // @1C42 stack[-1] // @1C42 stack[-2] // @1C4A memory[0x00:0x20] // @1C55 stack[-4] // @1C56 stack[-3] // } 1C41 5B JUMPDEST 1C42 90 SWAP1 1C43 60 PUSH1 0x00 1C45 52 MSTORE 1C46 60 PUSH1 0x20 1C48 60 PUSH1 0x00 1C4A 20 SHA3 1C4B 90 SWAP1 1C4C 60 PUSH1 0x1f 1C4E 01 ADD 1C4F 60 PUSH1 0x20 1C51 90 SWAP1 1C52 04 DIV 1C53 81 DUP2 1C54 01 ADD 1C55 92 SWAP3 1C56 82 DUP3 1C57 61 PUSH2 0x1c63 1C5A 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1C45 memory[0x00:0x20] = stack[-2] // @1C4B stack[-2] = keccak256(memory[0x00:0x20]) // @1C55 stack[-1] = stack[-4] // @1C55 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x1c63, if stack[-3] label_1C5B: // Incoming jump from 0x1C5A, if not stack[-3] // Inputs[1] { @1C5D stack[-5] } 1C5B 60 PUSH1 0x00 1C5D 85 DUP6 1C5E 55 SSTORE 1C5F 61 PUSH2 0x1ca9 1C62 56 *JUMP // Stack delta = +0 // Outputs[1] { @1C5E storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x1ca9 label_1C63: // Incoming jump from 0x1C5A, if stack[-3] // Inputs[1] { @1C64 stack[-3] } 1C63 5B JUMPDEST 1C64 82 DUP3 1C65 60 PUSH1 0x1f 1C67 10 LT 1C68 61 PUSH2 0x1c7c 1C6B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c7c, if 0x1f < stack[-3] label_1C6C: // Incoming jump from 0x1C6B, if not 0x1f < stack[-3] // Inputs[4] // { // @1C6C stack[-1] // @1C6D memory[stack[-1]:stack[-1] + 0x20] // @1C72 stack[-3] // @1C76 stack[-5] // } 1C6C 80 DUP1 1C6D 51 MLOAD 1C6E 60 PUSH1 0xff 1C70 19 NOT 1C71 16 AND 1C72 83 DUP4 1C73 80 DUP1 1C74 01 ADD 1C75 17 OR 1C76 85 DUP6 1C77 55 SSTORE 1C78 61 PUSH2 0x1ca9 1C7B 56 *JUMP // Stack delta = +0 // Outputs[1] { @1C77 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x1ca9 label_1C7C: // Incoming jump from 0x1C6B, if 0x1f < stack[-3] // Inputs[2] // { // @1C7D stack[-3] // @1C83 stack[-5] // } 1C7C 5B JUMPDEST 1C7D 82 DUP3 1C7E 80 DUP1 1C7F 01 ADD 1C80 60 PUSH1 0x01 1C82 01 ADD 1C83 85 DUP6 1C84 55 SSTORE 1C85 82 DUP3 1C86 15 ISZERO 1C87 61 PUSH2 0x1ca9 1C8A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1C84 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1ca9, if !stack[-3] label_1C8B: // Incoming jump from 0x1C8A, if not !stack[-3] // Inputs[2] // { // @1C8B stack[-3] // @1C8B stack[-1] // } 1C8B 91 SWAP2 1C8C 82 DUP3 1C8D 01 ADD 1C8E 5B JUMPDEST 1C8F 82 DUP3 1C90 81 DUP2 1C91 11 GT 1C92 15 ISZERO 1C93 61 PUSH2 0x1ca9 1C96 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1C8B stack[-3] = stack[-1] // @1C8D stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1ca9, if !(stack[-1] + stack[-3] > stack[-1]) label_1C97: // Incoming jump from 0x1C96, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x1C96, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @1C97 stack[-3] // @1C98 memory[stack[-3]:stack[-3] + 0x20] // @1C99 stack[-2] // @1C9B stack[-1] // } 1C97 82 DUP3 1C98 51 MLOAD 1C99 82 DUP3 1C9A 55 SSTORE 1C9B 91 SWAP2 1C9C 60 PUSH1 0x20 1C9E 01 ADD 1C9F 91 SWAP2 1CA0 90 SWAP1 1CA1 60 PUSH1 0x01 1CA3 01 ADD 1CA4 90 SWAP1 1CA5 61 PUSH2 0x1c8e 1CA8 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1C9A storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1C9F stack[-3] = 0x20 + stack[-3] // @1CA4 stack[-2] = 0x01 + stack[-2] // @1CA4 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1c8e label_1CA9: // Incoming jump from 0x1C62 // Incoming jump from 0x1C96, if !(stack[-1] > stack[-3]) // Incoming jump from 0x1C7B // Incoming jump from 0x1C96, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1C8A, if !stack[-3] // Inputs[2] // { // @1CAE stack[-4] // @1CAF stack[-3] // } 1CA9 5B JUMPDEST 1CAA 50 POP 1CAB 61 PUSH2 0x1cb5 1CAE 92 SWAP3 1CAF 91 SWAP2 1CB0 50 POP 1CB1 61 PUSH2 0x1cb9 1CB4 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1CAE stack[-4] = 0x1cb5 // @1CAF stack[-3] = stack[-4] // } // Block ends with call to 0x1cb9, returns to 0x1CB5 label_1CB5: // Incoming jump from 0x1CC2, if !(stack[-2] > stack[-1]) // Incoming jump from 0x1CC2, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x1CB9 at 0x1CB4 // Inputs[2] // { // @1CB7 stack[-3] // @1CB7 stack[-2] // } 1CB5 5B JUMPDEST 1CB6 50 POP 1CB7 90 SWAP1 1CB8 56 *JUMP // Stack delta = -2 // Outputs[1] { @1CB7 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1CB9: // Incoming call from 0x1CB4, returns to 0x1CB5 // Inputs[2] // { // @1CBB stack[-1] // @1CBC stack[-2] // } 1CB9 5B JUMPDEST 1CBA 5B JUMPDEST 1CBB 80 DUP1 1CBC 82 DUP3 1CBD 11 GT 1CBE 15 ISZERO 1CBF 61 PUSH2 0x1cb5 1CC2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1cb5, if !(stack[-2] > stack[-1]) label_1CC3: // Incoming jump from 0x1CC2, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1CC2, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1CC5 stack[-1] } 1CC3 60 PUSH1 0x00 1CC5 81 DUP2 1CC6 55 SSTORE 1CC7 60 PUSH1 0x01 1CC9 01 ADD 1CCA 61 PUSH2 0x1cba 1CCD 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1CC6 storage[stack[-1]] = 0x00 // @1CC9 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1cba label_1CCE: // Incoming call from 0x2276, returns to 0x1735 // Incoming call from 0x1D00, returns to 0x1735 // Inputs[1] { @1CD8 stack[-1] } 1CCE 5B JUMPDEST 1CCF 60 PUSH1 0x01 1CD1 60 PUSH1 0x01 1CD3 60 PUSH1 0xe0 1CD5 1B SHL 1CD6 03 SUB 1CD7 19 NOT 1CD8 81 DUP2 1CD9 16 AND 1CDA 81 DUP2 1CDB 14 EQ 1CDC 61 PUSH2 0x0a58 1CDF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a58, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1CE0: // Incoming jump from 0x1CDF, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1CE3 memory[0x00:0x00] } 1CE0 60 PUSH1 0x00 1CE2 80 DUP1 1CE3 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CE3 revert(memory[0x00:0x00]); } // Block terminates label_1CE4: // Incoming call from 0x02A4, returns to 0x02A5 // Inputs[2] // { // @1CE9 stack[-1] // @1CEA stack[-2] // } 1CE4 5B JUMPDEST 1CE5 60 PUSH1 0x00 1CE7 60 PUSH1 0x20 1CE9 82 DUP3 1CEA 84 DUP5 1CEB 03 SUB 1CEC 12 SLT 1CED 15 ISZERO 1CEE 61 PUSH2 0x1cf6 1CF1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CE5 stack[0] = 0x00 } // Block ends with conditional jump to 0x1cf6, if !(stack[-2] - stack[-1] i< 0x20) label_1CF2: // Incoming jump from 0x1CF1, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1CF5 memory[0x00:0x00] } 1CF2 60 PUSH1 0x00 1CF4 80 DUP1 1CF5 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CF5 revert(memory[0x00:0x00]); } // Block terminates label_1CF6: // Incoming jump from 0x1CF1, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1CF7 stack[-2] // @1CF8 msg.data[stack[-2]:stack[-2] + 0x20] // } 1CF6 5B JUMPDEST 1CF7 81 DUP2 1CF8 35 CALLDATALOAD 1CF9 61 PUSH2 0x1735 1CFC 81 DUP2 1CFD 61 PUSH2 0x1cce 1D00 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1CF8 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1CF9 stack[1] = 0x1735 // @1CFC stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1cce, returns to 0x1735 label_1D01: // Incoming call from 0x1D30, returns to 0x1735 // Incoming call from 0x2004, returns to 0x2005 // Inputs[2] // { // @1D02 stack[-1] // @1D03 msg.data[stack[-1]:stack[-1] + 0x20] // } 1D01 5B JUMPDEST 1D02 80 DUP1 1D03 35 CALLDATALOAD 1D04 80 DUP1 1D05 15 ISZERO 1D06 15 ISZERO 1D07 81 DUP2 1D08 14 EQ 1D09 61 PUSH2 0x1d11 1D0C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D03 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1d11, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_1D0D: // Incoming jump from 0x1D0C, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @1D10 memory[0x00:0x00] } 1D0D 60 PUSH1 0x00 1D0F 80 DUP1 1D10 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D10 revert(memory[0x00:0x00]); } // Block terminates label_1D11: // Incoming jump from 0x1D0C, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Incoming jump from 0x1DC7, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1D12 stack[-1] // @1D12 stack[-3] // @1D13 stack[-2] // } 1D11 5B JUMPDEST 1D12 91 SWAP2 1D13 90 SWAP1 1D14 50 POP 1D15 56 *JUMP // Stack delta = -2 // Outputs[1] { @1D12 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1D16: // Incoming call from 0x02D9, returns to 0x02DA // Incoming call from 0x03E4, returns to 0x03E5 // Inputs[2] // { // @1D1B stack[-1] // @1D1C stack[-2] // } 1D16 5B JUMPDEST 1D17 60 PUSH1 0x00 1D19 60 PUSH1 0x20 1D1B 82 DUP3 1D1C 84 DUP5 1D1D 03 SUB 1D1E 12 SLT 1D1F 15 ISZERO 1D20 61 PUSH2 0x1d28 1D23 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D17 stack[0] = 0x00 } // Block ends with conditional jump to 0x1d28, if !(stack[-2] - stack[-1] i< 0x20) label_1D24: // Incoming jump from 0x1D23, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1D27 memory[0x00:0x00] } 1D24 60 PUSH1 0x00 1D26 80 DUP1 1D27 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D27 revert(memory[0x00:0x00]); } // Block terminates label_1D28: // Incoming jump from 0x1D23, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1D2C stack[-2] } 1D28 5B JUMPDEST 1D29 61 PUSH2 0x1735 1D2C 82 DUP3 1D2D 61 PUSH2 0x1d01 1D30 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D29 stack[0] = 0x1735 // @1D2C stack[1] = stack[-2] // } // Block ends with call to 0x1d01, returns to 0x1735 label_1D31: // Incoming call from 0x1D74, returns to 0x1D75 // Inputs[1] { @1D35 stack[-3] } 1D31 5B JUMPDEST 1D32 60 PUSH1 0x00 1D34 5B JUMPDEST 1D35 83 DUP4 1D36 81 DUP2 1D37 10 LT 1D38 15 ISZERO 1D39 61 PUSH2 0x1d4c 1D3C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D32 stack[0] = 0x00 } // Block ends with conditional jump to 0x1d4c, if !(0x00 < stack[-3]) label_1D3D: // Incoming jump from 0x1D3C, if not !(0x00 < stack[-3]) // Incoming jump from 0x1D3C, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @1D3D stack[-2] // @1D3E stack[-1] // @1D40 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1D41 stack[-3] // } 1D3D 81 DUP2 1D3E 81 DUP2 1D3F 01 ADD 1D40 51 MLOAD 1D41 83 DUP4 1D42 82 DUP3 1D43 01 ADD 1D44 52 MSTORE 1D45 60 PUSH1 0x20 1D47 01 ADD 1D48 61 PUSH2 0x1d34 1D4B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1D44 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1D47 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1d34 label_1D4C: // Incoming jump from 0x1D3C, if !(0x00 < stack[-3]) // Incoming jump from 0x1D3C, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @1D4D stack[-4] // @1D4E stack[-1] // } 1D4C 5B JUMPDEST 1D4D 83 DUP4 1D4E 81 DUP2 1D4F 11 GT 1D50 15 ISZERO 1D51 61 PUSH2 0x101f 1D54 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x101f, if !(stack[-1] > stack[-4]) label_1D55: // Incoming jump from 0x1D54, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @1D59 stack[-4] // @1D5A stack[-3] // @1D5C stack[-5] // } 1D55 50 POP 1D56 50 POP 1D57 60 PUSH1 0x00 1D59 91 SWAP2 1D5A 01 ADD 1D5B 52 MSTORE 1D5C 56 *JUMP // Stack delta = -5 // Outputs[1] { @1D5B memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1D5D: // Incoming call from 0x224F, returns to 0x2250 // Incoming call from 0x1D9B, returns to 0x1735 // Inputs[3] // { // @1D60 stack[-1] // @1D61 memory[stack[-1]:stack[-1] + 0x20] // @1D63 stack[-2] // } 1D5D 5B JUMPDEST 1D5E 60 PUSH1 0x00 1D60 81 DUP2 1D61 51 MLOAD 1D62 80 DUP1 1D63 84 DUP5 1D64 52 MSTORE 1D65 61 PUSH2 0x1d75 1D68 81 DUP2 1D69 60 PUSH1 0x20 1D6B 86 DUP7 1D6C 01 ADD 1D6D 60 PUSH1 0x20 1D6F 86 DUP7 1D70 01 ADD 1D71 61 PUSH2 0x1d31 1D74 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1D5E stack[0] = 0x00 // @1D61 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1D64 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1D65 stack[2] = 0x1d75 // @1D68 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1D6C stack[4] = stack[-2] + 0x20 // @1D70 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x1d31, returns to 0x1D75 label_1D75: // Incoming return from call to 0x1D31 at 0x1D74 // Inputs[4] // { // @1D78 stack[-1] // @1D7D stack[-4] // @1D7E stack[-2] // @1D84 stack[-5] // } 1D75 5B JUMPDEST 1D76 60 PUSH1 0x1f 1D78 01 ADD 1D79 60 PUSH1 0x1f 1D7B 19 NOT 1D7C 16 AND 1D7D 92 SWAP3 1D7E 90 SWAP1 1D7F 92 SWAP3 1D80 01 ADD 1D81 60 PUSH1 0x20 1D83 01 ADD 1D84 92 SWAP3 1D85 91 SWAP2 1D86 50 POP 1D87 50 POP 1D88 56 *JUMP // Stack delta = -4 // Outputs[1] { @1D84 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1D89: // Incoming jump from 0x0302 // Inputs[2] // { // @1D8C stack[-1] // @1D97 stack[-2] // } 1D89 5B JUMPDEST 1D8A 60 PUSH1 0x20 1D8C 81 DUP2 1D8D 52 MSTORE 1D8E 60 PUSH1 0x00 1D90 61 PUSH2 0x1735 1D93 60 PUSH1 0x20 1D95 83 DUP4 1D96 01 ADD 1D97 84 DUP5 1D98 61 PUSH2 0x1d5d 1D9B 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1D8D memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1D8E stack[0] = 0x00 // @1D90 stack[1] = 0x1735 // @1D96 stack[2] = stack[-1] + 0x20 // @1D97 stack[3] = stack[-2] // } // Block ends with call to 0x1d5d, returns to 0x1735 label_1D9C: // Incoming call from 0x0542, returns to 0x0543 // Incoming call from 0x069F, returns to 0x06A0 // Incoming call from 0x045E, returns to 0x045F // Incoming call from 0x0654, returns to 0x0655 // Incoming call from 0x04B8, returns to 0x04B9 // Incoming call from 0x031D, returns to 0x031E // Incoming call from 0x04ED, returns to 0x04EE // Incoming call from 0x0582, returns to 0x0583 // Incoming call from 0x05C8, returns to 0x05C9 // Inputs[2] // { // @1DA1 stack[-1] // @1DA2 stack[-2] // } 1D9C 5B JUMPDEST 1D9D 60 PUSH1 0x00 1D9F 60 PUSH1 0x20 1DA1 82 DUP3 1DA2 84 DUP5 1DA3 03 SUB 1DA4 12 SLT 1DA5 15 ISZERO 1DA6 61 PUSH2 0x1dae 1DA9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D9D stack[0] = 0x00 } // Block ends with conditional jump to 0x1dae, if !(stack[-2] - stack[-1] i< 0x20) label_1DAA: // Incoming jump from 0x1DA9, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1DAD memory[0x00:0x00] } 1DAA 60 PUSH1 0x00 1DAC 80 DUP1 1DAD FD *REVERT // Stack delta = +0 // Outputs[1] { @1DAD revert(memory[0x00:0x00]); } // Block terminates label_1DAE: // Incoming jump from 0x1DA9, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1DB0 stack[-2] // @1DB0 msg.data[stack[-2]:stack[-2] + 0x20] // @1DB1 stack[-4] // @1DB2 stack[-3] // } 1DAE 5B JUMPDEST 1DAF 50 POP 1DB0 35 CALLDATALOAD 1DB1 91 SWAP2 1DB2 90 SWAP1 1DB3 50 POP 1DB4 56 *JUMP // Stack delta = -3 // Outputs[1] { @1DB1 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1DB5: // Incoming call from 0x1E21, returns to 0x1E22 // Incoming call from 0x1FDA, returns to 0x1735 // Incoming call from 0x20B3, returns to 0x2005 // Incoming call from 0x20A5, returns to 0x20A6 // Incoming call from 0x202C, returns to 0x202D // Incoming call from 0x1FF6, returns to 0x1FF7 // Incoming call from 0x1E13, returns to 0x1E14 // Incoming call from 0x203A, returns to 0x203B // Incoming call from 0x1DE7, returns to 0x1DE8 // Inputs[2] // { // @1DB6 stack[-1] // @1DB7 msg.data[stack[-1]:stack[-1] + 0x20] // } 1DB5 5B JUMPDEST 1DB6 80 DUP1 1DB7 35 CALLDATALOAD 1DB8 60 PUSH1 0x01 1DBA 60 PUSH1 0x01 1DBC 60 PUSH1 0xa0 1DBE 1B SHL 1DBF 03 SUB 1DC0 81 DUP2 1DC1 16 AND 1DC2 81 DUP2 1DC3 14 EQ 1DC4 61 PUSH2 0x1d11 1DC7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DB7 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1d11, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_1DC8: // Incoming jump from 0x1DC7, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1DCB memory[0x00:0x00] } 1DC8 60 PUSH1 0x00 1DCA 80 DUP1 1DCB FD *REVERT // Stack delta = +0 // Outputs[1] { @1DCB revert(memory[0x00:0x00]); } // Block terminates label_1DCC: // Incoming call from 0x0355, returns to 0x0356 // Inputs[2] // { // @1DD2 stack[-1] // @1DD3 stack[-2] // } 1DCC 5B JUMPDEST 1DCD 60 PUSH1 0x00 1DCF 80 DUP1 1DD0 60 PUSH1 0x40 1DD2 83 DUP4 1DD3 85 DUP6 1DD4 03 SUB 1DD5 12 SLT 1DD6 15 ISZERO 1DD7 61 PUSH2 0x1ddf 1DDA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DCD stack[0] = 0x00 // @1DCF stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ddf, if !(stack[-2] - stack[-1] i< 0x40) label_1DDB: // Incoming jump from 0x1DDA, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1DDE memory[0x00:0x00] } 1DDB 60 PUSH1 0x00 1DDD 80 DUP1 1DDE FD *REVERT // Stack delta = +0 // Outputs[1] { @1DDE revert(memory[0x00:0x00]); } // Block terminates label_1DDF: // Incoming jump from 0x1DDA, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1DE3 stack[-3] } 1DDF 5B JUMPDEST 1DE0 61 PUSH2 0x1de8 1DE3 83 DUP4 1DE4 61 PUSH2 0x1db5 1DE7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1DE0 stack[0] = 0x1de8 // @1DE3 stack[1] = stack[-3] // } // Block ends with call to 0x1db5, returns to 0x1DE8 label_1DE8: // Incoming return from call to 0x1DB5 at 0x1DE7 // Inputs[5] // { // @1DE9 stack[-6] // @1DE9 stack[-1] // @1DEC stack[-4] // @1DF0 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1DF1 stack[-5] // } 1DE8 5B JUMPDEST 1DE9 94 SWAP5 1DEA 60 PUSH1 0x20 1DEC 93 SWAP4 1DED 90 SWAP1 1DEE 93 SWAP4 1DEF 01 ADD 1DF0 35 CALLDATALOAD 1DF1 93 SWAP4 1DF2 50 POP 1DF3 50 POP 1DF4 50 POP 1DF5 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1DE9 stack[-6] = stack[-1] // @1DF1 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_1DF6: // Incoming call from 0x043E, returns to 0x043F // Incoming call from 0x03C4, returns to 0x03C5 // Inputs[2] // { // @1DFE stack[-1] // @1DFF stack[-2] // } 1DF6 5B JUMPDEST 1DF7 60 PUSH1 0x00 1DF9 80 DUP1 1DFA 60 PUSH1 0x00 1DFC 60 PUSH1 0x60 1DFE 84 DUP5 1DFF 86 DUP7 1E00 03 SUB 1E01 12 SLT 1E02 15 ISZERO 1E03 61 PUSH2 0x1e0b 1E06 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1DF7 stack[0] = 0x00 // @1DF9 stack[1] = 0x00 // @1DFA stack[2] = 0x00 // } // Block ends with conditional jump to 0x1e0b, if !(stack[-2] - stack[-1] i< 0x60) label_1E07: // Incoming jump from 0x1E06, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1E0A memory[0x00:0x00] } 1E07 60 PUSH1 0x00 1E09 80 DUP1 1E0A FD *REVERT // Stack delta = +0 // Outputs[1] { @1E0A revert(memory[0x00:0x00]); } // Block terminates label_1E0B: // Incoming jump from 0x1E06, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1E0F stack[-4] } 1E0B 5B JUMPDEST 1E0C 61 PUSH2 0x1e14 1E0F 84 DUP5 1E10 61 PUSH2 0x1db5 1E13 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E0C stack[0] = 0x1e14 // @1E0F stack[1] = stack[-4] // } // Block ends with call to 0x1db5, returns to 0x1E14 label_1E14: // Incoming return from call to 0x1DB5 at 0x1E13 // Inputs[3] // { // @1E15 stack[-4] // @1E15 stack[-1] // @1E1C stack[-5] // } 1E14 5B JUMPDEST 1E15 92 SWAP3 1E16 50 POP 1E17 61 PUSH2 0x1e22 1E1A 60 PUSH1 0x20 1E1C 85 DUP6 1E1D 01 ADD 1E1E 61 PUSH2 0x1db5 1E21 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1E15 stack[-4] = stack[-1] // @1E17 stack[-1] = 0x1e22 // @1E1D stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x1db5, returns to 0x1E22 label_1E22: // Incoming return from call to 0x1DB5 at 0x1E21 // Inputs[8] // { // @1E23 stack[-1] // @1E23 stack[-3] // @1E27 stack[-5] // @1E29 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1E2A stack[-2] // @1E2E stack[-6] // @1E30 stack[-4] // @1E30 stack[-7] // } 1E22 5B JUMPDEST 1E23 91 SWAP2 1E24 50 POP 1E25 60 PUSH1 0x40 1E27 84 DUP5 1E28 01 ADD 1E29 35 CALLDATALOAD 1E2A 90 SWAP1 1E2B 50 POP 1E2C 92 SWAP3 1E2D 50 POP 1E2E 92 SWAP3 1E2F 50 POP 1E30 92 SWAP3 1E31 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1E2C stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1E2E stack[-6] = stack[-1] // @1E30 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1E32: // Incoming jump from 0x1EC9 // Incoming jump from 0x1E70 // Incoming jump from 0x1F38 // Inputs[1] { @1E47 memory[0x00:0x24] } 1E32 5B JUMPDEST 1E33 63 PUSH4 0x4e487b71 1E38 60 PUSH1 0xe0 1E3A 1B SHL 1E3B 60 PUSH1 0x00 1E3D 52 MSTORE 1E3E 60 PUSH1 0x41 1E40 60 PUSH1 0x04 1E42 52 MSTORE 1E43 60 PUSH1 0x24 1E45 60 PUSH1 0x00 1E47 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1E3D memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1E42 memory[0x04:0x24] = 0x41 // @1E47 revert(memory[0x00:0x24]); // } // Block terminates label_1E48: // Incoming call from 0x1F4B, returns to 0x1F4C // Incoming call from 0x1EDA, returns to 0x1EDB // Inputs[2] // { // @1E4B memory[0x40:0x60] // @1E4E stack[-1] // } 1E48 5B JUMPDEST 1E49 60 PUSH1 0x40 1E4B 51 MLOAD 1E4C 60 PUSH1 0x1f 1E4E 82 DUP3 1E4F 01 ADD 1E50 60 PUSH1 0x1f 1E52 19 NOT 1E53 16 AND 1E54 81 DUP2 1E55 01 ADD 1E56 67 PUSH8 0xffffffffffffffff 1E5F 81 DUP2 1E60 11 GT 1E61 82 DUP3 1E62 82 DUP3 1E63 10 LT 1E64 17 OR 1E65 15 ISZERO 1E66 61 PUSH2 0x1e71 1E69 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E4B stack[0] = memory[0x40:0x60] // @1E55 stack[1] = memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) // } // Block ends with conditional jump to 0x1e71, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) label_1E6A: // Incoming jump from 0x1E69, if not !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) 1E6A 61 PUSH2 0x1e71 1E6D 61 PUSH2 0x1e32 1E70 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E6A stack[0] = 0x1e71 } // Block ends with unconditional jump to 0x1e32 label_1E71: // Incoming jump from 0x1E69, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) // Inputs[4] // { // @1E74 stack[-1] // @1E75 stack[-4] // @1E75 stack[-2] // @1E76 stack[-3] // } 1E71 5B JUMPDEST 1E72 60 PUSH1 0x40 1E74 52 MSTORE 1E75 91 SWAP2 1E76 90 SWAP1 1E77 50 POP 1E78 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1E74 memory[0x40:0x60] = stack[-1] // @1E75 stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_1E79: // Incoming call from 0x041E, returns to 0x041F // Inputs[2] // { // @1E7F stack[-1] // @1E80 stack[-2] // } 1E79 5B JUMPDEST 1E7A 60 PUSH1 0x00 1E7C 60 PUSH1 0x20 1E7E 80 DUP1 1E7F 83 DUP4 1E80 85 DUP6 1E81 03 SUB 1E82 12 SLT 1E83 15 ISZERO 1E84 61 PUSH2 0x1e8c 1E87 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E7A stack[0] = 0x00 // @1E7C stack[1] = 0x20 // } // Block ends with conditional jump to 0x1e8c, if !(stack[-2] - stack[-1] i< 0x20) label_1E88: // Incoming jump from 0x1E87, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1E8B memory[0x00:0x00] } 1E88 60 PUSH1 0x00 1E8A 80 DUP1 1E8B FD *REVERT // Stack delta = +0 // Outputs[1] { @1E8B revert(memory[0x00:0x00]); } // Block terminates label_1E8C: // Incoming jump from 0x1E87, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E8D stack[-3] // @1E8E msg.data[stack[-3]:stack[-3] + 0x20] // } 1E8C 5B JUMPDEST 1E8D 82 DUP3 1E8E 35 CALLDATALOAD 1E8F 67 PUSH8 0xffffffffffffffff 1E98 80 DUP1 1E99 82 DUP3 1E9A 11 GT 1E9B 15 ISZERO 1E9C 61 PUSH2 0x1ea4 1E9F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E8E stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1E8F stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1ea4, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1EA0: // Incoming jump from 0x1E9F, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1EA3 memory[0x00:0x00] } 1EA0 60 PUSH1 0x00 1EA2 80 DUP1 1EA3 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EA3 revert(memory[0x00:0x00]); } // Block terminates label_1EA4: // Incoming jump from 0x1E9F, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1EA5 stack[-2] // @1EA6 stack[-5] // @1EAA stack[-6] // } 1EA4 5B JUMPDEST 1EA5 81 DUP2 1EA6 85 DUP6 1EA7 01 ADD 1EA8 91 SWAP2 1EA9 50 POP 1EAA 85 DUP6 1EAB 60 PUSH1 0x1f 1EAD 83 DUP4 1EAE 01 ADD 1EAF 12 SLT 1EB0 61 PUSH2 0x1eb8 1EB3 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1EA8 stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x1eb8, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_1EB4: // Incoming jump from 0x1EB3, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @1EB7 memory[0x00:0x00] } 1EB4 60 PUSH1 0x00 1EB6 80 DUP1 1EB7 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EB7 revert(memory[0x00:0x00]); } // Block terminates label_1EB8: // Incoming jump from 0x1EB3, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @1EB9 stack[-2] // @1EBA msg.data[stack[-2]:stack[-2] + 0x20] // @1EBB stack[-1] // } 1EB8 5B JUMPDEST 1EB9 81 DUP2 1EBA 35 CALLDATALOAD 1EBB 81 DUP2 1EBC 81 DUP2 1EBD 11 GT 1EBE 15 ISZERO 1EBF 61 PUSH2 0x1eca 1EC2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1EBA stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1eca, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_1EC3: // Incoming jump from 0x1EC2, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) 1EC3 61 PUSH2 0x1eca 1EC6 61 PUSH2 0x1e32 1EC9 56 *JUMP // Stack delta = +1 // Outputs[1] { @1EC3 stack[0] = 0x1eca } // Block ends with unconditional jump to 0x1e32 label_1ECA: // Incoming jump from 0x1EC2, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @1ECB stack[-1] // @1ECF stack[-2] // @1ED4 stack[-4] // } 1ECA 5B JUMPDEST 1ECB 80 DUP1 1ECC 60 PUSH1 0x05 1ECE 1B SHL 1ECF 91 SWAP2 1ED0 50 POP 1ED1 61 PUSH2 0x1edb 1ED4 84 DUP5 1ED5 83 DUP4 1ED6 01 ADD 1ED7 61 PUSH2 0x1e48 1EDA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1ECF stack[-2] = stack[-1] << 0x05 // @1ED1 stack[0] = 0x1edb // @1ED6 stack[1] = (stack[-1] << 0x05) + stack[-4] // } // Block ends with call to 0x1e48, returns to 0x1EDB label_1EDB: // Incoming return from call to 0x1E48 at 0x1EDA // Inputs[6] // { // @1EDC stack[-2] // @1EDD stack[-1] // @1EDF stack[-3] // @1EE0 stack[-4] // @1EE2 stack[-5] // @1EE9 stack[-8] // } 1EDB 5B JUMPDEST 1EDC 81 DUP2 1EDD 81 DUP2 1EDE 52 MSTORE 1EDF 91 SWAP2 1EE0 83 DUP4 1EE1 01 ADD 1EE2 84 DUP5 1EE3 01 ADD 1EE4 91 SWAP2 1EE5 84 DUP5 1EE6 81 DUP2 1EE7 01 ADD 1EE8 90 SWAP1 1EE9 88 DUP9 1EEA 84 DUP5 1EEB 11 GT 1EEC 15 ISZERO 1EED 61 PUSH2 0x1ef5 1EF0 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1EDE memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @1EE4 stack[-3] = stack[-5] + stack[-4] + stack[-3] // @1EE8 stack[-1] = stack[-1] + stack[-5] // @1EE8 stack[0] = stack[-1] // } // Block ends with conditional jump to 0x1ef5, if !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) label_1EF1: // Incoming jump from 0x1EF0, if not !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) // Inputs[1] { @1EF4 memory[0x00:0x00] } 1EF1 60 PUSH1 0x00 1EF3 80 DUP1 1EF4 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EF4 revert(memory[0x00:0x00]); } // Block terminates label_1EF5: // Incoming jump from 0x1EF0, if !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) // Inputs[4] // { // @1EF6 stack[-1] // @1EF6 stack[-5] // @1EF7 stack[-6] // @1EFB stack[-4] // } 1EF5 5B JUMPDEST 1EF6 93 SWAP4 1EF7 85 DUP6 1EF8 01 ADD 1EF9 93 SWAP4 1EFA 5B JUMPDEST 1EFB 83 DUP4 1EFC 85 DUP6 1EFD 10 LT 1EFE 15 ISZERO 1EFF 61 PUSH2 0x1f13 1F02 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1EF9 stack[-5] = stack[-6] + stack[-5] // @1EF9 stack[-1] = stack[-1] // } // Block ends with conditional jump to 0x1f13, if !(stack[-6] + stack[-5] < stack[-4]) label_1F03: // Incoming jump from 0x1F02, if not !(stack[-5] < stack[-4]) // Incoming jump from 0x1F02, if not !(stack[-6] + stack[-5] < stack[-4]) // Inputs[5] // { // @1F03 stack[-5] // @1F04 msg.data[stack[-5]:stack[-5] + 0x20] // @1F05 stack[-2] // @1F07 stack[-1] // @1F08 stack[-6] // } 1F03 84 DUP5 1F04 35 CALLDATALOAD 1F05 82 DUP3 1F06 52 MSTORE 1F07 93 SWAP4 1F08 85 DUP6 1F09 01 ADD 1F0A 93 SWAP4 1F0B 90 SWAP1 1F0C 85 DUP6 1F0D 01 ADD 1F0E 90 SWAP1 1F0F 61 PUSH2 0x1efa 1F12 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1F06 memory[stack[-2]:stack[-2] + 0x20] = msg.data[stack[-5]:stack[-5] + 0x20] // @1F0A stack[-5] = stack[-6] + stack[-5] // @1F0E stack[-1] = stack[-1] // @1F0E stack[-2] = stack[-6] + stack[-2] // } // Block ends with unconditional jump to 0x1efa label_1F13: // Incoming jump from 0x1F02, if !(stack[-5] < stack[-4]) // Incoming jump from 0x1F02, if !(stack[-6] + stack[-5] < stack[-4]) // Inputs[3] // { // @1F14 stack[-1] // @1F14 stack[-10] // @1F15 stack[-9] // } 1F13 5B JUMPDEST 1F14 98 SWAP9 1F15 97 SWAP8 1F16 50 POP 1F17 50 POP 1F18 50 POP 1F19 50 POP 1F1A 50 POP 1F1B 50 POP 1F1C 50 POP 1F1D 50 POP 1F1E 56 *JUMP // Stack delta = -9 // Outputs[1] { @1F14 stack[-10] = stack[-1] } // Block ends with unconditional jump to stack[-10] label_1F1F: // Incoming call from 0x207D, returns to 0x207E // Incoming call from 0x1FBF, returns to 0x16AF // Inputs[1] { @1F2B stack[-2] } 1F1F 5B JUMPDEST 1F20 60 PUSH1 0x00 1F22 67 PUSH8 0xffffffffffffffff 1F2B 83 DUP4 1F2C 11 GT 1F2D 15 ISZERO 1F2E 61 PUSH2 0x1f39 1F31 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F20 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f39, if !(stack[-2] > 0xffffffffffffffff) label_1F32: // Incoming jump from 0x1F31, if not !(stack[-2] > 0xffffffffffffffff) 1F32 61 PUSH2 0x1f39 1F35 61 PUSH2 0x1e32 1F38 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F32 stack[0] = 0x1f39 } // Block ends with unconditional jump to 0x1e32 label_1F39: // Incoming jump from 0x1F31, if !(stack[-2] > 0xffffffffffffffff) // Inputs[1] { @1F3F stack[-3] } 1F39 5B JUMPDEST 1F3A 61 PUSH2 0x1f4c 1F3D 60 PUSH1 0x1f 1F3F 84 DUP5 1F40 01 ADD 1F41 60 PUSH1 0x1f 1F43 19 NOT 1F44 16 AND 1F45 60 PUSH1 0x20 1F47 01 ADD 1F48 61 PUSH2 0x1e48 1F4B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F3A stack[0] = 0x1f4c // @1F47 stack[1] = 0x20 + (~0x1f & stack[-3] + 0x1f) // } // Block ends with call to 0x1e48, returns to 0x1F4C label_1F4C: // Incoming return from call to 0x1E48 at 0x1F4B // Inputs[5] // { // @1F4D stack[-1] // @1F4D stack[-2] // @1F4F stack[-4] // @1F52 stack[-5] // @1F54 stack[-3] // } 1F4C 5B JUMPDEST 1F4D 90 SWAP1 1F4E 50 POP 1F4F 82 DUP3 1F50 81 DUP2 1F51 52 MSTORE 1F52 83 DUP4 1F53 83 DUP4 1F54 83 DUP4 1F55 01 ADD 1F56 11 GT 1F57 15 ISZERO 1F58 61 PUSH2 0x1f60 1F5B 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1F4D stack[-2] = stack[-1] // @1F51 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // } // Block ends with conditional jump to 0x1f60, if !(stack[-3] + stack[-4] > stack[-5]) label_1F5C: // Incoming jump from 0x1F5B, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @1F5F memory[0x00:0x00] } 1F5C 60 PUSH1 0x00 1F5E 80 DUP1 1F5F FD *REVERT // Stack delta = +0 // Outputs[1] { @1F5F revert(memory[0x00:0x00]); } // Block terminates label_1F60: // Incoming jump from 0x1F5B, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[6] // { // @1F61 stack[-3] // @1F62 stack[-2] // @1F65 stack[-1] // @1F67 msg.data[stack[-2]:stack[-2] + stack[-3]] // @1F71 stack[-5] // @1F72 stack[-4] // } 1F60 5B JUMPDEST 1F61 82 DUP3 1F62 82 DUP3 1F63 60 PUSH1 0x20 1F65 83 DUP4 1F66 01 ADD 1F67 37 CALLDATACOPY 1F68 60 PUSH1 0x00 1F6A 60 PUSH1 0x20 1F6C 84 DUP5 1F6D 83 DUP4 1F6E 01 ADD 1F6F 01 ADD 1F70 52 MSTORE 1F71 93 SWAP4 1F72 92 SWAP3 1F73 50 POP 1F74 50 POP 1F75 50 POP 1F76 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1F67 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-3]] = msg.data[stack[-2]:stack[-2] + stack[-3]] // @1F70 memory[stack[-1] + stack[-3] + 0x20:stack[-1] + stack[-3] + 0x20 + 0x20] = 0x00 // @1F71 stack[-5] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_1F77: // Incoming call from 0x0562, returns to 0x0563 // Incoming call from 0x047E, returns to 0x047F // Inputs[2] // { // @1F7C stack[-1] // @1F7D stack[-2] // } 1F77 5B JUMPDEST 1F78 60 PUSH1 0x00 1F7A 60 PUSH1 0x20 1F7C 82 DUP3 1F7D 84 DUP5 1F7E 03 SUB 1F7F 12 SLT 1F80 15 ISZERO 1F81 61 PUSH2 0x1f89 1F84 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F78 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f89, if !(stack[-2] - stack[-1] i< 0x20) label_1F85: // Incoming jump from 0x1F84, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1F88 memory[0x00:0x00] } 1F85 60 PUSH1 0x00 1F87 80 DUP1 1F88 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F88 revert(memory[0x00:0x00]); } // Block terminates label_1F89: // Incoming jump from 0x1F84, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1F8A stack[-2] // @1F8B msg.data[stack[-2]:stack[-2] + 0x20] // } 1F89 5B JUMPDEST 1F8A 81 DUP2 1F8B 35 CALLDATALOAD 1F8C 67 PUSH8 0xffffffffffffffff 1F95 81 DUP2 1F96 11 GT 1F97 15 ISZERO 1F98 61 PUSH2 0x1fa0 1F9B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F8B stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1fa0, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1F9C: // Incoming jump from 0x1F9B, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1F9F memory[0x00:0x00] } 1F9C 60 PUSH1 0x00 1F9E 80 DUP1 1F9F FD *REVERT // Stack delta = +0 // Outputs[1] { @1F9F revert(memory[0x00:0x00]); } // Block terminates label_1FA0: // Incoming jump from 0x1F9B, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1FA1 stack[-3] // @1FA2 stack[-1] // @1FA7 stack[-4] // } 1FA0 5B JUMPDEST 1FA1 82 DUP3 1FA2 01 ADD 1FA3 60 PUSH1 0x1f 1FA5 81 DUP2 1FA6 01 ADD 1FA7 84 DUP5 1FA8 13 SGT 1FA9 61 PUSH2 0x1fb1 1FAC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1FA2 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1fb1, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_1FAD: // Incoming jump from 0x1FAC, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @1FB0 memory[0x00:0x00] } 1FAD 60 PUSH1 0x00 1FAF 80 DUP1 1FB0 FD *REVERT // Stack delta = +0 // Outputs[1] { @1FB0 revert(memory[0x00:0x00]); } // Block terminates label_1FB1: // Incoming jump from 0x1FAC, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @1FB5 stack[-4] // @1FB6 stack[-1] // @1FB7 msg.data[stack[-1]:stack[-1] + 0x20] // } 1FB1 5B JUMPDEST 1FB2 61 PUSH2 0x16af 1FB5 84 DUP5 1FB6 82 DUP3 1FB7 35 CALLDATALOAD 1FB8 60 PUSH1 0x20 1FBA 84 DUP5 1FBB 01 ADD 1FBC 61 PUSH2 0x1f1f 1FBF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1FB2 stack[0] = 0x16af // @1FB5 stack[1] = stack[-4] // @1FB7 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1FBB stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1f1f, returns to 0x16AF label_1FC0: // Incoming call from 0x0708, returns to 0x0709 // Incoming call from 0x050D, returns to 0x050E // Inputs[2] // { // @1FC5 stack[-1] // @1FC6 stack[-2] // } 1FC0 5B JUMPDEST 1FC1 60 PUSH1 0x00 1FC3 60 PUSH1 0x20 1FC5 82 DUP3 1FC6 84 DUP5 1FC7 03 SUB 1FC8 12 SLT 1FC9 15 ISZERO 1FCA 61 PUSH2 0x1fd2 1FCD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1FC1 stack[0] = 0x00 } // Block ends with conditional jump to 0x1fd2, if !(stack[-2] - stack[-1] i< 0x20) label_1FCE: // Incoming jump from 0x1FCD, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1FD1 memory[0x00:0x00] } 1FCE 60 PUSH1 0x00 1FD0 80 DUP1 1FD1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1FD1 revert(memory[0x00:0x00]); } // Block terminates label_1FD2: // Incoming jump from 0x1FCD, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1FD6 stack[-2] } 1FD2 5B JUMPDEST 1FD3 61 PUSH2 0x1735 1FD6 82 DUP3 1FD7 61 PUSH2 0x1db5 1FDA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1FD3 stack[0] = 0x1735 // @1FD6 stack[1] = stack[-2] // } // Block ends with call to 0x1db5, returns to 0x1735 label_1FDB: // Incoming call from 0x05E8, returns to 0x05E9 // Inputs[2] // { // @1FE1 stack[-1] // @1FE2 stack[-2] // } 1FDB 5B JUMPDEST 1FDC 60 PUSH1 0x00 1FDE 80 DUP1 1FDF 60 PUSH1 0x40 1FE1 83 DUP4 1FE2 85 DUP6 1FE3 03 SUB 1FE4 12 SLT 1FE5 15 ISZERO 1FE6 61 PUSH2 0x1fee 1FE9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1FDC stack[0] = 0x00 // @1FDE stack[1] = 0x00 // } // Block ends with conditional jump to 0x1fee, if !(stack[-2] - stack[-1] i< 0x40) label_1FEA: // Incoming jump from 0x1FE9, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1FED memory[0x00:0x00] } 1FEA 60 PUSH1 0x00 1FEC 80 DUP1 1FED FD *REVERT // Stack delta = +0 // Outputs[1] { @1FED revert(memory[0x00:0x00]); } // Block terminates label_1FEE: // Incoming jump from 0x1FE9, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1FF2 stack[-3] } 1FEE 5B JUMPDEST 1FEF 61 PUSH2 0x1ff7 1FF2 83 DUP4 1FF3 61 PUSH2 0x1db5 1FF6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1FEF stack[0] = 0x1ff7 // @1FF2 stack[1] = stack[-3] // } // Block ends with call to 0x1db5, returns to 0x1FF7 label_1FF7: // Incoming return from call to 0x1DB5 at 0x1FF6 // Inputs[3] // { // @1FF8 stack[-1] // @1FF8 stack[-3] // @1FFF stack[-4] // } 1FF7 5B JUMPDEST 1FF8 91 SWAP2 1FF9 50 POP 1FFA 61 PUSH2 0x2005 1FFD 60 PUSH1 0x20 1FFF 84 DUP5 2000 01 ADD 2001 61 PUSH2 0x1d01 2004 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1FF8 stack[-3] = stack[-1] // @1FFA stack[-1] = 0x2005 // @2000 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1d01, returns to 0x2005 label_2005: // Incoming return from call to 0x1D01 at 0x2004 // Incoming return from call to 0x1DB5 at 0x20B3 // Inputs[6] // { // @2006 stack[-1] // @2006 stack[-2] // @2008 stack[-5] // @200A stack[-6] // @200A stack[-3] // @200B stack[-4] // } 2005 5B JUMPDEST 2006 90 SWAP1 2007 50 POP 2008 92 SWAP3 2009 50 POP 200A 92 SWAP3 200B 90 SWAP1 200C 50 POP 200D 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2008 stack[-5] = stack[-1] // @200A stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_200E: // Incoming call from 0x0608, returns to 0x0609 // Inputs[2] // { // @2017 stack[-1] // @2018 stack[-2] // } 200E 5B JUMPDEST 200F 60 PUSH1 0x00 2011 80 DUP1 2012 60 PUSH1 0x00 2014 80 DUP1 2015 60 PUSH1 0x80 2017 85 DUP6 2018 87 DUP8 2019 03 SUB 201A 12 SLT 201B 15 ISZERO 201C 61 PUSH2 0x2024 201F 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @200F stack[0] = 0x00 // @2011 stack[1] = 0x00 // @2012 stack[2] = 0x00 // @2014 stack[3] = 0x00 // } // Block ends with conditional jump to 0x2024, if !(stack[-2] - stack[-1] i< 0x80) label_2020: // Incoming jump from 0x201F, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2023 memory[0x00:0x00] } 2020 60 PUSH1 0x00 2022 80 DUP1 2023 FD *REVERT // Stack delta = +0 // Outputs[1] { @2023 revert(memory[0x00:0x00]); } // Block terminates label_2024: // Incoming jump from 0x201F, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2028 stack[-5] } 2024 5B JUMPDEST 2025 61 PUSH2 0x202d 2028 85 DUP6 2029 61 PUSH2 0x1db5 202C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2025 stack[0] = 0x202d // @2028 stack[1] = stack[-5] // } // Block ends with call to 0x1db5, returns to 0x202D label_202D: // Incoming return from call to 0x1DB5 at 0x202C // Inputs[3] // { // @202E stack[-5] // @202E stack[-1] // @2035 stack[-6] // } 202D 5B JUMPDEST 202E 93 SWAP4 202F 50 POP 2030 61 PUSH2 0x203b 2033 60 PUSH1 0x20 2035 86 DUP7 2036 01 ADD 2037 61 PUSH2 0x1db5 203A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @202E stack[-5] = stack[-1] // @2030 stack[-1] = 0x203b // @2036 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x1db5, returns to 0x203B label_203B: // Incoming return from call to 0x1DB5 at 0x203A // Inputs[6] // { // @203C stack[-1] // @203C stack[-4] // @2040 stack[-6] // @2042 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2043 stack[-3] // @2049 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 203B 5B JUMPDEST 203C 92 SWAP3 203D 50 POP 203E 60 PUSH1 0x40 2040 85 DUP6 2041 01 ADD 2042 35 CALLDATALOAD 2043 91 SWAP2 2044 50 POP 2045 60 PUSH1 0x60 2047 85 DUP6 2048 01 ADD 2049 35 CALLDATALOAD 204A 67 PUSH8 0xffffffffffffffff 2053 81 DUP2 2054 11 GT 2055 15 ISZERO 2056 61 PUSH2 0x205e 2059 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @203C stack[-4] = stack[-1] // @2043 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2049 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x205e, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_205A: // Incoming jump from 0x2059, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @205D memory[0x00:0x00] } 205A 60 PUSH1 0x00 205C 80 DUP1 205D FD *REVERT // Stack delta = +0 // Outputs[1] { @205D revert(memory[0x00:0x00]); } // Block terminates label_205E: // Incoming jump from 0x2059, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @205F stack[-6] // @2060 stack[-1] // @2065 stack[-7] // } 205E 5B JUMPDEST 205F 85 DUP6 2060 01 ADD 2061 60 PUSH1 0x1f 2063 81 DUP2 2064 01 ADD 2065 87 DUP8 2066 13 SGT 2067 61 PUSH2 0x206f 206A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2060 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x206f, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_206B: // Incoming jump from 0x206A, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @206E memory[0x00:0x00] } 206B 60 PUSH1 0x00 206D 80 DUP1 206E FD *REVERT // Stack delta = +0 // Outputs[1] { @206E revert(memory[0x00:0x00]); } // Block terminates label_206F: // Incoming jump from 0x206A, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @2073 stack[-7] // @2074 stack[-1] // @2075 msg.data[stack[-1]:stack[-1] + 0x20] // } 206F 5B JUMPDEST 2070 61 PUSH2 0x207e 2073 87 DUP8 2074 82 DUP3 2075 35 CALLDATALOAD 2076 60 PUSH1 0x20 2078 84 DUP5 2079 01 ADD 207A 61 PUSH2 0x1f1f 207D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2070 stack[0] = 0x207e // @2073 stack[1] = stack[-7] // @2075 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2079 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1f1f, returns to 0x207E label_207E: // Incoming return from call to 0x1F1F at 0x207D // Inputs[8] // { // @207F stack[-1] // @207F stack[-3] // @2082 stack[-6] // @2083 stack[-9] // @2084 stack[-5] // @2085 stack[-8] // @2087 stack[-7] // @2087 stack[-4] // } 207E 5B JUMPDEST 207F 91 SWAP2 2080 50 POP 2081 50 POP 2082 92 SWAP3 2083 95 SWAP6 2084 91 SWAP2 2085 94 SWAP5 2086 50 POP 2087 92 SWAP3 2088 50 POP 2089 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @2082 stack[-6] = stack[-1] // @2083 stack[-9] = stack[-6] // @2085 stack[-8] = stack[-5] // @2087 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_208A: // Incoming call from 0x06BF, returns to 0x06C0 // Inputs[2] // { // @2090 stack[-1] // @2091 stack[-2] // } 208A 5B JUMPDEST 208B 60 PUSH1 0x00 208D 80 DUP1 208E 60 PUSH1 0x40 2090 83 DUP4 2091 85 DUP6 2092 03 SUB 2093 12 SLT 2094 15 ISZERO 2095 61 PUSH2 0x209d 2098 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @208B stack[0] = 0x00 // @208D stack[1] = 0x00 // } // Block ends with conditional jump to 0x209d, if !(stack[-2] - stack[-1] i< 0x40) label_2099: // Incoming jump from 0x2098, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @209C memory[0x00:0x00] } 2099 60 PUSH1 0x00 209B 80 DUP1 209C FD *REVERT // Stack delta = +0 // Outputs[1] { @209C revert(memory[0x00:0x00]); } // Block terminates label_209D: // Incoming jump from 0x2098, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @20A1 stack[-3] } 209D 5B JUMPDEST 209E 61 PUSH2 0x20a6 20A1 83 DUP4 20A2 61 PUSH2 0x1db5 20A5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @209E stack[0] = 0x20a6 // @20A1 stack[1] = stack[-3] // } // Block ends with call to 0x1db5, returns to 0x20A6 label_20A6: // Incoming return from call to 0x1DB5 at 0x20A5 // Inputs[3] // { // @20A7 stack[-3] // @20A7 stack[-1] // @20AE stack[-4] // } 20A6 5B JUMPDEST 20A7 91 SWAP2 20A8 50 POP 20A9 61 PUSH2 0x2005 20AC 60 PUSH1 0x20 20AE 84 DUP5 20AF 01 ADD 20B0 61 PUSH2 0x1db5 20B3 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @20A7 stack[-3] = stack[-1] // @20A9 stack[-1] = 0x2005 // @20AF stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1db5, returns to 0x2005 label_20B4: // Incoming call from 0x07E4, returns to 0x07E5 // Incoming call from 0x1C40, returns to 0x1C41 // Incoming call from 0x0C11, returns to 0x0C12 // Incoming call from 0x1065, returns to 0x0C12 // Incoming call from 0x194D, returns to 0x07E5 // Incoming call from 0x0810, returns to 0x0811 // Incoming call from 0x0E86, returns to 0x07E5 // Incoming call from 0x0C3D, returns to 0x0C3E // Inputs[1] { @20B7 stack[-1] } 20B4 5B JUMPDEST 20B5 60 PUSH1 0x01 20B7 81 DUP2 20B8 81 DUP2 20B9 1C SHR 20BA 90 SWAP1 20BB 82 DUP3 20BC 16 AND 20BD 80 DUP1 20BE 61 PUSH2 0x20c8 20C1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20BA stack[0] = stack[-1] >> 0x01 // @20BC stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x20c8, if stack[-1] & 0x01 label_20C2: // Incoming jump from 0x20C1, if not stack[-1] & 0x01 // Inputs[2] // { // @20C4 stack[-2] // @20CD stack[-1] // } 20C2 60 PUSH1 0x7f 20C4 82 DUP3 20C5 16 AND 20C6 91 SWAP2 20C7 50 POP 20C8 5B JUMPDEST 20C9 60 PUSH1 0x20 20CB 82 DUP3 20CC 10 LT 20CD 81 DUP2 20CE 14 EQ 20CF 15 ISZERO 20D0 61 PUSH2 0x20e9 20D3 57 *JUMPI // Stack delta = +0 // Outputs[1] { @20C6 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x20e9, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_20D4: // Incoming jump from 0x20D3, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x20D3, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @20E8 memory[0x00:0x24] } 20D4 63 PUSH4 0x4e487b71 20D9 60 PUSH1 0xe0 20DB 1B SHL 20DC 60 PUSH1 0x00 20DE 52 MSTORE 20DF 60 PUSH1 0x22 20E1 60 PUSH1 0x04 20E3 52 MSTORE 20E4 60 PUSH1 0x24 20E6 60 PUSH1 0x00 20E8 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @20DE memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @20E3 memory[0x04:0x24] = 0x22 // @20E8 revert(memory[0x00:0x24]); // } // Block terminates label_20E9: // Incoming jump from 0x20D3, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x20D3, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @20EB stack[-2] // @20EB stack[-4] // @20EC stack[-3] // } 20E9 5B JUMPDEST 20EA 50 POP 20EB 91 SWAP2 20EC 90 SWAP1 20ED 50 POP 20EE 56 *JUMP // Stack delta = -3 // Outputs[1] { @20EB stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_20EF: // Incoming jump from 0x2136 // Incoming jump from 0x2117 // Inputs[1] { @2104 memory[0x00:0x24] } 20EF 5B JUMPDEST 20F0 63 PUSH4 0x4e487b71 20F5 60 PUSH1 0xe0 20F7 1B SHL 20F8 60 PUSH1 0x00 20FA 52 MSTORE 20FB 60 PUSH1 0x11 20FD 60 PUSH1 0x04 20FF 52 MSTORE 2100 60 PUSH1 0x24 2102 60 PUSH1 0x00 2104 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @20FA memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @20FF memory[0x04:0x24] = 0x11 // @2104 revert(memory[0x00:0x24]); // } // Block terminates label_2105: // Incoming call from 0x0A95, returns to 0x0A96 // Incoming call from 0x0EC5, returns to 0x0EC6 // Inputs[2] // { // @2108 stack[-2] // @210A stack[-1] // } 2105 5B JUMPDEST 2106 60 PUSH1 0x00 2108 82 DUP3 2109 19 NOT 210A 82 DUP3 210B 11 GT 210C 15 ISZERO 210D 61 PUSH2 0x2118 2110 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2106 stack[0] = 0x00 } // Block ends with conditional jump to 0x2118, if !(stack[-1] > ~stack[-2]) label_2111: // Incoming jump from 0x2110, if not !(stack[-1] > ~stack[-2]) 2111 61 PUSH2 0x2118 2114 61 PUSH2 0x20ef 2117 56 *JUMP // Stack delta = +1 // Outputs[1] { @2111 stack[0] = 0x2118 } // Block ends with unconditional jump to 0x20ef label_2118: // Incoming jump from 0x2110, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @211A stack[-2] // @211A stack[-3] // @211B stack[-4] // } 2118 5B JUMPDEST 2119 50 POP 211A 01 ADD 211B 90 SWAP1 211C 56 *JUMP // Stack delta = -3 // Outputs[1] { @211B stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_211D: // Incoming call from 0x0AD5, returns to 0x0AD6 // Incoming call from 0x0F27, returns to 0x0F28 // Inputs[2] // { // @2120 stack[-1] // @2125 stack[-2] // } 211D 5B JUMPDEST 211E 60 PUSH1 0x00 2120 81 DUP2 2121 60 PUSH1 0x00 2123 19 NOT 2124 04 DIV 2125 83 DUP4 2126 11 GT 2127 82 DUP3 2128 15 ISZERO 2129 15 ISZERO 212A 16 AND 212B 15 ISZERO 212C 61 PUSH2 0x2137 212F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @211E stack[0] = 0x00 } // Block ends with conditional jump to 0x2137, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_2130: // Incoming jump from 0x212F, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 2130 61 PUSH2 0x2137 2133 61 PUSH2 0x20ef 2136 56 *JUMP // Stack delta = +1 // Outputs[1] { @2130 stack[0] = 0x2137 } // Block ends with unconditional jump to 0x20ef label_2137: // Incoming jump from 0x212F, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @2139 stack[-2] // @2139 stack[-3] // @213A stack[-4] // } 2137 5B JUMPDEST 2138 50 POP 2139 02 MUL 213A 90 SWAP1 213B 56 *JUMP // Stack delta = -3 // Outputs[1] { @213A stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_213C: // Incoming jump from 0x0B01 // Inputs[1] { @2151 memory[0x00:0x24] } 213C 5B JUMPDEST 213D 63 PUSH4 0x4e487b71 2142 60 PUSH1 0xe0 2144 1B SHL 2145 60 PUSH1 0x00 2147 52 MSTORE 2148 60 PUSH1 0x32 214A 60 PUSH1 0x04 214C 52 MSTORE 214D 60 PUSH1 0x24 214F 60 PUSH1 0x00 2151 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2147 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @214C memory[0x04:0x24] = 0x32 // @2151 revert(memory[0x00:0x24]); // } // Block terminates 2152 5B JUMPDEST 2153 60 PUSH1 0x00 2155 60 PUSH1 0x00 2157 19 NOT 2158 82 DUP3 2159 14 EQ 215A 15 ISZERO 215B 61 PUSH2 0x2166 215E 57 *JUMPI 215F 61 PUSH2 0x2166 2162 61 PUSH2 0x20ef 2165 56 *JUMP 2166 5B JUMPDEST 2167 50 POP 2168 60 PUSH1 0x01 216A 01 ADD 216B 90 SWAP1 216C 56 *JUMP 216D 5B JUMPDEST 216E 60 PUSH1 0x00 2170 83 DUP4 2171 51 MLOAD 2172 60 PUSH1 0x20 2174 61 PUSH2 0x2180 2177 82 DUP3 2178 85 DUP6 2179 83 DUP4 217A 89 DUP10 217B 01 ADD 217C 61 PUSH2 0x1d31 217F 56 *JUMP 2180 5B JUMPDEST 2181 84 DUP5 2182 54 SLOAD 2183 91 SWAP2 2184 84 DUP5 2185 01 ADD 2186 91 SWAP2 2187 60 PUSH1 0x00 2189 90 SWAP1 218A 60 PUSH1 0x01 218C 81 DUP2 218D 81 DUP2 218E 1C SHR 218F 90 SWAP1 2190 80 DUP1 2191 83 DUP4 2192 16 AND 2193 80 DUP1 2194 61 PUSH2 0x219e 2197 57 *JUMPI 2198 60 PUSH1 0x7f 219A 83 DUP4 219B 16 AND 219C 92 SWAP3 219D 50 POP 219E 5B JUMPDEST 219F 85 DUP6 21A0 83 DUP4 21A1 10 LT 21A2 81 DUP2 21A3 14 EQ 21A4 15 ISZERO 21A5 61 PUSH2 0x21bc 21A8 57 *JUMPI 21A9 63 PUSH4 0x4e487b71 21AE 60 PUSH1 0xe0 21B0 1B SHL 21B1 85 DUP6 21B2 52 MSTORE 21B3 60 PUSH1 0x22 21B5 60 PUSH1 0x04 21B7 52 MSTORE 21B8 60 PUSH1 0x24 21BA 85 DUP6 21BB FD *REVERT 21BC 5B JUMPDEST 21BD 80 DUP1 21BE 80 DUP1 21BF 15 ISZERO 21C0 61 PUSH2 0x21d0 21C3 57 *JUMPI 21C4 60 PUSH1 0x01 21C6 81 DUP2 21C7 14 EQ 21C8 61 PUSH2 0x21e1 21CB 57 *JUMPI 21CC 61 PUSH2 0x220e 21CF 56 *JUMP 21D0 5B JUMPDEST 21D1 60 PUSH1 0xff 21D3 19 NOT 21D4 85 DUP6 21D5 16 AND 21D6 88 DUP9 21D7 52 MSTORE 21D8 83 DUP4 21D9 88 DUP9 21DA 01 ADD 21DB 95 SWAP6 21DC 50 POP 21DD 61 PUSH2 0x220e 21E0 56 *JUMP 21E1 5B JUMPDEST 21E2 60 PUSH1 0x00 21E4 8B DUP12 21E5 81 DUP2 21E6 52 MSTORE 21E7 60 PUSH1 0x20 21E9 90 SWAP1 21EA 20 SHA3 21EB 60 PUSH1 0x00 21ED 5B JUMPDEST 21EE 85 DUP6 21EF 81 DUP2 21F0 10 LT 21F1 15 ISZERO 21F2 61 PUSH2 0x2206 21F5 57 *JUMPI 21F6 81 DUP2 21F7 54 SLOAD 21F8 8A DUP11 21F9 82 DUP3 21FA 01 ADD 21FB 52 MSTORE 21FC 90 SWAP1 21FD 84 DUP5 21FE 01 ADD 21FF 90 SWAP1 2200 88 DUP9 2201 01 ADD 2202 61 PUSH2 0x21ed 2205 56 *JUMP 2206 5B JUMPDEST 2207 50 POP 2208 50 POP 2209 83 DUP4 220A 88 DUP9 220B 01 ADD 220C 95 SWAP6 220D 50 POP 220E 5B JUMPDEST 220F 50 POP 2210 93 SWAP4 2211 9A SWAP11 2212 99 SWAP10 2213 50 POP 2214 50 POP 2215 50 POP 2216 50 POP 2217 50 POP 2218 50 POP 2219 50 POP 221A 50 POP 221B 50 POP 221C 50 POP 221D 56 *JUMP label_221E: // Incoming call from 0x1602, returns to 0x1603 // Inputs[5] // { // @222A stack[-5] // @222C stack[-1] // @222F stack[-4] // @2237 stack[-3] // @224B stack[-2] // } 221E 5B JUMPDEST 221F 60 PUSH1 0x00 2221 60 PUSH1 0x01 2223 60 PUSH1 0x01 2225 60 PUSH1 0xa0 2227 1B SHL 2228 03 SUB 2229 80 DUP1 222A 87 DUP8 222B 16 AND 222C 83 DUP4 222D 52 MSTORE 222E 80 DUP1 222F 86 DUP7 2230 16 AND 2231 60 PUSH1 0x20 2233 84 DUP5 2234 01 ADD 2235 52 MSTORE 2236 50 POP 2237 83 DUP4 2238 60 PUSH1 0x40 223A 83 DUP4 223B 01 ADD 223C 52 MSTORE 223D 60 PUSH1 0x80 223F 60 PUSH1 0x60 2241 83 DUP4 2242 01 ADD 2243 52 MSTORE 2244 61 PUSH2 0x2250 2247 60 PUSH1 0x80 2249 83 DUP4 224A 01 ADD 224B 84 DUP5 224C 61 PUSH2 0x1d5d 224F 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @221F stack[0] = 0x00 // @222D memory[stack[-1]:stack[-1] + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @2235 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @223C memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @2243 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @2244 stack[1] = 0x2250 // @224A stack[2] = stack[-1] + 0x80 // @224B stack[3] = stack[-2] // } // Block ends with call to 0x1d5d, returns to 0x2250 label_2250: // Incoming return from call to 0x1D5D at 0x224F // Inputs[3] // { // @2251 stack[-8] // @2251 stack[-1] // @2252 stack[-7] // } 2250 5B JUMPDEST 2251 96 SWAP7 2252 95 SWAP6 2253 50 POP 2254 50 POP 2255 50 POP 2256 50 POP 2257 50 POP 2258 50 POP 2259 56 *JUMP // Stack delta = -7 // Outputs[1] { @2251 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_225A: // Incoming jump from 0x163A // Inputs[2] // { // @225F stack[-1] // @2260 stack[-2] // } 225A 5B JUMPDEST 225B 60 PUSH1 0x00 225D 60 PUSH1 0x20 225F 82 DUP3 2260 84 DUP5 2261 03 SUB 2262 12 SLT 2263 15 ISZERO 2264 61 PUSH2 0x226c 2267 57 *JUMPI // Stack delta = +1 // Outputs[1] { @225B stack[0] = 0x00 } // Block ends with conditional jump to 0x226c, if !(stack[-2] - stack[-1] i< 0x20) label_2268: // Incoming jump from 0x2267, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @226B memory[0x00:0x00] } 2268 60 PUSH1 0x00 226A 80 DUP1 226B FD *REVERT // Stack delta = +0 // Outputs[1] { @226B revert(memory[0x00:0x00]); } // Block terminates label_226C: // Incoming jump from 0x2267, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @226D stack[-2] // @226E memory[stack[-2]:stack[-2] + 0x20] // } 226C 5B JUMPDEST 226D 81 DUP2 226E 51 MLOAD 226F 61 PUSH2 0x1735 2272 81 DUP2 2273 61 PUSH2 0x1cce 2276 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @226E stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @226F stack[1] = 0x1735 // @2272 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1cce, returns to 0x1735 2277 5B JUMPDEST 2278 60 PUSH1 0x00 227A 83 DUP4 227B 51 MLOAD 227C 61 PUSH2 0x2289 227F 81 DUP2 2280 84 DUP5 2281 60 PUSH1 0x20 2283 88 DUP9 2284 01 ADD 2285 61 PUSH2 0x1d31 2288 56 *JUMP 2289 5B JUMPDEST 228A 83 DUP4 228B 51 MLOAD 228C 90 SWAP1 228D 83 DUP4 228E 01 ADD 228F 90 SWAP1 2290 61 PUSH2 0x229d 2293 81 DUP2 2294 83 DUP4 2295 60 PUSH1 0x20 2297 88 DUP9 2298 01 ADD 2299 61 PUSH2 0x1d31 229C 56 *JUMP 229D 5B JUMPDEST 229E 01 ADD 229F 94 SWAP5 22A0 93 SWAP4 22A1 50 POP 22A2 50 POP 22A3 50 POP 22A4 50 POP 22A5 56 *JUMP 22A6 5B JUMPDEST 22A7 63 PUSH4 0x4e487b71 22AC 60 PUSH1 0xe0 22AE 1B SHL 22AF 60 PUSH1 0x00 22B1 52 MSTORE 22B2 60 PUSH1 0x12 22B4 60 PUSH1 0x04 22B6 52 MSTORE 22B7 60 PUSH1 0x24 22B9 60 PUSH1 0x00 22BB FD *REVERT 22BC 5B JUMPDEST 22BD 60 PUSH1 0x00 22BF 82 DUP3 22C0 61 PUSH2 0x22cb 22C3 57 *JUMPI 22C4 61 PUSH2 0x22cb 22C7 61 PUSH2 0x22a6 22CA 56 *JUMP 22CB 5B JUMPDEST 22CC 50 POP 22CD 04 DIV 22CE 90 SWAP1 22CF 56 *JUMP 22D0 5B JUMPDEST 22D1 60 PUSH1 0x00 22D3 82 DUP3 22D4 82 DUP3 22D5 10 LT 22D6 15 ISZERO 22D7 61 PUSH2 0x22e2 22DA 57 *JUMPI 22DB 61 PUSH2 0x22e2 22DE 61 PUSH2 0x20ef 22E1 56 *JUMP 22E2 5B JUMPDEST 22E3 50 POP 22E4 03 SUB 22E5 90 SWAP1 22E6 56 *JUMP 22E7 5B JUMPDEST 22E8 60 PUSH1 0x00 22EA 82 DUP3 22EB 61 PUSH2 0x22f6 22EE 57 *JUMPI 22EF 61 PUSH2 0x22f6 22F2 61 PUSH2 0x22a6 22F5 56 *JUMP 22F6 5B JUMPDEST 22F7 50 POP 22F8 06 MOD 22F9 90 SWAP1 22FA 56 *JUMP 22FB FE *ASSERT 22FC 4F 4F 22FD 77 PUSH24 0x6e61626c653a2063616c6c6572206973206e6f7420746865 2316 20 SHA3 2317 6F PUSH16 0x776e6572a2646970667358221220be90 2328 FE *ASSERT 2329 8C DUP13 232A B7 B7 232B F3 *RETURN 232C 75 PUSH22 0x74b0b944eed18ac42eb3a200f6fbad84c95ee3bd8439 2343 B6 B6 2344 65 PUSH6 0xe864736f6c63 234B 43 NUMBER 234C 00 *STOP 234D 08 ADDMOD 234E 0B SIGNEXTEND 234F 00 *STOP 2350 33 CALLER