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 0x02bb 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x02bb, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x6352211e 0019 11 GT 001A 61 PUSH2 0x016e 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x016e, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0x9c70b512 0024 11 GT 0025 61 PUSH2 0x00cb 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00cb, if 0x9c70b512 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0x9c70b512 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xc87b56dd 002F 11 GT 0030 61 PUSH2 0x007f 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007f, if 0xc87b56dd > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xc87b56dd > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xe7b99ec7 003A 11 GT 003B 61 PUSH2 0x0064 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0064, if 0xe7b99ec7 > stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xe7b99ec7 > stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe7b99ec7 0045 14 EQ 0046 61 PUSH2 0x070c 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x070c, if 0xe7b99ec7 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe7b99ec7 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe985e9c5 0050 14 EQ 0051 61 PUSH2 0x0727 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0727, if 0xe985e9c5 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x0770 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0770, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0063 memory[0x00:0x00] } 0060 60 PUSH1 0x00 0062 80 DUP1 0063 FD *REVERT // Stack delta = +0 // Outputs[1] { @0063 revert(memory[0x00:0x00]); } // Block terminates label_0064: // Incoming jump from 0x003E, if 0xe7b99ec7 > stack[-1] // Inputs[1] { @0065 stack[-1] } 0064 5B JUMPDEST 0065 80 DUP1 0066 63 PUSH4 0xc87b56dd 006B 14 EQ 006C 61 PUSH2 0x06d9 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06d9, if 0xc87b56dd == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xd2cab056 0076 14 EQ 0077 61 PUSH2 0x06f9 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06f9, if 0xd2cab056 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xd2cab056 == 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 0xc87b56dd > stack[-1] // Inputs[1] { @0080 stack[-1] } 007F 5B JUMPDEST 0080 80 DUP1 0081 63 PUSH4 0xa22cb465 0086 11 GT 0087 61 PUSH2 0x00b0 008A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b0, if 0xa22cb465 > stack[-1] label_008B: // Incoming jump from 0x008A, if not 0xa22cb465 > stack[-1] // Inputs[1] { @008B stack[-1] } 008B 80 DUP1 008C 63 PUSH4 0xa22cb465 0091 14 EQ 0092 61 PUSH2 0x0668 0095 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0668, if 0xa22cb465 == stack[-1] label_0096: // Incoming jump from 0x0095, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0096 stack[-1] } 0096 80 DUP1 0097 63 PUSH4 0xb88d4fde 009C 14 EQ 009D 61 PUSH2 0x0688 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0688, if 0xb88d4fde == stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0xb88d4fde == stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0xc6682862 00A7 14 EQ 00A8 61 PUSH2 0x06a8 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06a8, if 0xc6682862 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0xc6682862 == 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 0xa22cb465 > stack[-1] // Inputs[1] { @00B1 stack[-1] } 00B0 5B JUMPDEST 00B1 80 DUP1 00B2 63 PUSH4 0x9c70b512 00B7 14 EQ 00B8 61 PUSH2 0x0636 00BB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0636, if 0x9c70b512 == stack[-1] label_00BC: // Incoming jump from 0x00BB, if not 0x9c70b512 == stack[-1] // Inputs[1] { @00BC stack[-1] } 00BC 80 DUP1 00BD 63 PUSH4 0xa0712d68 00C2 14 EQ 00C3 61 PUSH2 0x0655 00C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0655, if 0xa0712d68 == stack[-1] label_00C7: // Incoming jump from 0x00C6, if not 0xa0712d68 == 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 0x9c70b512 > stack[-1] // Inputs[1] { @00CC stack[-1] } 00CB 5B JUMPDEST 00CC 80 DUP1 00CD 63 PUSH4 0x8b93b0f5 00D2 11 GT 00D3 61 PUSH2 0x0122 00D6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0122, if 0x8b93b0f5 > stack[-1] label_00D7: // Incoming jump from 0x00D6, if not 0x8b93b0f5 > stack[-1] // Inputs[1] { @00D7 stack[-1] } 00D7 80 DUP1 00D8 63 PUSH4 0x940f1ada 00DD 11 GT 00DE 61 PUSH2 0x0107 00E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0107, if 0x940f1ada > stack[-1] label_00E2: // Incoming jump from 0x00E1, if not 0x940f1ada > stack[-1] // Inputs[1] { @00E2 stack[-1] } 00E2 80 DUP1 00E3 63 PUSH4 0x940f1ada 00E8 14 EQ 00E9 61 PUSH2 0x05f6 00EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f6, if 0x940f1ada == stack[-1] label_00ED: // Incoming jump from 0x00EC, if not 0x940f1ada == stack[-1] // Inputs[1] { @00ED stack[-1] } 00ED 80 DUP1 00EE 63 PUSH4 0x94464eec 00F3 14 EQ 00F4 61 PUSH2 0x060c 00F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x060c, if 0x94464eec == stack[-1] label_00F8: // Incoming jump from 0x00F7, if not 0x94464eec == stack[-1] // Inputs[1] { @00F8 stack[-1] } 00F8 80 DUP1 00F9 63 PUSH4 0x95d89b41 00FE 14 EQ 00FF 61 PUSH2 0x0621 0102 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0621, if 0x95d89b41 == stack[-1] label_0103: // Incoming jump from 0x0102, if not 0x95d89b41 == 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 0x940f1ada > stack[-1] // Inputs[1] { @0108 stack[-1] } 0107 5B JUMPDEST 0108 80 DUP1 0109 63 PUSH4 0x8b93b0f5 010E 14 EQ 010F 61 PUSH2 0x05c2 0112 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c2, if 0x8b93b0f5 == stack[-1] label_0113: // Incoming jump from 0x0112, if not 0x8b93b0f5 == stack[-1] // Inputs[1] { @0113 stack[-1] } 0113 80 DUP1 0114 63 PUSH4 0x8da5cb5b 0119 14 EQ 011A 61 PUSH2 0x05d8 011D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d8, 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 0x8b93b0f5 > stack[-1] // Inputs[1] { @0123 stack[-1] } 0122 5B JUMPDEST 0123 80 DUP1 0124 63 PUSH4 0x70a08231 0129 11 GT 012A 61 PUSH2 0x0153 012D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0153, 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 0x70a08231 0134 14 EQ 0135 61 PUSH2 0x0572 0138 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0572, if 0x70a08231 == stack[-1] label_0139: // Incoming jump from 0x0138, if not 0x70a08231 == stack[-1] // Inputs[1] { @0139 stack[-1] } 0139 80 DUP1 013A 63 PUSH4 0x715018a6 013F 14 EQ 0140 61 PUSH2 0x0592 0143 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0592, if 0x715018a6 == stack[-1] label_0144: // Incoming jump from 0x0143, if not 0x715018a6 == stack[-1] // Inputs[1] { @0144 stack[-1] } 0144 80 DUP1 0145 63 PUSH4 0x8693da20 014A 14 EQ 014B 61 PUSH2 0x05a7 014E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a7, if 0x8693da20 == stack[-1] label_014F: // Incoming jump from 0x014E, if not 0x8693da20 == 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 0x012D, if 0x70a08231 > stack[-1] // Inputs[1] { @0154 stack[-1] } 0153 5B JUMPDEST 0154 80 DUP1 0155 63 PUSH4 0x6352211e 015A 14 EQ 015B 61 PUSH2 0x053d 015E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x053d, if 0x6352211e == stack[-1] label_015F: // Incoming jump from 0x015E, if not 0x6352211e == stack[-1] // Inputs[1] { @015F stack[-1] } 015F 80 DUP1 0160 63 PUSH4 0x6c0360eb 0165 14 EQ 0166 61 PUSH2 0x055d 0169 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x055d, if 0x6c0360eb == stack[-1] label_016A: // Incoming jump from 0x0169, if not 0x6c0360eb == stack[-1] // Inputs[1] { @016D memory[0x00:0x00] } 016A 60 PUSH1 0x00 016C 80 DUP1 016D FD *REVERT // Stack delta = +0 // Outputs[1] { @016D revert(memory[0x00:0x00]); } // Block terminates label_016E: // Incoming jump from 0x001D, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @016F stack[-1] } 016E 5B JUMPDEST 016F 80 DUP1 0170 63 PUSH4 0x2f745c59 0175 11 GT 0176 61 PUSH2 0x021c 0179 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x021c, if 0x2f745c59 > stack[-1] label_017A: // Incoming jump from 0x0179, if not 0x2f745c59 > stack[-1] // Inputs[1] { @017A stack[-1] } 017A 80 DUP1 017B 63 PUSH4 0x46d36211 0180 11 GT 0181 61 PUSH2 0x01d0 0184 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d0, if 0x46d36211 > stack[-1] label_0185: // Incoming jump from 0x0184, if not 0x46d36211 > stack[-1] // Inputs[1] { @0185 stack[-1] } 0185 80 DUP1 0186 63 PUSH4 0x4f6ccce7 018B 11 GT 018C 61 PUSH2 0x01b5 018F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b5, if 0x4f6ccce7 > stack[-1] label_0190: // Incoming jump from 0x018F, if not 0x4f6ccce7 > stack[-1] // Inputs[1] { @0190 stack[-1] } 0190 80 DUP1 0191 63 PUSH4 0x4f6ccce7 0196 14 EQ 0197 61 PUSH2 0x04e3 019A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e3, if 0x4f6ccce7 == stack[-1] label_019B: // Incoming jump from 0x019A, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @019B stack[-1] } 019B 80 DUP1 019C 63 PUSH4 0x55f804b3 01A1 14 EQ 01A2 61 PUSH2 0x0503 01A5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0503, 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 0x0523 01B0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0523, 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 0x018F, if 0x4f6ccce7 > stack[-1] // Inputs[1] { @01B6 stack[-1] } 01B5 5B JUMPDEST 01B6 80 DUP1 01B7 63 PUSH4 0x46d36211 01BC 14 EQ 01BD 61 PUSH2 0x04ae 01C0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ae, if 0x46d36211 == stack[-1] label_01C1: // Incoming jump from 0x01C0, if not 0x46d36211 == stack[-1] // Inputs[1] { @01C1 stack[-1] } 01C1 80 DUP1 01C2 63 PUSH4 0x4b980d67 01C7 14 EQ 01C8 61 PUSH2 0x04ce 01CB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ce, if 0x4b980d67 == stack[-1] label_01CC: // Incoming jump from 0x01CB, if not 0x4b980d67 == stack[-1] // Inputs[1] { @01CF memory[0x00:0x00] } 01CC 60 PUSH1 0x00 01CE 80 DUP1 01CF FD *REVERT // Stack delta = +0 // Outputs[1] { @01CF revert(memory[0x00:0x00]); } // Block terminates label_01D0: // Incoming jump from 0x0184, if 0x46d36211 > stack[-1] // Inputs[1] { @01D1 stack[-1] } 01D0 5B JUMPDEST 01D1 80 DUP1 01D2 63 PUSH4 0x3c952764 01D7 11 GT 01D8 61 PUSH2 0x0201 01DB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0201, if 0x3c952764 > stack[-1] label_01DC: // Incoming jump from 0x01DB, if not 0x3c952764 > stack[-1] // Inputs[1] { @01DC stack[-1] } 01DC 80 DUP1 01DD 63 PUSH4 0x3c952764 01E2 14 EQ 01E3 61 PUSH2 0x0466 01E6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0466, if 0x3c952764 == stack[-1] label_01E7: // Incoming jump from 0x01E6, if not 0x3c952764 == stack[-1] // Inputs[1] { @01E7 stack[-1] } 01E7 80 DUP1 01E8 63 PUSH4 0x3ccfd60b 01ED 14 EQ 01EE 61 PUSH2 0x0486 01F1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0486, if 0x3ccfd60b == stack[-1] label_01F2: // Incoming jump from 0x01F1, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @01F2 stack[-1] } 01F2 80 DUP1 01F3 63 PUSH4 0x42842e0e 01F8 14 EQ 01F9 61 PUSH2 0x048e 01FC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048e, if 0x42842e0e == stack[-1] label_01FD: // Incoming jump from 0x01FC, if not 0x42842e0e == 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 0x01DB, if 0x3c952764 > stack[-1] // Inputs[1] { @0202 stack[-1] } 0201 5B JUMPDEST 0202 80 DUP1 0203 63 PUSH4 0x2f745c59 0208 14 EQ 0209 61 PUSH2 0x0430 020C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0430, if 0x2f745c59 == stack[-1] label_020D: // Incoming jump from 0x020C, if not 0x2f745c59 == stack[-1] // Inputs[1] { @020D stack[-1] } 020D 80 DUP1 020E 63 PUSH4 0x30621147 0213 14 EQ 0214 61 PUSH2 0x0450 0217 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0450, if 0x30621147 == stack[-1] label_0218: // Incoming jump from 0x0217, if not 0x30621147 == stack[-1] // Inputs[1] { @021B memory[0x00:0x00] } 0218 60 PUSH1 0x00 021A 80 DUP1 021B FD *REVERT // Stack delta = +0 // Outputs[1] { @021B revert(memory[0x00:0x00]); } // Block terminates label_021C: // Incoming jump from 0x0179, if 0x2f745c59 > stack[-1] // Inputs[1] { @021D stack[-1] } 021C 5B JUMPDEST 021D 80 DUP1 021E 63 PUSH4 0x18160ddd 0223 11 GT 0224 61 PUSH2 0x0273 0227 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0273, if 0x18160ddd > stack[-1] label_0228: // Incoming jump from 0x0227, if not 0x18160ddd > stack[-1] // Inputs[1] { @0228 stack[-1] } 0228 80 DUP1 0229 63 PUSH4 0x26a74d8e 022E 11 GT 022F 61 PUSH2 0x0258 0232 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0258, if 0x26a74d8e > stack[-1] label_0233: // Incoming jump from 0x0232, if not 0x26a74d8e > stack[-1] // Inputs[1] { @0233 stack[-1] } 0233 80 DUP1 0234 63 PUSH4 0x26a74d8e 0239 14 EQ 023A 61 PUSH2 0x03d0 023D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d0, if 0x26a74d8e == stack[-1] label_023E: // Incoming jump from 0x023D, if not 0x26a74d8e == stack[-1] // Inputs[1] { @023E stack[-1] } 023E 80 DUP1 023F 63 PUSH4 0x2ab4d052 0244 14 EQ 0245 61 PUSH2 0x03e6 0248 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e6, if 0x2ab4d052 == stack[-1] label_0249: // Incoming jump from 0x0248, if not 0x2ab4d052 == stack[-1] // Inputs[1] { @0249 stack[-1] } 0249 80 DUP1 024A 63 PUSH4 0x2eb4a7ab 024F 14 EQ 0250 61 PUSH2 0x03fc 0253 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03fc, if 0x2eb4a7ab == stack[-1] label_0254: // Incoming jump from 0x0253, if not 0x2eb4a7ab == 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 0x0232, if 0x26a74d8e > stack[-1] // Inputs[1] { @0259 stack[-1] } 0258 5B JUMPDEST 0259 80 DUP1 025A 63 PUSH4 0x18160ddd 025F 14 EQ 0260 61 PUSH2 0x0391 0263 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0391, if 0x18160ddd == stack[-1] label_0264: // Incoming jump from 0x0263, if not 0x18160ddd == stack[-1] // Inputs[1] { @0264 stack[-1] } 0264 80 DUP1 0265 63 PUSH4 0x23b872dd 026A 14 EQ 026B 61 PUSH2 0x03b0 026E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b0, if 0x23b872dd == stack[-1] label_026F: // Incoming jump from 0x026E, if not 0x23b872dd == stack[-1] // Inputs[1] { @0272 memory[0x00:0x00] } 026F 60 PUSH1 0x00 0271 80 DUP1 0272 FD *REVERT // Stack delta = +0 // Outputs[1] { @0272 revert(memory[0x00:0x00]); } // Block terminates label_0273: // Incoming jump from 0x0227, if 0x18160ddd > stack[-1] // Inputs[1] { @0274 stack[-1] } 0273 5B JUMPDEST 0274 80 DUP1 0275 63 PUSH4 0x081812fc 027A 11 GT 027B 61 PUSH2 0x02a4 027E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a4, if 0x081812fc > stack[-1] label_027F: // Incoming jump from 0x027E, if not 0x081812fc > stack[-1] // Inputs[1] { @027F stack[-1] } 027F 80 DUP1 0280 63 PUSH4 0x081812fc 0285 14 EQ 0286 61 PUSH2 0x0317 0289 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0317, if 0x081812fc == stack[-1] label_028A: // Incoming jump from 0x0289, if not 0x081812fc == stack[-1] // Inputs[1] { @028A stack[-1] } 028A 80 DUP1 028B 63 PUSH4 0x095ea7b3 0290 14 EQ 0291 61 PUSH2 0x034f 0294 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x034f, if 0x095ea7b3 == stack[-1] label_0295: // Incoming jump from 0x0294, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0295 stack[-1] } 0295 80 DUP1 0296 63 PUSH4 0x16c38b3c 029B 14 EQ 029C 61 PUSH2 0x0371 029F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0371, if 0x16c38b3c == stack[-1] label_02A0: // Incoming jump from 0x029F, if not 0x16c38b3c == stack[-1] // Inputs[1] { @02A3 memory[0x00:0x00] } 02A0 60 PUSH1 0x00 02A2 80 DUP1 02A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @02A3 revert(memory[0x00:0x00]); } // Block terminates label_02A4: // Incoming jump from 0x027E, if 0x081812fc > stack[-1] // Inputs[1] { @02A5 stack[-1] } 02A4 5B JUMPDEST 02A5 80 DUP1 02A6 63 PUSH4 0x01ffc9a7 02AB 14 EQ 02AC 61 PUSH2 0x02c0 02AF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c0, if 0x01ffc9a7 == stack[-1] label_02B0: // Incoming jump from 0x02AF, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @02B0 stack[-1] } 02B0 80 DUP1 02B1 63 PUSH4 0x06fdde03 02B6 14 EQ 02B7 61 PUSH2 0x02f5 02BA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f5, if 0x06fdde03 == stack[-1] label_02BB: // Incoming jump from 0x02BA, if not 0x06fdde03 == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @02BF memory[0x00:0x00] } 02BB 5B JUMPDEST 02BC 60 PUSH1 0x00 02BE 80 DUP1 02BF FD *REVERT // Stack delta = +0 // Outputs[1] { @02BF revert(memory[0x00:0x00]); } // Block terminates label_02C0: // Incoming jump from 0x02AF, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @02C1 msg.value } 02C0 5B JUMPDEST 02C1 34 CALLVALUE 02C2 80 DUP1 02C3 15 ISZERO 02C4 61 PUSH2 0x02cc 02C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C1 stack[0] = msg.value } // Block ends with conditional jump to 0x02cc, if !msg.value label_02C8: // Incoming jump from 0x02C7, if not !msg.value // Inputs[1] { @02CB memory[0x00:0x00] } 02C8 60 PUSH1 0x00 02CA 80 DUP1 02CB FD *REVERT // Stack delta = +0 // Outputs[1] { @02CB revert(memory[0x00:0x00]); } // Block terminates label_02CC: // Incoming jump from 0x02C7, if !msg.value // Inputs[1] { @02D4 msg.data.length } 02CC 5B JUMPDEST 02CD 50 POP 02CE 61 PUSH2 0x02e0 02D1 61 PUSH2 0x02db 02D4 36 CALLDATASIZE 02D5 60 PUSH1 0x04 02D7 61 PUSH2 0x2a44 02DA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02CE stack[-1] = 0x02e0 // @02D1 stack[0] = 0x02db // @02D4 stack[1] = msg.data.length // @02D5 stack[2] = 0x04 // } // Block ends with call to 0x2a44, returns to 0x02DB label_02DB: // Incoming return from call to 0x2A44 at 0x02DA 02DB 5B JUMPDEST 02DC 61 PUSH2 0x0790 02DF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0790 label_02E0: // Incoming jump from 0x053C // Incoming return from call to 0x0742 at 0x0741 // Incoming return from call to 0x02DB at 0x02DA // Incoming jump from 0x0654 // Inputs[4] // { // @02E3 memory[0x40:0x60] // @02E4 stack[-1] // @02EF memory[0x40:0x60] // @02F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02E0 5B JUMPDEST 02E1 60 PUSH1 0x40 02E3 51 MLOAD 02E4 90 SWAP1 02E5 15 ISZERO 02E6 15 ISZERO 02E7 81 DUP2 02E8 52 MSTORE 02E9 60 PUSH1 0x20 02EB 01 ADD 02EC 5B JUMPDEST 02ED 60 PUSH1 0x40 02EF 51 MLOAD 02F0 80 DUP1 02F1 91 SWAP2 02F2 03 SUB 02F3 90 SWAP1 02F4 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @02F4 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02F5: // Incoming jump from 0x02BA, if 0x06fdde03 == stack[-1] // Inputs[1] { @02F6 msg.value } 02F5 5B JUMPDEST 02F6 34 CALLVALUE 02F7 80 DUP1 02F8 15 ISZERO 02F9 61 PUSH2 0x0301 02FC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F6 stack[0] = msg.value } // Block ends with conditional jump to 0x0301, if !msg.value label_02FD: // Incoming jump from 0x02FC, if not !msg.value // Inputs[1] { @0300 memory[0x00:0x00] } 02FD 60 PUSH1 0x00 02FF 80 DUP1 0300 FD *REVERT // Stack delta = +0 // Outputs[1] { @0300 revert(memory[0x00:0x00]); } // Block terminates label_0301: // Incoming jump from 0x02FC, if !msg.value 0301 5B JUMPDEST 0302 50 POP 0303 61 PUSH2 0x030a 0306 61 PUSH2 0x07d4 0309 56 *JUMP // Stack delta = +0 // Outputs[1] { @0303 stack[-1] = 0x030a } // Block ends with call to 0x07d4, returns to 0x030A label_030A: // Incoming jump from 0x06D8 // Incoming return from call to 0x07D4 at 0x0309 // Incoming return from call to 0x06F4 at 0x06F3 // Incoming return from call to 0x103A at 0x0571 // Incoming return from call to 0x11E4 at 0x0635 // Incoming return from call to 0x11C8 at 0x0620 // Inputs[2] // { // @030D memory[0x40:0x60] // @0311 stack[-1] // } 030A 5B JUMPDEST 030B 60 PUSH1 0x40 030D 51 MLOAD 030E 61 PUSH2 0x02ec 0311 91 SWAP2 0312 90 SWAP1 0313 61 PUSH2 0x2c57 0316 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0311 stack[-1] = 0x02ec // @0312 stack[1] = memory[0x40:0x60] // @0312 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2c57 label_0317: // Incoming jump from 0x0289, if 0x081812fc == stack[-1] // Inputs[1] { @0318 msg.value } 0317 5B JUMPDEST 0318 34 CALLVALUE 0319 80 DUP1 031A 15 ISZERO 031B 61 PUSH2 0x0323 031E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0318 stack[0] = msg.value } // Block ends with conditional jump to 0x0323, if !msg.value label_031F: // Incoming jump from 0x031E, if not !msg.value // Inputs[1] { @0322 memory[0x00:0x00] } 031F 60 PUSH1 0x00 0321 80 DUP1 0322 FD *REVERT // Stack delta = +0 // Outputs[1] { @0322 revert(memory[0x00:0x00]); } // Block terminates label_0323: // Incoming jump from 0x031E, if !msg.value // Inputs[1] { @032B msg.data.length } 0323 5B JUMPDEST 0324 50 POP 0325 61 PUSH2 0x0337 0328 61 PUSH2 0x0332 032B 36 CALLDATASIZE 032C 60 PUSH1 0x04 032E 61 PUSH2 0x2ac7 0331 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0325 stack[-1] = 0x0337 // @0328 stack[0] = 0x0332 // @032B stack[1] = msg.data.length // @032C stack[2] = 0x04 // } // Block ends with call to 0x2ac7, returns to 0x0332 label_0332: // Incoming return from call to 0x2AC7 at 0x0331 0332 5B JUMPDEST 0333 61 PUSH2 0x0866 0336 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0866 label_0337: // Incoming return from call to 0x0558 at 0x0557 // Incoming jump from 0x05F5 // Incoming return from call to 0x0332 at 0x0331 // Inputs[2] // { // @033A memory[0x40:0x60] // @0344 stack[-1] // } 0337 5B JUMPDEST 0338 60 PUSH1 0x40 033A 51 MLOAD 033B 60 PUSH1 0x01 033D 60 PUSH1 0x01 033F 60 PUSH1 0xa0 0341 1B SHL 0342 03 SUB 0343 90 SWAP1 0344 91 SWAP2 0345 16 AND 0346 81 DUP2 0347 52 MSTORE 0348 60 PUSH1 0x20 034A 01 ADD 034B 61 PUSH2 0x02ec 034E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0347 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @034A stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02ec label_034F: // Incoming jump from 0x0294, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0350 msg.value } 034F 5B JUMPDEST 0350 34 CALLVALUE 0351 80 DUP1 0352 15 ISZERO 0353 61 PUSH2 0x035b 0356 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0350 stack[0] = msg.value } // Block ends with conditional jump to 0x035b, if !msg.value label_0357: // Incoming jump from 0x0356, if not !msg.value // Inputs[1] { @035A memory[0x00:0x00] } 0357 60 PUSH1 0x00 0359 80 DUP1 035A FD *REVERT // Stack delta = +0 // Outputs[1] { @035A revert(memory[0x00:0x00]); } // Block terminates label_035B: // Incoming jump from 0x0356, if !msg.value // Inputs[1] { @0363 msg.data.length } 035B 5B JUMPDEST 035C 50 POP 035D 61 PUSH2 0x036f 0360 61 PUSH2 0x036a 0363 36 CALLDATASIZE 0364 60 PUSH1 0x04 0366 61 PUSH2 0x29bd 0369 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @035D stack[-1] = 0x036f // @0360 stack[0] = 0x036a // @0363 stack[1] = msg.data.length // @0364 stack[2] = 0x04 // } // Block ends with call to 0x29bd, returns to 0x036A label_036A: // Incoming return from call to 0x29BD at 0x0369 036A 5B JUMPDEST 036B 61 PUSH2 0x0911 036E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0911 label_036F: // Incoming return from call to 0x036A at 0x0369 // Incoming return from call to 0x03CB at 0x03CA // Incoming return from call to 0x0C53 at 0x048D // Incoming return from call to 0x1162 at 0x05A6 // Incoming return from call to 0x0481 at 0x0480 // Incoming return from call to 0x0663 at 0x0662 // Incoming return from call to 0x038C at 0x038B // Incoming return from call to 0x0683 at 0x0682 // Incoming return from call to 0x04C9 at 0x04C8 // Incoming return from call to 0x0707 at 0x0706 036F 5B JUMPDEST 0370 00 *STOP // Stack delta = +0 // Outputs[1] { @0370 stop(); } // Block terminates label_0371: // Incoming jump from 0x029F, if 0x16c38b3c == stack[-1] // Inputs[1] { @0372 msg.value } 0371 5B JUMPDEST 0372 34 CALLVALUE 0373 80 DUP1 0374 15 ISZERO 0375 61 PUSH2 0x037d 0378 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0372 stack[0] = msg.value } // Block ends with conditional jump to 0x037d, if !msg.value label_0379: // Incoming jump from 0x0378, if not !msg.value // Inputs[1] { @037C memory[0x00:0x00] } 0379 60 PUSH1 0x00 037B 80 DUP1 037C FD *REVERT // Stack delta = +0 // Outputs[1] { @037C revert(memory[0x00:0x00]); } // Block terminates label_037D: // Incoming jump from 0x0378, if !msg.value // Inputs[1] { @0385 msg.data.length } 037D 5B JUMPDEST 037E 50 POP 037F 61 PUSH2 0x036f 0382 61 PUSH2 0x038c 0385 36 CALLDATASIZE 0386 60 PUSH1 0x04 0388 61 PUSH2 0x2a29 038B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @037F stack[-1] = 0x036f // @0382 stack[0] = 0x038c // @0385 stack[1] = msg.data.length // @0386 stack[2] = 0x04 // } // Block ends with call to 0x2a29, returns to 0x038C label_038C: // Incoming return from call to 0x2A29 at 0x038B 038C 5B JUMPDEST 038D 61 PUSH2 0x0a43 0390 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a43 label_0391: // Incoming jump from 0x0263, if 0x18160ddd == stack[-1] // Inputs[1] { @0392 msg.value } 0391 5B JUMPDEST 0392 34 CALLVALUE 0393 80 DUP1 0394 15 ISZERO 0395 61 PUSH2 0x039d 0398 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0392 stack[0] = msg.value } // Block ends with conditional jump to 0x039d, if !msg.value label_0399: // Incoming jump from 0x0398, if not !msg.value // Inputs[1] { @039C memory[0x00:0x00] } 0399 60 PUSH1 0x00 039B 80 DUP1 039C FD *REVERT // Stack delta = +0 // Outputs[1] { @039C revert(memory[0x00:0x00]); } // Block terminates label_039D: // Incoming jump from 0x0398, if !msg.value // Inputs[1] { @03A1 storage[0x08] } 039D 5B JUMPDEST 039E 50 POP 039F 60 PUSH1 0x08 03A1 54 SLOAD // Stack delta = +0 // Outputs[1] { @03A1 stack[-1] = storage[0x08] } // Block continues label_03A2: // Incoming jump from 0x03FB // Incoming jump from 0x060B // Incoming return from call to 0x04FE at 0x04FD // Incoming jump from 0x04E2 // Incoming return from call to 0x058D at 0x058C // Incoming jump from 0x0465 // Incoming jump from 0x05C1 // Incoming jump from 0x0726 // Incoming jump from 0x03A1 // Incoming return from call to 0x044B at 0x044A // Incoming jump from 0x03E5 // Incoming jump from 0x042F // Incoming jump from 0x05D7 // Inputs[2] // { // @03A5 memory[0x40:0x60] // @03A6 stack[-1] // } 03A2 5B JUMPDEST 03A3 60 PUSH1 0x40 03A5 51 MLOAD 03A6 90 SWAP1 03A7 81 DUP2 03A8 52 MSTORE 03A9 60 PUSH1 0x20 03AB 01 ADD 03AC 61 PUSH2 0x02ec 03AF 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @03AB stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02ec label_03B0: // Incoming jump from 0x026E, if 0x23b872dd == stack[-1] // Inputs[1] { @03B1 msg.value } 03B0 5B JUMPDEST 03B1 34 CALLVALUE 03B2 80 DUP1 03B3 15 ISZERO 03B4 61 PUSH2 0x03bc 03B7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03B1 stack[0] = msg.value } // Block ends with conditional jump to 0x03bc, if !msg.value label_03B8: // Incoming jump from 0x03B7, if not !msg.value // Inputs[1] { @03BB memory[0x00:0x00] } 03B8 60 PUSH1 0x00 03BA 80 DUP1 03BB FD *REVERT // Stack delta = +0 // Outputs[1] { @03BB revert(memory[0x00:0x00]); } // Block terminates label_03BC: // Incoming jump from 0x03B7, if !msg.value // Inputs[1] { @03C4 msg.data.length } 03BC 5B JUMPDEST 03BD 50 POP 03BE 61 PUSH2 0x036f 03C1 61 PUSH2 0x03cb 03C4 36 CALLDATASIZE 03C5 60 PUSH1 0x04 03C7 61 PUSH2 0x28db 03CA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03BE stack[-1] = 0x036f // @03C1 stack[0] = 0x03cb // @03C4 stack[1] = msg.data.length // @03C5 stack[2] = 0x04 // } // Block ends with call to 0x28db, returns to 0x03CB label_03CB: // Incoming return from call to 0x28DB at 0x03CA 03CB 5B JUMPDEST 03CC 61 PUSH2 0x0ab0 03CF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ab0 label_03D0: // Incoming jump from 0x023D, if 0x26a74d8e == stack[-1] // Inputs[1] { @03D1 msg.value } 03D0 5B JUMPDEST 03D1 34 CALLVALUE 03D2 80 DUP1 03D3 15 ISZERO 03D4 61 PUSH2 0x03dc 03D7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03D1 stack[0] = msg.value } // Block ends with conditional jump to 0x03dc, if !msg.value label_03D8: // Incoming jump from 0x03D7, if not !msg.value // Inputs[1] { @03DB memory[0x00:0x00] } 03D8 60 PUSH1 0x00 03DA 80 DUP1 03DB FD *REVERT // Stack delta = +0 // Outputs[1] { @03DB revert(memory[0x00:0x00]); } // Block terminates label_03DC: // Incoming jump from 0x03D7, if !msg.value 03DC 5B JUMPDEST 03DD 50 POP 03DE 61 PUSH2 0x03a2 03E1 61 PUSH2 0x0457 03E4 81 DUP2 03E5 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03DE stack[-1] = 0x03a2 // @03E1 stack[0] = 0x0457 // } // Block ends with unconditional jump to 0x03a2 label_03E6: // Incoming jump from 0x0248, if 0x2ab4d052 == stack[-1] // Inputs[1] { @03E7 msg.value } 03E6 5B JUMPDEST 03E7 34 CALLVALUE 03E8 80 DUP1 03E9 15 ISZERO 03EA 61 PUSH2 0x03f2 03ED 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E7 stack[0] = msg.value } // Block ends with conditional jump to 0x03f2, if !msg.value label_03EE: // Incoming jump from 0x03ED, if not !msg.value // Inputs[1] { @03F1 memory[0x00:0x00] } 03EE 60 PUSH1 0x00 03F0 80 DUP1 03F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F1 revert(memory[0x00:0x00]); } // Block terminates label_03F2: // Incoming jump from 0x03ED, if !msg.value 03F2 5B JUMPDEST 03F3 50 POP 03F4 61 PUSH2 0x03a2 03F7 61 PUSH2 0x05dd 03FA 81 DUP2 03FB 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03F4 stack[-1] = 0x03a2 // @03F7 stack[0] = 0x05dd // } // Block ends with unconditional jump to 0x03a2 label_03FC: // Incoming jump from 0x0253, if 0x2eb4a7ab == stack[-1] // Inputs[1] { @03FD msg.value } 03FC 5B JUMPDEST 03FD 34 CALLVALUE 03FE 80 DUP1 03FF 15 ISZERO 0400 61 PUSH2 0x0408 0403 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03FD stack[0] = msg.value } // Block ends with conditional jump to 0x0408, if !msg.value label_0404: // Incoming jump from 0x0403, if not !msg.value // Inputs[1] { @0407 memory[0x00:0x00] } 0404 60 PUSH1 0x00 0406 80 DUP1 0407 FD *REVERT // Stack delta = +0 // Outputs[1] { @0407 revert(memory[0x00:0x00]); } // Block terminates label_0408: // Incoming jump from 0x0403, if !msg.value 0408 5B JUMPDEST 0409 50 POP 040A 61 PUSH2 0x03a2 040D 7F PUSH32 0x1c59172521baca45ea5b482a6849c951386a295e51a04b71cd09dd1a515fe8dc 042E 81 DUP2 042F 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @040A stack[-1] = 0x03a2 // @040D stack[0] = 0x1c59172521baca45ea5b482a6849c951386a295e51a04b71cd09dd1a515fe8dc // } // Block ends with unconditional jump to 0x03a2 label_0430: // Incoming jump from 0x020C, if 0x2f745c59 == stack[-1] // Inputs[1] { @0431 msg.value } 0430 5B JUMPDEST 0431 34 CALLVALUE 0432 80 DUP1 0433 15 ISZERO 0434 61 PUSH2 0x043c 0437 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0431 stack[0] = msg.value } // Block ends with conditional jump to 0x043c, if !msg.value label_0438: // Incoming jump from 0x0437, if not !msg.value // Inputs[1] { @043B memory[0x00:0x00] } 0438 60 PUSH1 0x00 043A 80 DUP1 043B FD *REVERT // Stack delta = +0 // Outputs[1] { @043B revert(memory[0x00:0x00]); } // Block terminates label_043C: // Incoming jump from 0x0437, if !msg.value // Inputs[1] { @0444 msg.data.length } 043C 5B JUMPDEST 043D 50 POP 043E 61 PUSH2 0x03a2 0441 61 PUSH2 0x044b 0444 36 CALLDATASIZE 0445 60 PUSH1 0x04 0447 61 PUSH2 0x29bd 044A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @043E stack[-1] = 0x03a2 // @0441 stack[0] = 0x044b // @0444 stack[1] = msg.data.length // @0445 stack[2] = 0x04 // } // Block ends with call to 0x29bd, returns to 0x044B label_044B: // Incoming return from call to 0x29BD at 0x044A 044B 5B JUMPDEST 044C 61 PUSH2 0x0b37 044F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b37 label_0450: // Incoming jump from 0x0217, if 0x30621147 == stack[-1] // Inputs[1] { @0451 msg.value } 0450 5B JUMPDEST 0451 34 CALLVALUE 0452 80 DUP1 0453 15 ISZERO 0454 61 PUSH2 0x045c 0457 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0451 stack[0] = msg.value } // Block ends with conditional jump to 0x045c, if !msg.value label_0458: // Incoming jump from 0x0457, if not !msg.value // Inputs[1] { @045B memory[0x00:0x00] } 0458 60 PUSH1 0x00 045A 80 DUP1 045B FD *REVERT // Stack delta = +0 // Outputs[1] { @045B revert(memory[0x00:0x00]); } // Block terminates label_045C: // Incoming jump from 0x0457, if !msg.value // Inputs[1] { @0463 storage[0x0c] } 045C 5B JUMPDEST 045D 50 POP 045E 61 PUSH2 0x03a2 0461 60 PUSH1 0x0c 0463 54 SLOAD 0464 81 DUP2 0465 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @045E stack[-1] = 0x03a2 // @0463 stack[0] = storage[0x0c] // } // Block ends with unconditional jump to 0x03a2 label_0466: // Incoming jump from 0x01E6, if 0x3c952764 == stack[-1] // Inputs[1] { @0467 msg.value } 0466 5B JUMPDEST 0467 34 CALLVALUE 0468 80 DUP1 0469 15 ISZERO 046A 61 PUSH2 0x0472 046D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0467 stack[0] = msg.value } // Block ends with conditional jump to 0x0472, if !msg.value label_046E: // Incoming jump from 0x046D, if not !msg.value // Inputs[1] { @0471 memory[0x00:0x00] } 046E 60 PUSH1 0x00 0470 80 DUP1 0471 FD *REVERT // Stack delta = +0 // Outputs[1] { @0471 revert(memory[0x00:0x00]); } // Block terminates label_0472: // Incoming jump from 0x046D, if !msg.value // Inputs[1] { @047A msg.data.length } 0472 5B JUMPDEST 0473 50 POP 0474 61 PUSH2 0x036f 0477 61 PUSH2 0x0481 047A 36 CALLDATASIZE 047B 60 PUSH1 0x04 047D 61 PUSH2 0x2a29 0480 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0474 stack[-1] = 0x036f // @0477 stack[0] = 0x0481 // @047A stack[1] = msg.data.length // @047B stack[2] = 0x04 // } // Block ends with call to 0x2a29, returns to 0x0481 label_0481: // Incoming return from call to 0x2A29 at 0x0480 0481 5B JUMPDEST 0482 61 PUSH2 0x0bdf 0485 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bdf label_0486: // Incoming jump from 0x01F1, if 0x3ccfd60b == stack[-1] 0486 5B JUMPDEST 0487 61 PUSH2 0x036f 048A 61 PUSH2 0x0c53 048D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0487 stack[0] = 0x036f } // Block ends with call to 0x0c53, returns to 0x036F label_048E: // Incoming jump from 0x01FC, if 0x42842e0e == stack[-1] // Inputs[1] { @048F msg.value } 048E 5B JUMPDEST 048F 34 CALLVALUE 0490 80 DUP1 0491 15 ISZERO 0492 61 PUSH2 0x049a 0495 57 *JUMPI // Stack delta = +1 // Outputs[1] { @048F stack[0] = msg.value } // Block ends with conditional jump to 0x049a, if !msg.value label_0496: // Incoming jump from 0x0495, if not !msg.value // Inputs[1] { @0499 memory[0x00:0x00] } 0496 60 PUSH1 0x00 0498 80 DUP1 0499 FD *REVERT // Stack delta = +0 // Outputs[1] { @0499 revert(memory[0x00:0x00]); } // Block terminates label_049A: // Incoming jump from 0x0495, if !msg.value // Inputs[1] { @04A2 msg.data.length } 049A 5B JUMPDEST 049B 50 POP 049C 61 PUSH2 0x036f 049F 61 PUSH2 0x04a9 04A2 36 CALLDATASIZE 04A3 60 PUSH1 0x04 04A5 61 PUSH2 0x28db 04A8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @049C stack[-1] = 0x036f // @049F stack[0] = 0x04a9 // @04A2 stack[1] = msg.data.length // @04A3 stack[2] = 0x04 // } // Block ends with call to 0x28db, returns to 0x04A9 label_04A9: // Incoming return from call to 0x28DB at 0x04A8 04A9 5B JUMPDEST 04AA 61 PUSH2 0x0d05 04AD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d05 label_04AE: // Incoming jump from 0x01C0, if 0x46d36211 == stack[-1] // Inputs[1] { @04AF msg.value } 04AE 5B JUMPDEST 04AF 34 CALLVALUE 04B0 80 DUP1 04B1 15 ISZERO 04B2 61 PUSH2 0x04ba 04B5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04AF stack[0] = msg.value } // Block ends with conditional jump to 0x04ba, if !msg.value label_04B6: // Incoming jump from 0x04B5, if not !msg.value // Inputs[1] { @04B9 memory[0x00:0x00] } 04B6 60 PUSH1 0x00 04B8 80 DUP1 04B9 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B9 revert(memory[0x00:0x00]); } // Block terminates label_04BA: // Incoming jump from 0x04B5, if !msg.value // Inputs[1] { @04C2 msg.data.length } 04BA 5B JUMPDEST 04BB 50 POP 04BC 61 PUSH2 0x036f 04BF 61 PUSH2 0x04c9 04C2 36 CALLDATASIZE 04C3 60 PUSH1 0x04 04C5 61 PUSH2 0x29e7 04C8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04BC stack[-1] = 0x036f // @04BF stack[0] = 0x04c9 // @04C2 stack[1] = msg.data.length // @04C3 stack[2] = 0x04 // } // Block ends with call to 0x29e7, returns to 0x04C9 label_04C9: // Incoming return from call to 0x29E7 at 0x04C8 04C9 5B JUMPDEST 04CA 61 PUSH2 0x0d20 04CD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d20 label_04CE: // Incoming jump from 0x01CB, if 0x4b980d67 == stack[-1] // Inputs[1] { @04CF msg.value } 04CE 5B JUMPDEST 04CF 34 CALLVALUE 04D0 80 DUP1 04D1 15 ISZERO 04D2 61 PUSH2 0x04da 04D5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04CF stack[0] = msg.value } // Block ends with conditional jump to 0x04da, if !msg.value label_04D6: // Incoming jump from 0x04D5, if not !msg.value // Inputs[1] { @04D9 memory[0x00:0x00] } 04D6 60 PUSH1 0x00 04D8 80 DUP1 04D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D9 revert(memory[0x00:0x00]); } // Block terminates label_04DA: // Incoming jump from 0x04D5, if !msg.value 04DA 5B JUMPDEST 04DB 50 POP 04DC 61 PUSH2 0x03a2 04DF 60 PUSH1 0x0a 04E1 81 DUP2 04E2 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04DC stack[-1] = 0x03a2 // @04DF stack[0] = 0x0a // } // Block ends with unconditional jump to 0x03a2 label_04E3: // Incoming jump from 0x019A, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @04E4 msg.value } 04E3 5B JUMPDEST 04E4 34 CALLVALUE 04E5 80 DUP1 04E6 15 ISZERO 04E7 61 PUSH2 0x04ef 04EA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04E4 stack[0] = msg.value } // Block ends with conditional jump to 0x04ef, if !msg.value label_04EB: // Incoming jump from 0x04EA, if not !msg.value // Inputs[1] { @04EE memory[0x00:0x00] } 04EB 60 PUSH1 0x00 04ED 80 DUP1 04EE FD *REVERT // Stack delta = +0 // Outputs[1] { @04EE revert(memory[0x00:0x00]); } // Block terminates label_04EF: // Incoming jump from 0x04EA, if !msg.value // Inputs[1] { @04F7 msg.data.length } 04EF 5B JUMPDEST 04F0 50 POP 04F1 61 PUSH2 0x03a2 04F4 61 PUSH2 0x04fe 04F7 36 CALLDATASIZE 04F8 60 PUSH1 0x04 04FA 61 PUSH2 0x2ac7 04FD 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04F1 stack[-1] = 0x03a2 // @04F4 stack[0] = 0x04fe // @04F7 stack[1] = msg.data.length // @04F8 stack[2] = 0x04 // } // Block ends with call to 0x2ac7, returns to 0x04FE label_04FE: // Incoming return from call to 0x2AC7 at 0x04FD 04FE 5B JUMPDEST 04FF 61 PUSH2 0x0e9a 0502 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e9a label_0503: // Incoming jump from 0x01A5, if 0x55f804b3 == stack[-1] // Inputs[1] { @0504 msg.value } 0503 5B JUMPDEST 0504 34 CALLVALUE 0505 80 DUP1 0506 15 ISZERO 0507 61 PUSH2 0x050f 050A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0504 stack[0] = msg.value } // Block ends with conditional jump to 0x050f, if !msg.value label_050B: // Incoming jump from 0x050A, if not !msg.value // Inputs[1] { @050E memory[0x00:0x00] } 050B 60 PUSH1 0x00 050D 80 DUP1 050E FD *REVERT // Stack delta = +0 // Outputs[1] { @050E revert(memory[0x00:0x00]); } // Block terminates label_050F: // Incoming jump from 0x050A, if !msg.value // Inputs[1] { @0517 msg.data.length } 050F 5B JUMPDEST 0510 50 POP 0511 61 PUSH2 0x036f 0514 61 PUSH2 0x051e 0517 36 CALLDATASIZE 0518 60 PUSH1 0x04 051A 61 PUSH2 0x2a7e 051D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0511 stack[-1] = 0x036f // @0514 stack[0] = 0x051e // @0517 stack[1] = msg.data.length // @0518 stack[2] = 0x04 // } // Block ends with call to 0x2a7e, returns to 0x051E label_051E: // Incoming return from call to 0x2A7E at 0x051D 051E 5B JUMPDEST 051F 61 PUSH2 0x0f3e 0522 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f3e label_0523: // Incoming jump from 0x01B0, if 0x5c975abb == stack[-1] // Inputs[1] { @0524 msg.value } 0523 5B JUMPDEST 0524 34 CALLVALUE 0525 80 DUP1 0526 15 ISZERO 0527 61 PUSH2 0x052f 052A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0524 stack[0] = msg.value } // Block ends with conditional jump to 0x052f, if !msg.value label_052B: // Incoming jump from 0x052A, if not !msg.value // Inputs[1] { @052E memory[0x00:0x00] } 052B 60 PUSH1 0x00 052D 80 DUP1 052E FD *REVERT // Stack delta = +0 // Outputs[1] { @052E revert(memory[0x00:0x00]); } // Block terminates label_052F: // Incoming jump from 0x052A, if !msg.value // Inputs[1] { @0533 storage[0x0e] } 052F 5B JUMPDEST 0530 50 POP 0531 60 PUSH1 0x0e 0533 54 SLOAD 0534 61 PUSH2 0x02e0 0537 90 SWAP1 0538 60 PUSH1 0xff 053A 16 AND 053B 81 DUP2 053C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0537 stack[-1] = 0x02e0 // @053A stack[0] = 0xff & storage[0x0e] // } // Block ends with unconditional jump to 0x02e0 label_053D: // Incoming jump from 0x015E, if 0x6352211e == stack[-1] // Inputs[1] { @053E msg.value } 053D 5B JUMPDEST 053E 34 CALLVALUE 053F 80 DUP1 0540 15 ISZERO 0541 61 PUSH2 0x0549 0544 57 *JUMPI // Stack delta = +1 // Outputs[1] { @053E stack[0] = msg.value } // Block ends with conditional jump to 0x0549, if !msg.value label_0545: // Incoming jump from 0x0544, if not !msg.value // Inputs[1] { @0548 memory[0x00:0x00] } 0545 60 PUSH1 0x00 0547 80 DUP1 0548 FD *REVERT // Stack delta = +0 // Outputs[1] { @0548 revert(memory[0x00:0x00]); } // Block terminates label_0549: // Incoming jump from 0x0544, if !msg.value // Inputs[1] { @0551 msg.data.length } 0549 5B JUMPDEST 054A 50 POP 054B 61 PUSH2 0x0337 054E 61 PUSH2 0x0558 0551 36 CALLDATASIZE 0552 60 PUSH1 0x04 0554 61 PUSH2 0x2ac7 0557 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @054B stack[-1] = 0x0337 // @054E stack[0] = 0x0558 // @0551 stack[1] = msg.data.length // @0552 stack[2] = 0x04 // } // Block ends with call to 0x2ac7, returns to 0x0558 label_0558: // Incoming return from call to 0x2AC7 at 0x0557 0558 5B JUMPDEST 0559 61 PUSH2 0x0faf 055C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0faf label_055D: // Incoming jump from 0x0169, if 0x6c0360eb == stack[-1] // Inputs[1] { @055E msg.value } 055D 5B JUMPDEST 055E 34 CALLVALUE 055F 80 DUP1 0560 15 ISZERO 0561 61 PUSH2 0x0569 0564 57 *JUMPI // Stack delta = +1 // Outputs[1] { @055E stack[0] = msg.value } // Block ends with conditional jump to 0x0569, if !msg.value label_0565: // Incoming jump from 0x0564, if not !msg.value // Inputs[1] { @0568 memory[0x00:0x00] } 0565 60 PUSH1 0x00 0567 80 DUP1 0568 FD *REVERT // Stack delta = +0 // Outputs[1] { @0568 revert(memory[0x00:0x00]); } // Block terminates label_0569: // Incoming jump from 0x0564, if !msg.value 0569 5B JUMPDEST 056A 50 POP 056B 61 PUSH2 0x030a 056E 61 PUSH2 0x103a 0571 56 *JUMP // Stack delta = +0 // Outputs[1] { @056B stack[-1] = 0x030a } // Block ends with call to 0x103a, returns to 0x030A label_0572: // Incoming jump from 0x0138, if 0x70a08231 == stack[-1] // Inputs[1] { @0573 msg.value } 0572 5B JUMPDEST 0573 34 CALLVALUE 0574 80 DUP1 0575 15 ISZERO 0576 61 PUSH2 0x057e 0579 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0573 stack[0] = msg.value } // Block ends with conditional jump to 0x057e, if !msg.value label_057A: // Incoming jump from 0x0579, if not !msg.value // Inputs[1] { @057D memory[0x00:0x00] } 057A 60 PUSH1 0x00 057C 80 DUP1 057D FD *REVERT // Stack delta = +0 // Outputs[1] { @057D revert(memory[0x00:0x00]); } // Block terminates label_057E: // Incoming jump from 0x0579, if !msg.value // Inputs[1] { @0586 msg.data.length } 057E 5B JUMPDEST 057F 50 POP 0580 61 PUSH2 0x03a2 0583 61 PUSH2 0x058d 0586 36 CALLDATASIZE 0587 60 PUSH1 0x04 0589 61 PUSH2 0x2886 058C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0580 stack[-1] = 0x03a2 // @0583 stack[0] = 0x058d // @0586 stack[1] = msg.data.length // @0587 stack[2] = 0x04 // } // Block ends with call to 0x2886, returns to 0x058D label_058D: // Incoming return from call to 0x2886 at 0x058C 058D 5B JUMPDEST 058E 61 PUSH2 0x10c8 0591 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10c8 label_0592: // Incoming jump from 0x0143, if 0x715018a6 == stack[-1] // Inputs[1] { @0593 msg.value } 0592 5B JUMPDEST 0593 34 CALLVALUE 0594 80 DUP1 0595 15 ISZERO 0596 61 PUSH2 0x059e 0599 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0593 stack[0] = msg.value } // Block ends with conditional jump to 0x059e, if !msg.value label_059A: // Incoming jump from 0x0599, if not !msg.value // Inputs[1] { @059D memory[0x00:0x00] } 059A 60 PUSH1 0x00 059C 80 DUP1 059D FD *REVERT // Stack delta = +0 // Outputs[1] { @059D revert(memory[0x00:0x00]); } // Block terminates label_059E: // Incoming jump from 0x0599, if !msg.value 059E 5B JUMPDEST 059F 50 POP 05A0 61 PUSH2 0x036f 05A3 61 PUSH2 0x1162 05A6 56 *JUMP // Stack delta = +0 // Outputs[1] { @05A0 stack[-1] = 0x036f } // Block ends with call to 0x1162, returns to 0x036F label_05A7: // Incoming jump from 0x014E, if 0x8693da20 == stack[-1] // Inputs[1] { @05A8 msg.value } 05A7 5B JUMPDEST 05A8 34 CALLVALUE 05A9 80 DUP1 05AA 15 ISZERO 05AB 61 PUSH2 0x05b3 05AE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05A8 stack[0] = msg.value } // Block ends with conditional jump to 0x05b3, if !msg.value label_05AF: // Incoming jump from 0x05AE, if not !msg.value // Inputs[1] { @05B2 memory[0x00:0x00] } 05AF 60 PUSH1 0x00 05B1 80 DUP1 05B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B2 revert(memory[0x00:0x00]); } // Block terminates label_05B3: // Incoming jump from 0x05AE, if !msg.value 05B3 5B JUMPDEST 05B4 50 POP 05B5 61 PUSH2 0x03a2 05B8 66 PUSH7 0x8e1bc9bf040000 05C0 81 DUP2 05C1 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @05B5 stack[-1] = 0x03a2 // @05B8 stack[0] = 0x8e1bc9bf040000 // } // Block ends with unconditional jump to 0x03a2 label_05C2: // Incoming jump from 0x0112, if 0x8b93b0f5 == stack[-1] // Inputs[1] { @05C3 msg.value } 05C2 5B JUMPDEST 05C3 34 CALLVALUE 05C4 80 DUP1 05C5 15 ISZERO 05C6 61 PUSH2 0x05ce 05C9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05C3 stack[0] = msg.value } // Block ends with conditional jump to 0x05ce, if !msg.value label_05CA: // Incoming jump from 0x05C9, if not !msg.value // Inputs[1] { @05CD memory[0x00:0x00] } 05CA 60 PUSH1 0x00 05CC 80 DUP1 05CD FD *REVERT // Stack delta = +0 // Outputs[1] { @05CD revert(memory[0x00:0x00]); } // Block terminates label_05CE: // Incoming jump from 0x05C9, if !msg.value 05CE 5B JUMPDEST 05CF 50 POP 05D0 61 PUSH2 0x03a2 05D3 61 PUSH2 0x0185 05D6 81 DUP2 05D7 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @05D0 stack[-1] = 0x03a2 // @05D3 stack[0] = 0x0185 // } // Block ends with unconditional jump to 0x03a2 label_05D8: // Incoming jump from 0x011D, if 0x8da5cb5b == stack[-1] // Inputs[1] { @05D9 msg.value } 05D8 5B JUMPDEST 05D9 34 CALLVALUE 05DA 80 DUP1 05DB 15 ISZERO 05DC 61 PUSH2 0x05e4 05DF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05D9 stack[0] = msg.value } // Block ends with conditional jump to 0x05e4, if !msg.value label_05E0: // Incoming jump from 0x05DF, if not !msg.value // Inputs[1] { @05E3 memory[0x00:0x00] } 05E0 60 PUSH1 0x00 05E2 80 DUP1 05E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @05E3 revert(memory[0x00:0x00]); } // Block terminates label_05E4: // Incoming jump from 0x05DF, if !msg.value // Inputs[1] { @05E8 storage[0x0a] } 05E4 5B JUMPDEST 05E5 50 POP 05E6 60 PUSH1 0x0a 05E8 54 SLOAD 05E9 60 PUSH1 0x01 05EB 60 PUSH1 0x01 05ED 60 PUSH1 0xa0 05EF 1B SHL 05F0 03 SUB 05F1 16 AND 05F2 61 PUSH2 0x0337 05F5 56 *JUMP // Stack delta = +0 // Outputs[1] { @05F1 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x0a] } // Block ends with unconditional jump to 0x0337 label_05F6: // Incoming jump from 0x00EC, if 0x940f1ada == stack[-1] // Inputs[1] { @05F7 msg.value } 05F6 5B JUMPDEST 05F7 34 CALLVALUE 05F8 80 DUP1 05F9 15 ISZERO 05FA 61 PUSH2 0x0602 05FD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05F7 stack[0] = msg.value } // Block ends with conditional jump to 0x0602, if !msg.value label_05FE: // Incoming jump from 0x05FD, if not !msg.value // Inputs[1] { @0601 memory[0x00:0x00] } 05FE 60 PUSH1 0x00 0600 80 DUP1 0601 FD *REVERT // Stack delta = +0 // Outputs[1] { @0601 revert(memory[0x00:0x00]); } // Block terminates label_0602: // Incoming jump from 0x05FD, if !msg.value // Inputs[1] { @0609 storage[0x0b] } 0602 5B JUMPDEST 0603 50 POP 0604 61 PUSH2 0x03a2 0607 60 PUSH1 0x0b 0609 54 SLOAD 060A 81 DUP2 060B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0604 stack[-1] = 0x03a2 // @0609 stack[0] = storage[0x0b] // } // Block ends with unconditional jump to 0x03a2 label_060C: // Incoming jump from 0x00F7, if 0x94464eec == stack[-1] // Inputs[1] { @060D msg.value } 060C 5B JUMPDEST 060D 34 CALLVALUE 060E 80 DUP1 060F 15 ISZERO 0610 61 PUSH2 0x0618 0613 57 *JUMPI // Stack delta = +1 // Outputs[1] { @060D stack[0] = msg.value } // Block ends with conditional jump to 0x0618, if !msg.value label_0614: // Incoming jump from 0x0613, if not !msg.value // Inputs[1] { @0617 memory[0x00:0x00] } 0614 60 PUSH1 0x00 0616 80 DUP1 0617 FD *REVERT // Stack delta = +0 // Outputs[1] { @0617 revert(memory[0x00:0x00]); } // Block terminates label_0618: // Incoming jump from 0x0613, if !msg.value 0618 5B JUMPDEST 0619 50 POP 061A 61 PUSH2 0x030a 061D 61 PUSH2 0x11c8 0620 56 *JUMP // Stack delta = +0 // Outputs[1] { @061A stack[-1] = 0x030a } // Block ends with call to 0x11c8, returns to 0x030A label_0621: // Incoming jump from 0x0102, if 0x95d89b41 == stack[-1] // Inputs[1] { @0622 msg.value } 0621 5B JUMPDEST 0622 34 CALLVALUE 0623 80 DUP1 0624 15 ISZERO 0625 61 PUSH2 0x062d 0628 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0622 stack[0] = msg.value } // Block ends with conditional jump to 0x062d, if !msg.value label_0629: // Incoming jump from 0x0628, if not !msg.value // Inputs[1] { @062C memory[0x00:0x00] } 0629 60 PUSH1 0x00 062B 80 DUP1 062C FD *REVERT // Stack delta = +0 // Outputs[1] { @062C revert(memory[0x00:0x00]); } // Block terminates label_062D: // Incoming jump from 0x0628, if !msg.value 062D 5B JUMPDEST 062E 50 POP 062F 61 PUSH2 0x030a 0632 61 PUSH2 0x11e4 0635 56 *JUMP // Stack delta = +0 // Outputs[1] { @062F stack[-1] = 0x030a } // Block ends with call to 0x11e4, returns to 0x030A label_0636: // Incoming jump from 0x00BB, if 0x9c70b512 == stack[-1] // Inputs[1] { @0637 msg.value } 0636 5B JUMPDEST 0637 34 CALLVALUE 0638 80 DUP1 0639 15 ISZERO 063A 61 PUSH2 0x0642 063D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0637 stack[0] = msg.value } // Block ends with conditional jump to 0x0642, if !msg.value label_063E: // Incoming jump from 0x063D, if not !msg.value // Inputs[1] { @0641 memory[0x00:0x00] } 063E 60 PUSH1 0x00 0640 80 DUP1 0641 FD *REVERT // Stack delta = +0 // Outputs[1] { @0641 revert(memory[0x00:0x00]); } // Block terminates label_0642: // Incoming jump from 0x063D, if !msg.value // Inputs[1] { @0646 storage[0x0e] } 0642 5B JUMPDEST 0643 50 POP 0644 60 PUSH1 0x0e 0646 54 SLOAD 0647 61 PUSH2 0x02e0 064A 90 SWAP1 064B 61 PUSH2 0x0100 064E 90 SWAP1 064F 04 DIV 0650 60 PUSH1 0xff 0652 16 AND 0653 81 DUP2 0654 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @064A stack[-1] = 0x02e0 // @0652 stack[0] = 0xff & storage[0x0e] / 0x0100 // } // Block ends with unconditional jump to 0x02e0 label_0655: // Incoming jump from 0x00C6, if 0xa0712d68 == stack[-1] // Inputs[1] { @065C msg.data.length } 0655 5B JUMPDEST 0656 61 PUSH2 0x036f 0659 61 PUSH2 0x0663 065C 36 CALLDATASIZE 065D 60 PUSH1 0x04 065F 61 PUSH2 0x2ac7 0662 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0656 stack[0] = 0x036f // @0659 stack[1] = 0x0663 // @065C stack[2] = msg.data.length // @065D stack[3] = 0x04 // } // Block ends with call to 0x2ac7, returns to 0x0663 label_0663: // Incoming return from call to 0x2AC7 at 0x0662 0663 5B JUMPDEST 0664 61 PUSH2 0x11f3 0667 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x11f3 label_0668: // Incoming jump from 0x0095, if 0xa22cb465 == stack[-1] // Inputs[1] { @0669 msg.value } 0668 5B JUMPDEST 0669 34 CALLVALUE 066A 80 DUP1 066B 15 ISZERO 066C 61 PUSH2 0x0674 066F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0669 stack[0] = msg.value } // Block ends with conditional jump to 0x0674, if !msg.value label_0670: // Incoming jump from 0x066F, if not !msg.value // Inputs[1] { @0673 memory[0x00:0x00] } 0670 60 PUSH1 0x00 0672 80 DUP1 0673 FD *REVERT // Stack delta = +0 // Outputs[1] { @0673 revert(memory[0x00:0x00]); } // Block terminates label_0674: // Incoming jump from 0x066F, if !msg.value // Inputs[1] { @067C msg.data.length } 0674 5B JUMPDEST 0675 50 POP 0676 61 PUSH2 0x036f 0679 61 PUSH2 0x0683 067C 36 CALLDATASIZE 067D 60 PUSH1 0x04 067F 61 PUSH2 0x2993 0682 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0676 stack[-1] = 0x036f // @0679 stack[0] = 0x0683 // @067C stack[1] = msg.data.length // @067D stack[2] = 0x04 // } // Block ends with call to 0x2993, returns to 0x0683 label_0683: // Incoming return from call to 0x2993 at 0x0682 0683 5B JUMPDEST 0684 61 PUSH2 0x13f9 0687 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x13f9 label_0688: // Incoming jump from 0x00A0, if 0xb88d4fde == stack[-1] // Inputs[1] { @0689 msg.value } 0688 5B JUMPDEST 0689 34 CALLVALUE 068A 80 DUP1 068B 15 ISZERO 068C 61 PUSH2 0x0694 068F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0689 stack[0] = msg.value } // Block ends with conditional jump to 0x0694, if !msg.value label_0690: // Incoming jump from 0x068F, if not !msg.value // Inputs[1] { @0693 memory[0x00:0x00] } 0690 60 PUSH1 0x00 0692 80 DUP1 0693 FD *REVERT // Stack delta = +0 // Outputs[1] { @0693 revert(memory[0x00:0x00]); } // Block terminates label_0694: // Incoming jump from 0x068F, if !msg.value // Inputs[1] { @069C msg.data.length } 0694 5B JUMPDEST 0695 50 POP 0696 61 PUSH2 0x036f 0699 61 PUSH2 0x06a3 069C 36 CALLDATASIZE 069D 60 PUSH1 0x04 069F 61 PUSH2 0x2917 06A2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0696 stack[-1] = 0x036f // @0699 stack[0] = 0x06a3 // @069C stack[1] = msg.data.length // @069D stack[2] = 0x04 // } // Block ends with call to 0x2917, returns to 0x06A3 label_06A3: // Incoming return from call to 0x2917 at 0x06A2 06A3 5B JUMPDEST 06A4 61 PUSH2 0x14be 06A7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x14be label_06A8: // Incoming jump from 0x00AB, if 0xc6682862 == stack[-1] // Inputs[1] { @06A9 msg.value } 06A8 5B JUMPDEST 06A9 34 CALLVALUE 06AA 80 DUP1 06AB 15 ISZERO 06AC 61 PUSH2 0x06b4 06AF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06A9 stack[0] = msg.value } // Block ends with conditional jump to 0x06b4, if !msg.value label_06B0: // Incoming jump from 0x06AF, if not !msg.value // Inputs[1] { @06B3 memory[0x00:0x00] } 06B0 60 PUSH1 0x00 06B2 80 DUP1 06B3 FD *REVERT // Stack delta = +0 // Outputs[1] { @06B3 revert(memory[0x00:0x00]); } // Block terminates label_06B4: // Incoming jump from 0x06AF, if !msg.value // Inputs[1] { @06BB memory[0x40:0x60] } 06B4 5B JUMPDEST 06B5 50 POP 06B6 61 PUSH2 0x030a 06B9 60 PUSH1 0x40 06BB 51 MLOAD 06BC 80 DUP1 06BD 60 PUSH1 0x40 06BF 01 ADD 06C0 60 PUSH1 0x40 06C2 52 MSTORE 06C3 80 DUP1 06C4 60 PUSH1 0x05 06C6 81 DUP2 06C7 52 MSTORE 06C8 60 PUSH1 0x20 06CA 01 ADD 06CB 64 PUSH5 0x173539b7b7 06D1 60 PUSH1 0xd9 06D3 1B SHL 06D4 81 DUP2 06D5 52 MSTORE 06D6 50 POP 06D7 81 DUP2 06D8 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @06B6 stack[-1] = 0x030a // @06BB stack[0] = memory[0x40:0x60] // @06C2 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @06C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x05 // @06D5 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x173539b7b7 << 0xd9 // } // Block ends with unconditional jump to 0x030a label_06D9: // Incoming jump from 0x006F, if 0xc87b56dd == stack[-1] // Inputs[1] { @06DA msg.value } 06D9 5B JUMPDEST 06DA 34 CALLVALUE 06DB 80 DUP1 06DC 15 ISZERO 06DD 61 PUSH2 0x06e5 06E0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06DA stack[0] = msg.value } // Block ends with conditional jump to 0x06e5, if !msg.value label_06E1: // Incoming jump from 0x06E0, if not !msg.value // Inputs[1] { @06E4 memory[0x00:0x00] } 06E1 60 PUSH1 0x00 06E3 80 DUP1 06E4 FD *REVERT // Stack delta = +0 // Outputs[1] { @06E4 revert(memory[0x00:0x00]); } // Block terminates label_06E5: // Incoming jump from 0x06E0, if !msg.value // Inputs[1] { @06ED msg.data.length } 06E5 5B JUMPDEST 06E6 50 POP 06E7 61 PUSH2 0x030a 06EA 61 PUSH2 0x06f4 06ED 36 CALLDATASIZE 06EE 60 PUSH1 0x04 06F0 61 PUSH2 0x2ac7 06F3 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06E7 stack[-1] = 0x030a // @06EA stack[0] = 0x06f4 // @06ED stack[1] = msg.data.length // @06EE stack[2] = 0x04 // } // Block ends with call to 0x2ac7, returns to 0x06F4 label_06F4: // Incoming return from call to 0x2AC7 at 0x06F3 06F4 5B JUMPDEST 06F5 61 PUSH2 0x1546 06F8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1546 label_06F9: // Incoming jump from 0x007A, if 0xd2cab056 == stack[-1] // Inputs[1] { @0700 msg.data.length } 06F9 5B JUMPDEST 06FA 61 PUSH2 0x036f 06FD 61 PUSH2 0x0707 0700 36 CALLDATASIZE 0701 60 PUSH1 0x04 0703 61 PUSH2 0x2ae0 0706 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06FA stack[0] = 0x036f // @06FD stack[1] = 0x0707 // @0700 stack[2] = msg.data.length // @0701 stack[3] = 0x04 // } // Block ends with call to 0x2ae0, returns to 0x0707 label_0707: // Incoming return from call to 0x2AE0 at 0x0706 0707 5B JUMPDEST 0708 61 PUSH2 0x1624 070B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1624 label_070C: // Incoming jump from 0x0049, if 0xe7b99ec7 == stack[-1] // Inputs[1] { @070D msg.value } 070C 5B JUMPDEST 070D 34 CALLVALUE 070E 80 DUP1 070F 15 ISZERO 0710 61 PUSH2 0x0718 0713 57 *JUMPI // Stack delta = +1 // Outputs[1] { @070D stack[0] = msg.value } // Block ends with conditional jump to 0x0718, if !msg.value label_0714: // Incoming jump from 0x0713, if not !msg.value // Inputs[1] { @0717 memory[0x00:0x00] } 0714 60 PUSH1 0x00 0716 80 DUP1 0717 FD *REVERT // Stack delta = +0 // Outputs[1] { @0717 revert(memory[0x00:0x00]); } // Block terminates label_0718: // Incoming jump from 0x0713, if !msg.value 0718 5B JUMPDEST 0719 50 POP 071A 61 PUSH2 0x03a2 071D 66 PUSH7 0x6a94d74f430000 0725 81 DUP2 0726 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @071A stack[-1] = 0x03a2 // @071D stack[0] = 0x6a94d74f430000 // } // Block ends with unconditional jump to 0x03a2 label_0727: // Incoming jump from 0x0054, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0728 msg.value } 0727 5B JUMPDEST 0728 34 CALLVALUE 0729 80 DUP1 072A 15 ISZERO 072B 61 PUSH2 0x0733 072E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0728 stack[0] = msg.value } // Block ends with conditional jump to 0x0733, if !msg.value label_072F: // Incoming jump from 0x072E, if not !msg.value // Inputs[1] { @0732 memory[0x00:0x00] } 072F 60 PUSH1 0x00 0731 80 DUP1 0732 FD *REVERT // Stack delta = +0 // Outputs[1] { @0732 revert(memory[0x00:0x00]); } // Block terminates label_0733: // Incoming jump from 0x072E, if !msg.value // Inputs[1] { @073B msg.data.length } 0733 5B JUMPDEST 0734 50 POP 0735 61 PUSH2 0x02e0 0738 61 PUSH2 0x0742 073B 36 CALLDATASIZE 073C 60 PUSH1 0x04 073E 61 PUSH2 0x28a8 0741 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0735 stack[-1] = 0x02e0 // @0738 stack[0] = 0x0742 // @073B stack[1] = msg.data.length // @073C stack[2] = 0x04 // } // Block ends with call to 0x28a8, returns to 0x0742 label_0742: // Incoming call from 0x09C1, returns to 0x09C2 // Incoming return from call to 0x28A8 at 0x0741 // Inputs[6] // { // @074B stack[-2] // @075E memory[0x00:0x40] // @075F stack[-1] // @0769 memory[0x00:0x40] // @076A storage[keccak256(memory[0x00:0x40])] // @076E stack[-3] // } 0742 5B JUMPDEST 0743 60 PUSH1 0x01 0745 60 PUSH1 0x01 0747 60 PUSH1 0xa0 0749 1B SHL 074A 03 SUB 074B 91 SWAP2 074C 82 DUP3 074D 16 AND 074E 60 PUSH1 0x00 0750 90 SWAP1 0751 81 DUP2 0752 52 MSTORE 0753 60 PUSH1 0x05 0755 60 PUSH1 0x20 0757 90 SWAP1 0758 81 DUP2 0759 52 MSTORE 075A 60 PUSH1 0x40 075C 80 DUP1 075D 83 DUP4 075E 20 SHA3 075F 93 SWAP4 0760 90 SWAP1 0761 94 SWAP5 0762 16 AND 0763 82 DUP3 0764 52 MSTORE 0765 91 SWAP2 0766 90 SWAP1 0767 91 SWAP2 0768 52 MSTORE 0769 20 SHA3 076A 54 SLOAD 076B 60 PUSH1 0xff 076D 16 AND 076E 90 SWAP1 076F 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0752 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0759 memory[0x20:0x40] = 0x05 // @0764 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0768 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @076E stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0770: // Incoming jump from 0x005F, if 0xf2fde38b == stack[-1] // Inputs[1] { @0771 msg.value } 0770 5B JUMPDEST 0771 34 CALLVALUE 0772 80 DUP1 0773 15 ISZERO 0774 61 PUSH2 0x077c 0777 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0771 stack[0] = msg.value } // Block ends with conditional jump to 0x077c, if !msg.value label_0778: // Incoming jump from 0x0777, if not !msg.value // Inputs[1] { @077B memory[0x00:0x00] } 0778 60 PUSH1 0x00 077A 80 DUP1 077B FD *REVERT // Stack delta = +0 // Outputs[1] { @077B revert(memory[0x00:0x00]); } // Block terminates label_077C: // Incoming jump from 0x0777, if !msg.value // Inputs[1] { @0784 msg.data.length } 077C 5B JUMPDEST 077D 50 POP 077E 61 PUSH2 0x036f 0781 61 PUSH2 0x078b 0784 36 CALLDATASIZE 0785 60 PUSH1 0x04 0787 61 PUSH2 0x2886 078A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @077E stack[-1] = 0x036f // @0781 stack[0] = 0x078b // @0784 stack[1] = msg.data.length // @0785 stack[2] = 0x04 // } // Block ends with call to 0x2886, returns to 0x078B label_078B: // Incoming return from call to 0x2886 at 0x078A 078B 5B JUMPDEST 078C 61 PUSH2 0x19a5 078F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x19a5 label_0790: // Incoming jump from 0x02DF // Inputs[1] { @079C stack[-1] } 0790 5B JUMPDEST 0791 60 PUSH1 0x00 0793 60 PUSH1 0x01 0795 60 PUSH1 0x01 0797 60 PUSH1 0xe0 0799 1B SHL 079A 03 SUB 079B 19 NOT 079C 82 DUP3 079D 16 AND 079E 7F PUSH32 0x780e9d6300000000000000000000000000000000000000000000000000000000 07BF 14 EQ 07C0 80 DUP1 07C1 61 PUSH2 0x07ce 07C4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0791 stack[0] = 0x00 // @07BF stack[1] = 0x780e9d6300000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x07ce, if 0x780e9d6300000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_07C5: // Incoming jump from 0x07C4, if not 0x780e9d6300000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @07C9 stack[-3] } 07C5 50 POP 07C6 61 PUSH2 0x07ce 07C9 82 DUP3 07CA 61 PUSH2 0x1a8a 07CD 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @07C6 stack[-1] = 0x07ce // @07C9 stack[0] = stack[-3] // } // Block ends with call to 0x1a8a, returns to 0x07CE label_07CE: // Incoming jump from 0x1AF2, if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x07C4, if 0x780e9d6300000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x0FCC, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1B24 // Incoming return from call to 0x1A8A at 0x07CD // Incoming jump from 0x1AF2, if stack[-1] // Inputs[3] // { // @07CF stack[-1] // @07CF stack[-4] // @07D0 stack[-3] // } 07CE 5B JUMPDEST 07CF 92 SWAP3 07D0 91 SWAP2 07D1 50 POP 07D2 50 POP 07D3 56 *JUMP // Stack delta = -3 // Outputs[1] { @07CF stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_07D4: // Incoming call from 0x0309, returns to 0x030A // Inputs[1] { @07DA storage[0x00] } 07D4 5B JUMPDEST 07D5 60 PUSH1 0x60 07D7 60 PUSH1 0x00 07D9 80 DUP1 07DA 54 SLOAD 07DB 61 PUSH2 0x07e3 07DE 90 SWAP1 07DF 61 PUSH2 0x2cf8 07E2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @07D5 stack[0] = 0x60 // @07D7 stack[1] = 0x00 // @07DE stack[2] = 0x07e3 // @07DE stack[3] = storage[0x00] // } // Block ends with call to 0x2cf8, returns to 0x07E3 label_07E3: // Incoming return from call to 0x2CF8 at 0x07E2 // Incoming return from call to 0x2CF8 at 0x11F2 // Inputs[4] // { // @07E4 stack[-1] // @07F3 memory[0x40:0x60] // @07FB stack[-2] // @0806 storage[stack[-2]] // } 07E3 5B JUMPDEST 07E4 80 DUP1 07E5 60 PUSH1 0x1f 07E7 01 ADD 07E8 60 PUSH1 0x20 07EA 80 DUP1 07EB 91 SWAP2 07EC 04 DIV 07ED 02 MUL 07EE 60 PUSH1 0x20 07F0 01 ADD 07F1 60 PUSH1 0x40 07F3 51 MLOAD 07F4 90 SWAP1 07F5 81 DUP2 07F6 01 ADD 07F7 60 PUSH1 0x40 07F9 52 MSTORE 07FA 80 DUP1 07FB 92 SWAP3 07FC 91 SWAP2 07FD 90 SWAP1 07FE 81 DUP2 07FF 81 DUP2 0800 52 MSTORE 0801 60 PUSH1 0x20 0803 01 ADD 0804 82 DUP3 0805 80 DUP1 0806 54 SLOAD 0807 61 PUSH2 0x080f 080A 90 SWAP1 080B 61 PUSH2 0x2cf8 080E 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @07F9 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @07FB stack[-2] = memory[0x40:0x60] // @07FC stack[-1] = stack[-2] // @07FD stack[0] = stack[-1] // @0800 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0803 stack[1] = 0x20 + memory[0x40:0x60] // @0804 stack[2] = stack[-2] // @080A stack[4] = storage[stack[-2]] // @080A stack[3] = 0x080f // } // Block ends with call to 0x2cf8, returns to 0x080F label_080F: // Incoming return from call to 0x2CF8 at 0x080E // Inputs[1] { @0810 stack[-1] } 080F 5B JUMPDEST 0810 80 DUP1 0811 15 ISZERO 0812 61 PUSH2 0x085c 0815 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x085c, if !stack[-1] label_0816: // Incoming jump from 0x0815, if not !stack[-1] // Inputs[1] { @0816 stack[-1] } 0816 80 DUP1 0817 60 PUSH1 0x1f 0819 10 LT 081A 61 PUSH2 0x0831 081D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0831, if 0x1f < stack[-1] label_081E: // Incoming jump from 0x081D, if not 0x1f < stack[-1] // Inputs[4] // { // @0822 stack[-2] // @0823 storage[stack[-2]] // @0826 stack[-3] // @0828 stack[-1] // } 081E 61 PUSH2 0x0100 0821 80 DUP1 0822 83 DUP4 0823 54 SLOAD 0824 04 DIV 0825 02 MUL 0826 83 DUP4 0827 52 MSTORE 0828 91 SWAP2 0829 60 PUSH1 0x20 082B 01 ADD 082C 91 SWAP2 082D 61 PUSH2 0x085c 0830 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0827 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @082C stack[-1] = stack[-1] // @082C stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x085c label_0831: // Incoming jump from 0x081D, if 0x1f < stack[-1] // Inputs[5] // { // @0832 stack[-3] // @0833 stack[-1] // @0835 stack[-2] // @083D memory[0x00:0x20] // @0841 storage[keccak256(memory[0x00:0x20])] // } 0831 5B JUMPDEST 0832 82 DUP3 0833 01 ADD 0834 91 SWAP2 0835 90 SWAP1 0836 60 PUSH1 0x00 0838 52 MSTORE 0839 60 PUSH1 0x20 083B 60 PUSH1 0x00 083D 20 SHA3 083E 90 SWAP1 083F 5B JUMPDEST 0840 81 DUP2 0841 54 SLOAD 0842 81 DUP2 0843 52 MSTORE 0844 90 SWAP1 0845 60 PUSH1 0x01 0847 01 ADD 0848 90 SWAP1 0849 60 PUSH1 0x20 084B 01 ADD 084C 80 DUP1 084D 83 DUP4 084E 11 GT 084F 61 PUSH2 0x083f 0852 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0834 stack[-3] = stack[-3] + stack[-1] // @0838 memory[0x00:0x20] = stack[-2] // @0843 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0848 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @084B stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x083f, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0853: // Incoming jump from 0x0852, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0852, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0853 stack[-3] // @0854 stack[-1] // } 0853 82 DUP3 0854 90 SWAP1 0855 03 SUB 0856 60 PUSH1 0x1f 0858 16 AND 0859 82 DUP3 085A 01 ADD 085B 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @085B stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @085B stack[-1] = stack[-3] // } // Block continues label_085C: // Incoming jump from 0x0830 // Incoming jump from 0x085B // Incoming jump from 0x0815, if !stack[-1] // Inputs[3] // { // @0862 stack[-7] // @0862 stack[-6] // @0864 stack[-8] // } 085C 5B JUMPDEST 085D 50 POP 085E 50 POP 085F 50 POP 0860 50 POP 0861 50 POP 0862 90 SWAP1 0863 50 POP 0864 90 SWAP1 0865 56 *JUMP // Stack delta = -7 // Outputs[1] { @0864 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0866: // Incoming jump from 0x0336 // Incoming call from 0x1C64, returns to 0x1C65 // Inputs[3] // { // @0869 stack[-1] // @0874 memory[0x00:0x40] // @0875 storage[keccak256(memory[0x00:0x40])] // } 0866 5B JUMPDEST 0867 60 PUSH1 0x00 0869 81 DUP2 086A 81 DUP2 086B 52 MSTORE 086C 60 PUSH1 0x02 086E 60 PUSH1 0x20 0870 52 MSTORE 0871 60 PUSH1 0x40 0873 81 DUP2 0874 20 SHA3 0875 54 SLOAD 0876 60 PUSH1 0x01 0878 60 PUSH1 0x01 087A 60 PUSH1 0xa0 087C 1B SHL 087D 03 SUB 087E 16 AND 087F 61 PUSH2 0x08f5 0882 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0867 stack[0] = 0x00 // @086B memory[0x00:0x20] = stack[-1] // @0870 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x08f5, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_0883: // Incoming jump from 0x0882, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0885 memory[0x40:0x60] } 0883 60 PUSH1 0x40 0885 51 MLOAD 0886 62 PUSH3 0x461bcd 088A 60 PUSH1 0xe5 088C 1B SHL 088D 81 DUP2 088E 52 MSTORE 088F 60 PUSH1 0x20 0891 60 PUSH1 0x04 0893 82 DUP3 0894 01 ADD 0895 52 MSTORE 0896 60 PUSH1 0x2c 0898 60 PUSH1 0x24 089A 82 DUP3 089B 01 ADD 089C 52 MSTORE 089D 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 08BE 60 PUSH1 0x44 08C0 82 DUP3 08C1 01 ADD 08C2 52 MSTORE 08C3 7F PUSH32 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 08E4 60 PUSH1 0x64 08E6 82 DUP3 08E7 01 ADD 08E8 52 MSTORE 08E9 60 PUSH1 0x84 08EB 01 ADD // Stack delta = +1 // Outputs[6] // { // @088E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0895 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @089C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @08C2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 // @08E8 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 // @08EB stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_08EC: // Incoming jump from 0x0CAC // Incoming jump from 0x25F9 // Incoming jump from 0x1A7A // Incoming jump from 0x12AA // Incoming jump from 0x18FB // Incoming jump from 0x189C // Incoming jump from 0x184E // Incoming jump from 0x1DB1 // Incoming jump from 0x22B0 // Incoming jump from 0x1C29 // Incoming jump from 0x0B2B // Incoming jump from 0x13B7 // Incoming jump from 0x0DC7 // Incoming jump from 0x1756 // Incoming jump from 0x0D79 // Incoming jump from 0x195B // Incoming jump from 0x0BB5 // Incoming jump from 0x265E // Incoming jump from 0x11BB // Incoming jump from 0x19FE // Incoming jump from 0x15D2 // Incoming jump from 0x0E27 // Incoming jump from 0x1357 // Incoming jump from 0x0F18 // Incoming jump from 0x0A33 // Incoming jump from 0x1D36 // Incoming jump from 0x1539 // Incoming jump from 0x1689 // Incoming jump from 0x1451 // Incoming jump from 0x12F8 // Incoming jump from 0x1039 // Incoming jump from 0x16DA // Incoming jump from 0x1F8E // Incoming jump from 0x0F97 // Incoming jump from 0x0C38 // Incoming jump from 0x08EB // Incoming jump from 0x0A9C // Incoming jump from 0x09A5 // Incoming jump from 0x1145 // Incoming jump from 0x1259 // Inputs[3] // { // @08EF memory[0x40:0x60] // @08F1 stack[-1] // @08F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 08EC 5B JUMPDEST 08ED 60 PUSH1 0x40 08EF 51 MLOAD 08F0 80 DUP1 08F1 91 SWAP2 08F2 03 SUB 08F3 90 SWAP1 08F4 FD *REVERT // Stack delta = -1 // Outputs[1] { @08F4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_08F5: // Incoming jump from 0x0882, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @08F9 stack[-2] // @0904 memory[0x00:0x40] // @0905 storage[keccak256(memory[0x00:0x40])] // @090F stack[-3] // } 08F5 5B JUMPDEST 08F6 50 POP 08F7 60 PUSH1 0x00 08F9 90 SWAP1 08FA 81 DUP2 08FB 52 MSTORE 08FC 60 PUSH1 0x04 08FE 60 PUSH1 0x20 0900 52 MSTORE 0901 60 PUSH1 0x40 0903 90 SWAP1 0904 20 SHA3 0905 54 SLOAD 0906 60 PUSH1 0x01 0908 60 PUSH1 0x01 090A 60 PUSH1 0xa0 090C 1B SHL 090D 03 SUB 090E 16 AND 090F 90 SWAP1 0910 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @08FB memory[0x00:0x20] = stack[-2] // @0900 memory[0x20:0x40] = 0x04 // @090F stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0911: // Incoming jump from 0x036E // Inputs[1] { @0917 stack[-1] } 0911 5B JUMPDEST 0912 60 PUSH1 0x00 0914 61 PUSH2 0x091c 0917 82 DUP3 0918 61 PUSH2 0x0faf 091B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0912 stack[0] = 0x00 // @0914 stack[1] = 0x091c // @0917 stack[2] = stack[-1] // } // Block ends with call to 0x0faf, returns to 0x091C label_091C: // Incoming return from call to 0x0FAF at 0x091B // Inputs[3] // { // @091D stack[-1] // @091D stack[-2] // @0929 stack[-4] // } 091C 5B JUMPDEST 091D 90 SWAP1 091E 50 POP 091F 80 DUP1 0920 60 PUSH1 0x01 0922 60 PUSH1 0x01 0924 60 PUSH1 0xa0 0926 1B SHL 0927 03 SUB 0928 16 AND 0929 83 DUP4 092A 60 PUSH1 0x01 092C 60 PUSH1 0x01 092E 60 PUSH1 0xa0 0930 1B SHL 0931 03 SUB 0932 16 AND 0933 14 EQ 0934 15 ISZERO 0935 61 PUSH2 0x09a6 0938 57 *JUMPI // Stack delta = -1 // Outputs[1] { @091D stack[-2] = stack[-1] } // Block ends with conditional jump to 0x09a6, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0939: // Incoming jump from 0x0938, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @093B memory[0x40:0x60] } 0939 60 PUSH1 0x40 093B 51 MLOAD 093C 62 PUSH3 0x461bcd 0940 60 PUSH1 0xe5 0942 1B SHL 0943 81 DUP2 0944 52 MSTORE 0945 60 PUSH1 0x20 0947 60 PUSH1 0x04 0949 82 DUP3 094A 01 ADD 094B 52 MSTORE 094C 60 PUSH1 0x21 094E 60 PUSH1 0x24 0950 82 DUP3 0951 01 ADD 0952 52 MSTORE 0953 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 0974 60 PUSH1 0x44 0976 82 DUP3 0977 01 ADD 0978 52 MSTORE 0979 7F PUSH32 0x7200000000000000000000000000000000000000000000000000000000000000 099A 60 PUSH1 0x64 099C 82 DUP3 099D 01 ADD 099E 52 MSTORE 099F 60 PUSH1 0x84 09A1 01 ADD 09A2 61 PUSH2 0x08ec 09A5 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0944 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @094B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0952 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @0978 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 // @099E memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7200000000000000000000000000000000000000000000000000000000000000 // @09A1 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_09A6: // Incoming jump from 0x0938, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @09A7 msg.sender // @09B0 stack[-1] // } 09A6 5B JUMPDEST 09A7 33 CALLER 09A8 60 PUSH1 0x01 09AA 60 PUSH1 0x01 09AC 60 PUSH1 0xa0 09AE 1B SHL 09AF 03 SUB 09B0 82 DUP3 09B1 16 AND 09B2 14 EQ 09B3 80 DUP1 09B4 61 PUSH2 0x09c2 09B7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @09B2 stack[0] = stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender } // Block ends with conditional jump to 0x09c2, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_09B8: // Incoming jump from 0x09B7, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @09BC stack[-2] // @09BD msg.sender // } 09B8 50 POP 09B9 61 PUSH2 0x09c2 09BC 81 DUP2 09BD 33 CALLER 09BE 61 PUSH2 0x0742 09C1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09B9 stack[-1] = 0x09c2 // @09BC stack[0] = stack[-2] // @09BD stack[1] = msg.sender // } // Block ends with call to 0x0742, returns to 0x09C2 label_09C2: // Incoming jump from 0x09B7, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming return from call to 0x0742 at 0x09C1 // Inputs[1] { @09C6 stack[-1] } 09C2 5B JUMPDEST 09C3 61 PUSH2 0x0a34 09C6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a34, if stack[-1] label_09C7: // Incoming jump from 0x09C6, if not stack[-1] // Inputs[1] { @09C9 memory[0x40:0x60] } 09C7 60 PUSH1 0x40 09C9 51 MLOAD 09CA 62 PUSH3 0x461bcd 09CE 60 PUSH1 0xe5 09D0 1B SHL 09D1 81 DUP2 09D2 52 MSTORE 09D3 60 PUSH1 0x20 09D5 60 PUSH1 0x04 09D7 82 DUP3 09D8 01 ADD 09D9 52 MSTORE 09DA 60 PUSH1 0x38 09DC 60 PUSH1 0x24 09DE 82 DUP3 09DF 01 ADD 09E0 52 MSTORE 09E1 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 0A02 60 PUSH1 0x44 0A04 82 DUP3 0A05 01 ADD 0A06 52 MSTORE 0A07 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 0A28 60 PUSH1 0x64 0A2A 82 DUP3 0A2B 01 ADD 0A2C 52 MSTORE 0A2D 60 PUSH1 0x84 0A2F 01 ADD 0A30 61 PUSH2 0x08ec 0A33 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @09D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09D9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09E0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x38 // @0A06 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 // @0A2C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 // @0A2F stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_0A34: // Incoming jump from 0x09C6, if stack[-1] // Inputs[2] // { // @0A38 stack[-3] // @0A39 stack[-2] // } 0A34 5B JUMPDEST 0A35 61 PUSH2 0x0a3e 0A38 83 DUP4 0A39 83 DUP4 0A3A 61 PUSH2 0x1b25 0A3D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A35 stack[0] = 0x0a3e // @0A38 stack[1] = stack[-3] // @0A39 stack[2] = stack[-2] // } // Block ends with call to 0x1b25, returns to 0x0A3E label_0A3E: // Incoming jump from 0x13C3, if !(0x00 < stack[-2]) // Incoming return from call to 0x1B25 at 0x0A3D // Incoming jump from 0x13C3, if !(stack[-1] < stack[-3]) // Incoming jump from 0x221E, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] // Incoming return from call to 0x24B1 at 0x2204 // Incoming return from call to 0x1CA8 at 0x0B36 // Incoming return from call to 0x2560 at 0x2227 // Incoming jump from 0x2243, if stack[-1] // Inputs[1] { @0A42 stack[-4] } 0A3E 5B JUMPDEST 0A3F 50 POP 0A40 50 POP 0A41 50 POP 0A42 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0A43: // Incoming jump from 0x0390 // Inputs[2] // { // @0A46 storage[0x0a] // @0A50 msg.sender // } 0A43 5B JUMPDEST 0A44 60 PUSH1 0x0a 0A46 54 SLOAD 0A47 60 PUSH1 0x01 0A49 60 PUSH1 0x01 0A4B 60 PUSH1 0xa0 0A4D 1B SHL 0A4E 03 SUB 0A4F 16 AND 0A50 33 CALLER 0A51 14 EQ 0A52 61 PUSH2 0x0a9d 0A55 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a9d, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] label_0A56: // Incoming jump from 0x0A55, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @0A58 memory[0x40:0x60] } 0A56 60 PUSH1 0x40 0A58 51 MLOAD 0A59 62 PUSH3 0x461bcd 0A5D 60 PUSH1 0xe5 0A5F 1B SHL 0A60 81 DUP2 0A61 52 MSTORE 0A62 60 PUSH1 0x20 0A64 60 PUSH1 0x04 0A66 82 DUP3 0A67 01 ADD 0A68 81 DUP2 0A69 90 SWAP1 0A6A 52 MSTORE 0A6B 60 PUSH1 0x24 0A6D 82 DUP3 0A6E 01 ADD 0A6F 52 MSTORE 0A70 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0A91 60 PUSH1 0x44 0A93 82 DUP3 0A94 01 ADD 0A95 52 MSTORE 0A96 60 PUSH1 0x64 0A98 01 ADD 0A99 61 PUSH2 0x08ec 0A9C 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A61 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A6A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A6F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0A95 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0A98 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_0A9D: // Incoming jump from 0x0A55, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[3] // { // @0AA1 storage[0x0e] // @0AA6 stack[-1] // @0AAF stack[-2] // } 0A9D 5B JUMPDEST 0A9E 60 PUSH1 0x0e 0AA0 80 DUP1 0AA1 54 SLOAD 0AA2 60 PUSH1 0xff 0AA4 19 NOT 0AA5 16 AND 0AA6 91 SWAP2 0AA7 15 ISZERO 0AA8 15 ISZERO 0AA9 91 SWAP2 0AAA 90 SWAP1 0AAB 91 SWAP2 0AAC 17 OR 0AAD 90 SWAP1 0AAE 55 SSTORE 0AAF 56 *JUMP // Stack delta = -2 // Outputs[1] { @0AAE storage[0x0e] = !!stack[-1] | (~0xff & storage[0x0e]) } // Block ends with unconditional jump to stack[-2] label_0AB0: // Incoming jump from 0x03CF // Inputs[2] // { // @0AB4 msg.sender // @0AB5 stack[-1] // } 0AB0 5B JUMPDEST 0AB1 61 PUSH2 0x0aba 0AB4 33 CALLER 0AB5 82 DUP3 0AB6 61 PUSH2 0x1ba0 0AB9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AB1 stack[0] = 0x0aba // @0AB4 stack[1] = msg.sender // @0AB5 stack[2] = stack[-1] // } // Block ends with call to 0x1ba0, returns to 0x0ABA label_0ABA: // Incoming return from call to 0x1BA0 at 0x0AB9 // Inputs[1] { @0ABE stack[-1] } 0ABA 5B JUMPDEST 0ABB 61 PUSH2 0x0b2c 0ABE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b2c, if stack[-1] label_0ABF: // Incoming jump from 0x0ABE, if not stack[-1] // Inputs[1] { @0AC1 memory[0x40:0x60] } 0ABF 60 PUSH1 0x40 0AC1 51 MLOAD 0AC2 62 PUSH3 0x461bcd 0AC6 60 PUSH1 0xe5 0AC8 1B SHL 0AC9 81 DUP2 0ACA 52 MSTORE 0ACB 60 PUSH1 0x20 0ACD 60 PUSH1 0x04 0ACF 82 DUP3 0AD0 01 ADD 0AD1 52 MSTORE 0AD2 60 PUSH1 0x31 0AD4 60 PUSH1 0x24 0AD6 82 DUP3 0AD7 01 ADD 0AD8 52 MSTORE 0AD9 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 0AFA 60 PUSH1 0x44 0AFC 82 DUP3 0AFD 01 ADD 0AFE 52 MSTORE 0AFF 7F PUSH32 0x776e6572206e6f7220617070726f766564000000000000000000000000000000 0B20 60 PUSH1 0x64 0B22 82 DUP3 0B23 01 ADD 0B24 52 MSTORE 0B25 60 PUSH1 0x84 0B27 01 ADD 0B28 61 PUSH2 0x08ec 0B2B 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0ACA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AD1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0AD8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x31 // @0AFE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f // @0B24 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x776e6572206e6f7220617070726f766564000000000000000000000000000000 // @0B27 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_0B2C: // Incoming jump from 0x0ABE, if stack[-1] // Inputs[3] // { // @0B30 stack[-3] // @0B31 stack[-2] // @0B32 stack[-1] // } 0B2C 5B JUMPDEST 0B2D 61 PUSH2 0x0a3e 0B30 83 DUP4 0B31 83 DUP4 0B32 83 DUP4 0B33 61 PUSH2 0x1ca8 0B36 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B2D stack[0] = 0x0a3e // @0B30 stack[1] = stack[-3] // @0B31 stack[2] = stack[-2] // @0B32 stack[3] = stack[-1] // } // Block ends with call to 0x1ca8, returns to 0x0A3E label_0B37: // Incoming jump from 0x044F // Inputs[1] { @0B3D stack[-2] } 0B37 5B JUMPDEST 0B38 60 PUSH1 0x00 0B3A 61 PUSH2 0x0b42 0B3D 83 DUP4 0B3E 61 PUSH2 0x10c8 0B41 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B38 stack[0] = 0x00 // @0B3A stack[1] = 0x0b42 // @0B3D stack[2] = stack[-2] // } // Block ends with call to 0x10c8, returns to 0x0B42 label_0B42: // Incoming return from call to 0x10C8 at 0x0B41 // Inputs[2] // { // @0B43 stack[-3] // @0B44 stack[-1] // } 0B42 5B JUMPDEST 0B43 82 DUP3 0B44 10 LT 0B45 61 PUSH2 0x0bb6 0B48 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0bb6, if stack[-3] < stack[-1] label_0B49: // Incoming jump from 0x0B48, if not stack[-3] < stack[-1] // Inputs[1] { @0B4B memory[0x40:0x60] } 0B49 60 PUSH1 0x40 0B4B 51 MLOAD 0B4C 62 PUSH3 0x461bcd 0B50 60 PUSH1 0xe5 0B52 1B SHL 0B53 81 DUP2 0B54 52 MSTORE 0B55 60 PUSH1 0x20 0B57 60 PUSH1 0x04 0B59 82 DUP3 0B5A 01 ADD 0B5B 52 MSTORE 0B5C 60 PUSH1 0x2b 0B5E 60 PUSH1 0x24 0B60 82 DUP3 0B61 01 ADD 0B62 52 MSTORE 0B63 7F PUSH32 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 0B84 60 PUSH1 0x44 0B86 82 DUP3 0B87 01 ADD 0B88 52 MSTORE 0B89 7F PUSH32 0x74206f6620626f756e6473000000000000000000000000000000000000000000 0BAA 60 PUSH1 0x64 0BAC 82 DUP3 0BAD 01 ADD 0BAE 52 MSTORE 0BAF 60 PUSH1 0x84 0BB1 01 ADD 0BB2 61 PUSH2 0x08ec 0BB5 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0B54 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B5B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B62 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @0B88 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 // @0BAE memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x74206f6620626f756e6473000000000000000000000000000000000000000000 // @0BB1 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_0BB6: // Incoming jump from 0x0B48, if stack[-3] < stack[-1] // Inputs[6] // { // @0BC0 stack[-3] // @0BC1 stack[-2] // @0BD4 memory[0x00:0x40] // @0BDB memory[0x00:0x40] // @0BDC storage[keccak256(memory[0x00:0x40])] // @0BDD stack[-4] // } 0BB6 5B JUMPDEST 0BB7 50 POP 0BB8 60 PUSH1 0x01 0BBA 60 PUSH1 0x01 0BBC 60 PUSH1 0xa0 0BBE 1B SHL 0BBF 03 SUB 0BC0 91 SWAP2 0BC1 90 SWAP1 0BC2 91 SWAP2 0BC3 16 AND 0BC4 60 PUSH1 0x00 0BC6 90 SWAP1 0BC7 81 DUP2 0BC8 52 MSTORE 0BC9 60 PUSH1 0x06 0BCB 60 PUSH1 0x20 0BCD 90 SWAP1 0BCE 81 DUP2 0BCF 52 MSTORE 0BD0 60 PUSH1 0x40 0BD2 80 DUP1 0BD3 83 DUP4 0BD4 20 SHA3 0BD5 93 SWAP4 0BD6 83 DUP4 0BD7 52 MSTORE 0BD8 92 SWAP3 0BD9 90 SWAP1 0BDA 52 MSTORE 0BDB 20 SHA3 0BDC 54 SLOAD 0BDD 90 SWAP1 0BDE 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @0BC8 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @0BCF memory[0x20:0x40] = 0x06 // @0BD7 memory[0x00:0x20] = stack[-2] // @0BDA memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0BDD stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_0BDF: // Incoming jump from 0x0485 // Inputs[2] // { // @0BE2 storage[0x0a] // @0BEC msg.sender // } 0BDF 5B JUMPDEST 0BE0 60 PUSH1 0x0a 0BE2 54 SLOAD 0BE3 60 PUSH1 0x01 0BE5 60 PUSH1 0x01 0BE7 60 PUSH1 0xa0 0BE9 1B SHL 0BEA 03 SUB 0BEB 16 AND 0BEC 33 CALLER 0BED 14 EQ 0BEE 61 PUSH2 0x0c39 0BF1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c39, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] label_0BF2: // Incoming jump from 0x0BF1, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @0BF4 memory[0x40:0x60] } 0BF2 60 PUSH1 0x40 0BF4 51 MLOAD 0BF5 62 PUSH3 0x461bcd 0BF9 60 PUSH1 0xe5 0BFB 1B SHL 0BFC 81 DUP2 0BFD 52 MSTORE 0BFE 60 PUSH1 0x20 0C00 60 PUSH1 0x04 0C02 82 DUP3 0C03 01 ADD 0C04 81 DUP2 0C05 90 SWAP1 0C06 52 MSTORE 0C07 60 PUSH1 0x24 0C09 82 DUP3 0C0A 01 ADD 0C0B 52 MSTORE 0C0C 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0C2D 60 PUSH1 0x44 0C2F 82 DUP3 0C30 01 ADD 0C31 52 MSTORE 0C32 60 PUSH1 0x64 0C34 01 ADD 0C35 61 PUSH2 0x08ec 0C38 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0BFD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C06 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C0B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0C31 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0C34 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_0C39: // Incoming jump from 0x0BF1, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[3] // { // @0C3D storage[0x0e] // @0C3E stack[-1] // @0C52 stack[-2] // } 0C39 5B JUMPDEST 0C3A 60 PUSH1 0x0e 0C3C 80 DUP1 0C3D 54 SLOAD 0C3E 91 SWAP2 0C3F 15 ISZERO 0C40 15 ISZERO 0C41 61 PUSH2 0x0100 0C44 02 MUL 0C45 61 PUSH2 0xff00 0C48 19 NOT 0C49 90 SWAP1 0C4A 92 SWAP3 0C4B 16 AND 0C4C 91 SWAP2 0C4D 90 SWAP1 0C4E 91 SWAP2 0C4F 17 OR 0C50 90 SWAP1 0C51 55 SSTORE 0C52 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C51 storage[0x0e] = (storage[0x0e] & ~0xff00) | 0x0100 * !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_0C53: // Incoming call from 0x048D, returns to 0x036F // Inputs[2] // { // @0C56 storage[0x0a] // @0C60 msg.sender // } 0C53 5B JUMPDEST 0C54 60 PUSH1 0x0a 0C56 54 SLOAD 0C57 60 PUSH1 0x01 0C59 60 PUSH1 0x01 0C5B 60 PUSH1 0xa0 0C5D 1B SHL 0C5E 03 SUB 0C5F 16 AND 0C60 33 CALLER 0C61 14 EQ 0C62 61 PUSH2 0x0cad 0C65 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cad, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] label_0C66: // Incoming jump from 0x0C65, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @0C68 memory[0x40:0x60] } 0C66 60 PUSH1 0x40 0C68 51 MLOAD 0C69 62 PUSH3 0x461bcd 0C6D 60 PUSH1 0xe5 0C6F 1B SHL 0C70 81 DUP2 0C71 52 MSTORE 0C72 60 PUSH1 0x20 0C74 60 PUSH1 0x04 0C76 82 DUP3 0C77 01 ADD 0C78 81 DUP2 0C79 90 SWAP1 0C7A 52 MSTORE 0C7B 60 PUSH1 0x24 0C7D 82 DUP3 0C7E 01 ADD 0C7F 52 MSTORE 0C80 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0CA1 60 PUSH1 0x44 0CA3 82 DUP3 0CA4 01 ADD 0CA5 52 MSTORE 0CA6 60 PUSH1 0x64 0CA8 01 ADD 0CA9 61 PUSH2 0x08ec 0CAC 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0C71 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C7A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C7F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0CA5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0CA8 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_0CAD: // Incoming jump from 0x0C65, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[8] // { // @0CB0 memory[0x40:0x60] // @0CB4 msg.sender // @0CB6 address(this).balance // @0CB6 address(this) // @0CBE msg.gas // @0CBF address(msg.sender).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0CBF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0CC4 returndata.length // } 0CAD 5B JUMPDEST 0CAE 60 PUSH1 0x40 0CB0 51 MLOAD 0CB1 60 PUSH1 0x00 0CB3 90 SWAP1 0CB4 33 CALLER 0CB5 90 SWAP1 0CB6 47 SELFBALANCE 0CB7 90 SWAP1 0CB8 83 DUP4 0CB9 81 DUP2 0CBA 81 DUP2 0CBB 81 DUP2 0CBC 85 DUP6 0CBD 87 DUP8 0CBE 5A GAS 0CBF F1 CALL 0CC0 92 SWAP3 0CC1 50 POP 0CC2 50 POP 0CC3 50 POP 0CC4 3D RETURNDATASIZE 0CC5 80 DUP1 0CC6 60 PUSH1 0x00 0CC8 81 DUP2 0CC9 14 EQ 0CCA 61 PUSH2 0x0cef 0CCD 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @0CB3 stack[0] = 0x00 // @0CBF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(msg.sender).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0CC0 stack[1] = address(msg.sender).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0CC4 stack[2] = returndata.length // @0CC5 stack[3] = returndata.length // } // Block ends with conditional jump to 0x0cef, if returndata.length == 0x00 label_0CCE: // Incoming jump from 0x0CCD, if not returndata.length == 0x00 // Inputs[6] // { // @0CD0 memory[0x40:0x60] // @0CD1 stack[-2] // @0CD8 returndata.length // @0CE0 returndata.length // @0CE3 returndata.length // @0CEA returndata[0x00:0x00 + returndata.length] // } 0CCE 60 PUSH1 0x40 0CD0 51 MLOAD 0CD1 91 SWAP2 0CD2 50 POP 0CD3 60 PUSH1 0x1f 0CD5 19 NOT 0CD6 60 PUSH1 0x3f 0CD8 3D RETURNDATASIZE 0CD9 01 ADD 0CDA 16 AND 0CDB 82 DUP3 0CDC 01 ADD 0CDD 60 PUSH1 0x40 0CDF 52 MSTORE 0CE0 3D RETURNDATASIZE 0CE1 82 DUP3 0CE2 52 MSTORE 0CE3 3D RETURNDATASIZE 0CE4 60 PUSH1 0x00 0CE6 60 PUSH1 0x20 0CE8 84 DUP5 0CE9 01 ADD 0CEA 3E RETURNDATACOPY 0CEB 61 PUSH2 0x0cf4 0CEE 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0CD1 stack[-2] = memory[0x40:0x60] // @0CDF memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0CE2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0CEA memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0cf4 label_0CEF: // Incoming jump from 0x0CCD, if returndata.length == 0x00 // Inputs[3] // { // @0CF2 stack[-2] // @0CF7 stack[-4] // @0CF7 stack[-3] // } 0CEF 5B JUMPDEST 0CF0 60 PUSH1 0x60 0CF2 91 SWAP2 0CF3 50 POP 0CF4 5B JUMPDEST 0CF5 50 POP 0CF6 50 POP 0CF7 90 SWAP1 0CF8 50 POP 0CF9 80 DUP1 0CFA 61 PUSH2 0x0d02 0CFD 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0CF7 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x0d02, if stack[-3] label_0CFE: // Incoming jump from 0x0CFD, if not stack[-3] // Incoming jump from 0x0CFD, if not stack[-3] // Inputs[1] { @0D01 memory[0x00:0x00] } 0CFE 60 PUSH1 0x00 0D00 80 DUP1 0D01 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D01 revert(memory[0x00:0x00]); } // Block terminates label_0D02: // Incoming jump from 0x0CFD, if stack[-3] // Incoming jump from 0x0CFD, if stack[-3] // Incoming return from call to 0x1EA7 at 0x1A83 // Incoming jump from 0x2DE1, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0D04 stack[-2] } 0D02 5B JUMPDEST 0D03 50 POP 0D04 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0D05: // Incoming jump from 0x04AD // Inputs[4] // { // @0D09 stack[-3] // @0D0A stack[-2] // @0D0B stack[-1] // @0D0E memory[0x40:0x60] // } 0D05 5B JUMPDEST 0D06 61 PUSH2 0x0a3e 0D09 83 DUP4 0D0A 83 DUP4 0D0B 83 DUP4 0D0C 60 PUSH1 0x40 0D0E 51 MLOAD 0D0F 80 DUP1 0D10 60 PUSH1 0x20 0D12 01 ADD 0D13 60 PUSH1 0x40 0D15 52 MSTORE 0D16 80 DUP1 0D17 60 PUSH1 0x00 0D19 81 DUP2 0D1A 52 MSTORE 0D1B 50 POP 0D1C 61 PUSH2 0x14be 0D1F 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0D06 stack[0] = 0x0a3e // @0D09 stack[1] = stack[-3] // @0D0A stack[2] = stack[-2] // @0D0B stack[3] = stack[-1] // @0D0E stack[4] = memory[0x40:0x60] // @0D15 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0D1A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x14be label_0D20: // Incoming jump from 0x04CD // Inputs[2] // { // @0D23 storage[0x0a] // @0D2D msg.sender // } 0D20 5B JUMPDEST 0D21 60 PUSH1 0x0a 0D23 54 SLOAD 0D24 60 PUSH1 0x01 0D26 60 PUSH1 0x01 0D28 60 PUSH1 0xa0 0D2A 1B SHL 0D2B 03 SUB 0D2C 16 AND 0D2D 33 CALLER 0D2E 14 EQ 0D2F 61 PUSH2 0x0d7a 0D32 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d7a, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] label_0D33: // Incoming jump from 0x0D32, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @0D35 memory[0x40:0x60] } 0D33 60 PUSH1 0x40 0D35 51 MLOAD 0D36 62 PUSH3 0x461bcd 0D3A 60 PUSH1 0xe5 0D3C 1B SHL 0D3D 81 DUP2 0D3E 52 MSTORE 0D3F 60 PUSH1 0x20 0D41 60 PUSH1 0x04 0D43 82 DUP3 0D44 01 ADD 0D45 81 DUP2 0D46 90 SWAP1 0D47 52 MSTORE 0D48 60 PUSH1 0x24 0D4A 82 DUP3 0D4B 01 ADD 0D4C 52 MSTORE 0D4D 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0D6E 60 PUSH1 0x44 0D70 82 DUP3 0D71 01 ADD 0D72 52 MSTORE 0D73 60 PUSH1 0x64 0D75 01 ADD 0D76 61 PUSH2 0x08ec 0D79 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0D3E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D47 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D4C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0D72 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0D75 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_0D7A: // Incoming jump from 0x0D32, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @0D82 storage[0x08] } 0D7A 5B JUMPDEST 0D7B 60 PUSH1 0x00 0D7D 61 PUSH2 0x0d85 0D80 60 PUSH1 0x08 0D82 54 SLOAD 0D83 90 SWAP1 0D84 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D7B stack[0] = 0x00 // @0D83 stack[1] = storage[0x08] // } // Block ends with unconditional jump to 0x0d85 label_0D85: // Incoming jump from 0x0D84 // Inputs[2] // { // @0D86 stack[-2] // @0D86 stack[-1] // } 0D85 5B JUMPDEST 0D86 90 SWAP1 0D87 50 POP 0D88 61 PUSH2 0x05dd 0D8B 81 DUP2 0D8C 10 LT 0D8D 61 PUSH2 0x0dc8 0D90 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0D86 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0dc8, if stack[-1] < 0x05dd label_0D91: // Incoming jump from 0x0D90, if not stack[-1] < 0x05dd // Inputs[1] { @0D93 memory[0x40:0x60] } 0D91 60 PUSH1 0x40 0D93 51 MLOAD 0D94 62 PUSH3 0x461bcd 0D98 60 PUSH1 0xe5 0D9A 1B SHL 0D9B 81 DUP2 0D9C 52 MSTORE 0D9D 60 PUSH1 0x20 0D9F 60 PUSH1 0x04 0DA1 82 DUP3 0DA2 01 ADD 0DA3 52 MSTORE 0DA4 60 PUSH1 0x0d 0DA6 60 PUSH1 0x24 0DA8 82 DUP3 0DA9 01 ADD 0DAA 52 MSTORE 0DAB 6C PUSH13 0x27baba1037b31039ba37b1b597 0DB9 60 PUSH1 0x99 0DBB 1B SHL 0DBC 60 PUSH1 0x44 0DBE 82 DUP3 0DBF 01 ADD 0DC0 52 MSTORE 0DC1 60 PUSH1 0x64 0DC3 01 ADD 0DC4 61 PUSH2 0x08ec 0DC7 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0D9C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DA3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DAA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0d // @0DC0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x27baba1037b31039ba37b1b597 << 0x99 // @0DC3 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_0DC8: // Incoming jump from 0x0D90, if stack[-1] < 0x05dd // Inputs[2] // { // @0DCB storage[0x0c] // @0DD4 stack[-2] // } 0DC8 5B JUMPDEST 0DC9 60 PUSH1 0x0c 0DCB 54 SLOAD 0DCC 61 PUSH2 0x0185 0DCF 90 SWAP1 0DD0 61 PUSH2 0x0dda 0DD3 90 SWAP1 0DD4 84 DUP5 0DD5 90 SWAP1 0DD6 61 PUSH2 0x2c6a 0DD9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0DCF stack[0] = 0x0185 // @0DD3 stack[1] = 0x0dda // @0DD5 stack[2] = stack[-2] // @0DD5 stack[3] = storage[0x0c] // } // Block ends with call to 0x2c6a, returns to 0x0DDA label_0DDA: // Incoming return from call to 0x2C6A at 0x0DD9 // Inputs[2] // { // @0DDB stack[-1] // @0DDB stack[-2] // } 0DDA 5B JUMPDEST 0DDB 11 GT 0DDC 15 ISZERO 0DDD 61 PUSH2 0x0e28 0DE0 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0e28, if !(stack[-1] > stack[-2]) label_0DE1: // Incoming jump from 0x0DE0, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0DE3 memory[0x40:0x60] } 0DE1 60 PUSH1 0x40 0DE3 51 MLOAD 0DE4 62 PUSH3 0x461bcd 0DE8 60 PUSH1 0xe5 0DEA 1B SHL 0DEB 81 DUP2 0DEC 52 MSTORE 0DED 60 PUSH1 0x20 0DEF 60 PUSH1 0x04 0DF1 82 DUP3 0DF2 01 ADD 0DF3 52 MSTORE 0DF4 60 PUSH1 0x14 0DF6 60 PUSH1 0x24 0DF8 82 DUP3 0DF9 01 ADD 0DFA 52 MSTORE 0DFB 7F PUSH32 0x5075626c6963206d696e74206578636565646564000000000000000000000000 0E1C 60 PUSH1 0x44 0E1E 82 DUP3 0E1F 01 ADD 0E20 52 MSTORE 0E21 60 PUSH1 0x64 0E23 01 ADD 0E24 61 PUSH2 0x08ec 0E27 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0DEC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DF3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DFA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @0E20 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5075626c6963206d696e74206578636565646564000000000000000000000000 // @0E23 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_0E28: // Incoming jump from 0x0DE0, if !(stack[-1] > stack[-2]) // Inputs[1] { @0E2C stack[-2] } 0E28 5B JUMPDEST 0E29 60 PUSH1 0x00 0E2B 5B JUMPDEST 0E2C 82 DUP3 0E2D 81 DUP2 0E2E 10 LT 0E2F 15 ISZERO 0E30 61 PUSH2 0x0e94 0E33 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E29 stack[0] = 0x00 } // Block ends with conditional jump to 0x0e94, if !(0x00 < stack[-2]) label_0E34: // Incoming jump from 0x0E33, if not !(0x00 < stack[-2]) // Incoming jump from 0x0E33, if not !(stack[-1] < stack[-3]) // Inputs[3] // { // @0E37 stack[-4] // @0E38 stack[-3] // @0E39 stack[-1] // } 0E34 61 PUSH2 0x0e6c 0E37 84 DUP5 0E38 84 DUP5 0E39 83 DUP4 0E3A 81 DUP2 0E3B 81 DUP2 0E3C 10 LT 0E3D 61 PUSH2 0x0e48 0E40 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0E34 stack[0] = 0x0e6c // @0E37 stack[1] = stack[-4] // @0E38 stack[2] = stack[-3] // @0E39 stack[3] = stack[-1] // } // Block ends with conditional call to 0x0e48, returns to 0x0E6C, if stack[-1] < stack[-3] label_0E41: // Incoming jump from 0x0E40, if not stack[-1] < stack[-3] 0E41 61 PUSH2 0x0e48 0E44 61 PUSH2 0x2da4 0E47 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E41 stack[0] = 0x0e48 } // Block ends with unconditional jump to 0x2da4 label_0E48: // Incoming call from 0x0E40, returns to 0x0E6C, if stack[-1] < stack[-3] // Inputs[3] // { // @0E49 stack[-2] // @0E49 stack[-1] // @0E4E stack[-3] // } 0E48 5B JUMPDEST 0E49 90 SWAP1 0E4A 50 POP 0E4B 60 PUSH1 0x20 0E4D 02 MUL 0E4E 01 ADD 0E4F 60 PUSH1 0x20 0E51 81 DUP2 0E52 01 ADD 0E53 90 SWAP1 0E54 61 PUSH2 0x0e5d 0E57 91 SWAP2 0E58 90 SWAP1 0E59 61 PUSH2 0x2886 0E5C 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0E57 stack[-3] = 0x0e5d // @0E58 stack[-1] = 0x20 * stack[-1] + stack[-3] // @0E58 stack[-2] = 0x20 * stack[-1] + stack[-3] + 0x20 // } // Block ends with call to 0x2886, returns to 0x0E5D label_0E5D: // Incoming return from call to 0x2886 at 0x0E5C // Inputs[2] // { // @0E61 stack[-3] // @0E62 stack[-4] // } 0E5D 5B JUMPDEST 0E5E 61 PUSH2 0x0e67 0E61 83 DUP4 0E62 85 DUP6 0E63 61 PUSH2 0x2c6a 0E66 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E5E stack[0] = 0x0e67 // @0E61 stack[1] = stack[-3] // @0E62 stack[2] = stack[-4] // } // Block ends with call to 0x2c6a, returns to 0x0E67 label_0E67: // Incoming return from call to 0x2C6A at 0x13D0 // Incoming return from call to 0x2C6A at 0x0E66 // Incoming return from call to 0x2C6A at 0x1974 0E67 5B JUMPDEST 0E68 61 PUSH2 0x1e8d 0E6B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1e8d label_0E6C: // Incoming return from call to 0x0E48 at 0x0E40 // Inputs[1] { @0E70 storage[0x0c] } 0E6C 5B JUMPDEST 0E6D 60 PUSH1 0x0c 0E6F 80 DUP1 0E70 54 SLOAD 0E71 90 SWAP1 0E72 60 PUSH1 0x00 0E74 61 PUSH2 0x0e7c 0E77 83 DUP4 0E78 61 PUSH2 0x2d33 0E7B 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0E71 stack[0] = storage[0x0c] // @0E71 stack[1] = 0x0c // @0E72 stack[2] = 0x00 // @0E74 stack[3] = 0x0e7c // @0E77 stack[4] = storage[0x0c] // } // Block ends with call to 0x2d33, returns to 0x0E7C label_0E7C: // Incoming return from call to 0x2D33 at 0x0E7B // Inputs[4] // { // @0E7D stack[-1] // @0E7D stack[-3] // @0E7E stack[-2] // @0E82 stack[-5] // } 0E7C 5B JUMPDEST 0E7D 91 SWAP2 0E7E 90 SWAP1 0E7F 50 POP 0E80 55 SSTORE 0E81 50 POP 0E82 80 DUP1 0E83 80 DUP1 0E84 61 PUSH2 0x0e8c 0E87 90 SWAP1 0E88 61 PUSH2 0x2d33 0E8B 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0E80 storage[stack[-3]] = stack[-1] // @0E82 stack[-4] = stack[-5] // @0E87 stack[-2] = stack[-5] // @0E87 stack[-3] = 0x0e8c // } // Block ends with call to 0x2d33, returns to 0x0E8C label_0E8C: // Incoming return from call to 0x2D33 at 0x0E8B // Inputs[2] // { // @0E8D stack[-3] // @0E8D stack[-1] // } 0E8C 5B JUMPDEST 0E8D 91 SWAP2 0E8E 50 POP 0E8F 50 POP 0E90 61 PUSH2 0x0e2b 0E93 56 *JUMP // Stack delta = -2 // Outputs[1] { @0E8D stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0e2b label_0E94: // Incoming jump from 0x1F21, if stack[-1] // Incoming jump from 0x2CEF, if !(stack[-1] > stack[-4]) // Incoming return from call to 0x1F06 at 0x1545 // Incoming jump from 0x0E33, if !(0x00 < stack[-2]) // Incoming jump from 0x0E33, if !(stack[-1] < stack[-3]) // Inputs[1] { @0E99 stack[-5] } 0E94 5B JUMPDEST 0E95 50 POP 0E96 50 POP 0E97 50 POP 0E98 50 POP 0E99 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0E9A: // Incoming jump from 0x0502 // Inputs[1] { @0EA2 storage[0x08] } 0E9A 5B JUMPDEST 0E9B 60 PUSH1 0x00 0E9D 61 PUSH2 0x0ea5 0EA0 60 PUSH1 0x08 0EA2 54 SLOAD 0EA3 90 SWAP1 0EA4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0E9B stack[0] = 0x00 // @0EA3 stack[1] = storage[0x08] // } // Block ends with unconditional jump to 0x0ea5 label_0EA5: // Incoming jump from 0x0EA4 // Inputs[2] // { // @0EA6 stack[-3] // @0EA7 stack[-1] // } 0EA5 5B JUMPDEST 0EA6 82 DUP3 0EA7 10 LT 0EA8 61 PUSH2 0x0f19 0EAB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f19, if stack[-3] < stack[-1] label_0EAC: // Incoming jump from 0x0EAB, if not stack[-3] < stack[-1] // Inputs[1] { @0EAE memory[0x40:0x60] } 0EAC 60 PUSH1 0x40 0EAE 51 MLOAD 0EAF 62 PUSH3 0x461bcd 0EB3 60 PUSH1 0xe5 0EB5 1B SHL 0EB6 81 DUP2 0EB7 52 MSTORE 0EB8 60 PUSH1 0x20 0EBA 60 PUSH1 0x04 0EBC 82 DUP3 0EBD 01 ADD 0EBE 52 MSTORE 0EBF 60 PUSH1 0x2c 0EC1 60 PUSH1 0x24 0EC3 82 DUP3 0EC4 01 ADD 0EC5 52 MSTORE 0EC6 7F PUSH32 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f 0EE7 60 PUSH1 0x44 0EE9 82 DUP3 0EEA 01 ADD 0EEB 52 MSTORE 0EEC 7F PUSH32 0x7574206f6620626f756e64730000000000000000000000000000000000000000 0F0D 60 PUSH1 0x64 0F0F 82 DUP3 0F10 01 ADD 0F11 52 MSTORE 0F12 60 PUSH1 0x84 0F14 01 ADD 0F15 61 PUSH2 0x08ec 0F18 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0EB7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EBE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0EC5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @0EEB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f // @0F11 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7574206f6620626f756e64730000000000000000000000000000000000000000 // @0F14 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_0F19: // Incoming jump from 0x0EAB, if stack[-3] < stack[-1] // Inputs[2] // { // @0F1C stack[-2] // @0F1E storage[0x08] // } 0F19 5B JUMPDEST 0F1A 60 PUSH1 0x08 0F1C 82 DUP3 0F1D 81 DUP2 0F1E 54 SLOAD 0F1F 81 DUP2 0F20 10 LT 0F21 61 PUSH2 0x0f2c 0F24 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0F1A stack[0] = 0x08 // @0F1C stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0f2c, if stack[-2] < storage[0x08] label_0F25: // Incoming jump from 0x0F24, if not stack[-2] < storage[0x08] 0F25 61 PUSH2 0x0f2c 0F28 61 PUSH2 0x2da4 0F2B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F25 stack[0] = 0x0f2c } // Block ends with unconditional jump to 0x2da4 label_0F2C: // Incoming jump from 0x0F24, if stack[-2] < storage[0x08] // Inputs[7] // { // @0F2D stack[-1] // @0F2D stack[-2] // @0F35 memory[0x00:0x20] // @0F37 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0F38 stack[-3] // @0F3A stack[-5] // @0F3B stack[-4] // } 0F2C 5B JUMPDEST 0F2D 90 SWAP1 0F2E 60 PUSH1 0x00 0F30 52 MSTORE 0F31 60 PUSH1 0x20 0F33 60 PUSH1 0x00 0F35 20 SHA3 0F36 01 ADD 0F37 54 SLOAD 0F38 90 SWAP1 0F39 50 POP 0F3A 91 SWAP2 0F3B 90 SWAP1 0F3C 50 POP 0F3D 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @0F30 memory[0x00:0x20] = stack[-2] // @0F3A stack[-5] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-5] label_0F3E: // Incoming jump from 0x0522 // Inputs[2] // { // @0F41 storage[0x0a] // @0F4B msg.sender // } 0F3E 5B JUMPDEST 0F3F 60 PUSH1 0x0a 0F41 54 SLOAD 0F42 60 PUSH1 0x01 0F44 60 PUSH1 0x01 0F46 60 PUSH1 0xa0 0F48 1B SHL 0F49 03 SUB 0F4A 16 AND 0F4B 33 CALLER 0F4C 14 EQ 0F4D 61 PUSH2 0x0f98 0F50 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f98, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] label_0F51: // Incoming jump from 0x0F50, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @0F53 memory[0x40:0x60] } 0F51 60 PUSH1 0x40 0F53 51 MLOAD 0F54 62 PUSH3 0x461bcd 0F58 60 PUSH1 0xe5 0F5A 1B SHL 0F5B 81 DUP2 0F5C 52 MSTORE 0F5D 60 PUSH1 0x20 0F5F 60 PUSH1 0x04 0F61 82 DUP3 0F62 01 ADD 0F63 81 DUP2 0F64 90 SWAP1 0F65 52 MSTORE 0F66 60 PUSH1 0x24 0F68 82 DUP3 0F69 01 ADD 0F6A 52 MSTORE 0F6B 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0F8C 60 PUSH1 0x44 0F8E 82 DUP3 0F8F 01 ADD 0F90 52 MSTORE 0F91 60 PUSH1 0x64 0F93 01 ADD 0F94 61 PUSH2 0x08ec 0F97 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0F5C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F65 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F6A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0F90 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0F93 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_0F98: // Incoming jump from 0x0F50, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[2] // { // @0F99 stack[-1] // @0F9A memory[stack[-1]:stack[-1] + 0x20] // } 0F98 5B JUMPDEST 0F99 80 DUP1 0F9A 51 MLOAD 0F9B 61 PUSH2 0x0fab 0F9E 90 SWAP1 0F9F 60 PUSH1 0x0d 0FA1 90 SWAP1 0FA2 60 PUSH1 0x20 0FA4 84 DUP5 0FA5 01 ADD 0FA6 90 SWAP1 0FA7 61 PUSH2 0x26ff 0FAA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F9E stack[0] = 0x0fab // @0FA1 stack[1] = 0x0d // @0FA6 stack[2] = stack[-1] + 0x20 // @0FA6 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x26ff label_0FAB: // Incoming return from call to 0x2228 at 0x1EA6 // Inputs[1] { @0FAE stack[-3] } 0FAB 5B JUMPDEST 0FAC 50 POP 0FAD 50 POP 0FAE 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0FAF: // Incoming call from 0x1C34, returns to 0x1C35 // Incoming jump from 0x055C // Incoming call from 0x091B, returns to 0x091C // Incoming call from 0x1B66, returns to 0x1B67 // Incoming call from 0x1CBA, returns to 0x1CBB // Inputs[3] // { // @0FB2 stack[-1] // @0FBD memory[0x00:0x40] // @0FBE storage[keccak256(memory[0x00:0x40])] // } 0FAF 5B JUMPDEST 0FB0 60 PUSH1 0x00 0FB2 81 DUP2 0FB3 81 DUP2 0FB4 52 MSTORE 0FB5 60 PUSH1 0x02 0FB7 60 PUSH1 0x20 0FB9 52 MSTORE 0FBA 60 PUSH1 0x40 0FBC 81 DUP2 0FBD 20 SHA3 0FBE 54 SLOAD 0FBF 60 PUSH1 0x01 0FC1 60 PUSH1 0x01 0FC3 60 PUSH1 0xa0 0FC5 1B SHL 0FC6 03 SUB 0FC7 16 AND 0FC8 80 DUP1 0FC9 61 PUSH2 0x07ce 0FCC 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0FB0 stack[0] = 0x00 // @0FB4 memory[0x00:0x20] = stack[-1] // @0FB9 memory[0x20:0x40] = 0x02 // @0FC7 stack[1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x07ce, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_0FCD: // Incoming jump from 0x0FCC, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0FCF memory[0x40:0x60] } 0FCD 60 PUSH1 0x40 0FCF 51 MLOAD 0FD0 62 PUSH3 0x461bcd 0FD4 60 PUSH1 0xe5 0FD6 1B SHL 0FD7 81 DUP2 0FD8 52 MSTORE 0FD9 60 PUSH1 0x20 0FDB 60 PUSH1 0x04 0FDD 82 DUP3 0FDE 01 ADD 0FDF 52 MSTORE 0FE0 60 PUSH1 0x29 0FE2 60 PUSH1 0x24 0FE4 82 DUP3 0FE5 01 ADD 0FE6 52 MSTORE 0FE7 7F PUSH32 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 1008 60 PUSH1 0x44 100A 82 DUP3 100B 01 ADD 100C 52 MSTORE 100D 7F PUSH32 0x656e7420746f6b656e0000000000000000000000000000000000000000000000 102E 60 PUSH1 0x64 1030 82 DUP3 1031 01 ADD 1032 52 MSTORE 1033 60 PUSH1 0x84 1035 01 ADD 1036 61 PUSH2 0x08ec 1039 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0FD8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FDF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0FE6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @100C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 // @1032 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x656e7420746f6b656e0000000000000000000000000000000000000000000000 // @1035 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_103A: // Incoming call from 0x0571, returns to 0x030A // Inputs[1] { @103E storage[0x0d] } 103A 5B JUMPDEST 103B 60 PUSH1 0x0d 103D 80 DUP1 103E 54 SLOAD 103F 61 PUSH2 0x1047 1042 90 SWAP1 1043 61 PUSH2 0x2cf8 1046 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @103B stack[0] = 0x0d // @1042 stack[1] = 0x1047 // @1042 stack[2] = storage[0x0d] // } // Block ends with call to 0x2cf8, returns to 0x1047 label_1047: // Incoming return from call to 0x2CF8 at 0x1046 // Inputs[4] // { // @1048 stack[-1] // @1057 memory[0x40:0x60] // @105F stack[-2] // @106A storage[stack[-2]] // } 1047 5B JUMPDEST 1048 80 DUP1 1049 60 PUSH1 0x1f 104B 01 ADD 104C 60 PUSH1 0x20 104E 80 DUP1 104F 91 SWAP2 1050 04 DIV 1051 02 MUL 1052 60 PUSH1 0x20 1054 01 ADD 1055 60 PUSH1 0x40 1057 51 MLOAD 1058 90 SWAP1 1059 81 DUP2 105A 01 ADD 105B 60 PUSH1 0x40 105D 52 MSTORE 105E 80 DUP1 105F 92 SWAP3 1060 91 SWAP2 1061 90 SWAP1 1062 81 DUP2 1063 81 DUP2 1064 52 MSTORE 1065 60 PUSH1 0x20 1067 01 ADD 1068 82 DUP3 1069 80 DUP1 106A 54 SLOAD 106B 61 PUSH2 0x1073 106E 90 SWAP1 106F 61 PUSH2 0x2cf8 1072 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @105D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @105F stack[-2] = memory[0x40:0x60] // @1060 stack[-1] = stack[-2] // @1061 stack[0] = stack[-1] // @1064 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1067 stack[1] = 0x20 + memory[0x40:0x60] // @1068 stack[2] = stack[-2] // @106E stack[4] = storage[stack[-2]] // @106E stack[3] = 0x1073 // } // Block ends with call to 0x2cf8, returns to 0x1073 label_1073: // Incoming return from call to 0x2CF8 at 0x1072 // Inputs[1] { @1074 stack[-1] } 1073 5B JUMPDEST 1074 80 DUP1 1075 15 ISZERO 1076 61 PUSH2 0x10c0 1079 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10c0, if !stack[-1] label_107A: // Incoming jump from 0x1079, if not !stack[-1] // Inputs[1] { @107A stack[-1] } 107A 80 DUP1 107B 60 PUSH1 0x1f 107D 10 LT 107E 61 PUSH2 0x1095 1081 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1095, if 0x1f < stack[-1] label_1082: // Incoming jump from 0x1081, if not 0x1f < stack[-1] // Inputs[4] // { // @1086 stack[-2] // @1087 storage[stack[-2]] // @108A stack[-3] // @108C stack[-1] // } 1082 61 PUSH2 0x0100 1085 80 DUP1 1086 83 DUP4 1087 54 SLOAD 1088 04 DIV 1089 02 MUL 108A 83 DUP4 108B 52 MSTORE 108C 91 SWAP2 108D 60 PUSH1 0x20 108F 01 ADD 1090 91 SWAP2 1091 61 PUSH2 0x10c0 1094 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @108B memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1090 stack[-1] = stack[-1] // @1090 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x10c0 label_1095: // Incoming jump from 0x1081, if 0x1f < stack[-1] // Inputs[5] // { // @1096 stack[-3] // @1097 stack[-1] // @1099 stack[-2] // @10A1 memory[0x00:0x20] // @10A5 storage[keccak256(memory[0x00:0x20])] // } 1095 5B JUMPDEST 1096 82 DUP3 1097 01 ADD 1098 91 SWAP2 1099 90 SWAP1 109A 60 PUSH1 0x00 109C 52 MSTORE 109D 60 PUSH1 0x20 109F 60 PUSH1 0x00 10A1 20 SHA3 10A2 90 SWAP1 10A3 5B JUMPDEST 10A4 81 DUP2 10A5 54 SLOAD 10A6 81 DUP2 10A7 52 MSTORE 10A8 90 SWAP1 10A9 60 PUSH1 0x01 10AB 01 ADD 10AC 90 SWAP1 10AD 60 PUSH1 0x20 10AF 01 ADD 10B0 80 DUP1 10B1 83 DUP4 10B2 11 GT 10B3 61 PUSH2 0x10a3 10B6 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1098 stack[-3] = stack[-3] + stack[-1] // @109C memory[0x00:0x20] = stack[-2] // @10A7 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @10AC stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @10AF stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x10a3, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_10B7: // Incoming jump from 0x10B6, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x10B6, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @10B7 stack[-3] // @10B8 stack[-1] // } 10B7 82 DUP3 10B8 90 SWAP1 10B9 03 SUB 10BA 60 PUSH1 0x1f 10BC 16 AND 10BD 82 DUP3 10BE 01 ADD 10BF 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @10BF stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @10BF stack[-1] = stack[-3] // } // Block continues label_10C0: // Incoming jump from 0x1094 // Incoming jump from 0x1079, if !stack[-1] // Incoming jump from 0x10BF // Inputs[1] { @10C6 stack[-7] } 10C0 5B JUMPDEST 10C1 50 POP 10C2 50 POP 10C3 50 POP 10C4 50 POP 10C5 50 POP 10C6 81 DUP2 10C7 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_10C8: // Incoming call from 0x2420, returns to 0x2421 // Incoming call from 0x0B41, returns to 0x0B42 // Incoming call from 0x256A, returns to 0x256B // Incoming call from 0x16E3, returns to 0x16E4 // Incoming jump from 0x0591 // Inputs[1] { @10D3 stack[-1] } 10C8 5B JUMPDEST 10C9 60 PUSH1 0x00 10CB 60 PUSH1 0x01 10CD 60 PUSH1 0x01 10CF 60 PUSH1 0xa0 10D1 1B SHL 10D2 03 SUB 10D3 82 DUP3 10D4 16 AND 10D5 61 PUSH2 0x1146 10D8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @10C9 stack[0] = 0x00 } // Block ends with conditional jump to 0x1146, if stack[-1] & (0x01 << 0xa0) - 0x01 label_10D9: // Incoming jump from 0x10D8, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @10DB memory[0x40:0x60] } 10D9 60 PUSH1 0x40 10DB 51 MLOAD 10DC 62 PUSH3 0x461bcd 10E0 60 PUSH1 0xe5 10E2 1B SHL 10E3 81 DUP2 10E4 52 MSTORE 10E5 60 PUSH1 0x20 10E7 60 PUSH1 0x04 10E9 82 DUP3 10EA 01 ADD 10EB 52 MSTORE 10EC 60 PUSH1 0x2a 10EE 60 PUSH1 0x24 10F0 82 DUP3 10F1 01 ADD 10F2 52 MSTORE 10F3 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 1114 60 PUSH1 0x44 1116 82 DUP3 1117 01 ADD 1118 52 MSTORE 1119 7F PUSH32 0x726f206164647265737300000000000000000000000000000000000000000000 113A 60 PUSH1 0x64 113C 82 DUP3 113D 01 ADD 113E 52 MSTORE 113F 60 PUSH1 0x84 1141 01 ADD 1142 61 PUSH2 0x08ec 1145 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @10E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10EB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10F2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @1118 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 // @113E memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x726f206164647265737300000000000000000000000000000000000000000000 // @1141 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_1146: // Incoming jump from 0x10D8, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @1150 stack[-2] // @115E memory[0x00:0x40] // @115F storage[keccak256(memory[0x00:0x40])] // @1160 stack[-3] // } 1146 5B JUMPDEST 1147 50 POP 1148 60 PUSH1 0x01 114A 60 PUSH1 0x01 114C 60 PUSH1 0xa0 114E 1B SHL 114F 03 SUB 1150 16 AND 1151 60 PUSH1 0x00 1153 90 SWAP1 1154 81 DUP2 1155 52 MSTORE 1156 60 PUSH1 0x03 1158 60 PUSH1 0x20 115A 52 MSTORE 115B 60 PUSH1 0x40 115D 90 SWAP1 115E 20 SHA3 115F 54 SLOAD 1160 90 SWAP1 1161 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @1155 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @115A memory[0x20:0x40] = 0x03 // @1160 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1162: // Incoming call from 0x05A6, returns to 0x036F // Inputs[2] // { // @1165 storage[0x0a] // @116F msg.sender // } 1162 5B JUMPDEST 1163 60 PUSH1 0x0a 1165 54 SLOAD 1166 60 PUSH1 0x01 1168 60 PUSH1 0x01 116A 60 PUSH1 0xa0 116C 1B SHL 116D 03 SUB 116E 16 AND 116F 33 CALLER 1170 14 EQ 1171 61 PUSH2 0x11bc 1174 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11bc, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] label_1175: // Incoming jump from 0x1174, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @1177 memory[0x40:0x60] } 1175 60 PUSH1 0x40 1177 51 MLOAD 1178 62 PUSH3 0x461bcd 117C 60 PUSH1 0xe5 117E 1B SHL 117F 81 DUP2 1180 52 MSTORE 1181 60 PUSH1 0x20 1183 60 PUSH1 0x04 1185 82 DUP3 1186 01 ADD 1187 81 DUP2 1188 90 SWAP1 1189 52 MSTORE 118A 60 PUSH1 0x24 118C 82 DUP3 118D 01 ADD 118E 52 MSTORE 118F 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 11B0 60 PUSH1 0x44 11B2 82 DUP3 11B3 01 ADD 11B4 52 MSTORE 11B5 60 PUSH1 0x64 11B7 01 ADD 11B8 61 PUSH2 0x08ec 11BB 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1180 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1189 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @118E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @11B4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @11B7 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_11BC: // Incoming jump from 0x1174, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] 11BC 5B JUMPDEST 11BD 61 PUSH2 0x11c6 11C0 60 PUSH1 0x00 11C2 61 PUSH2 0x1ea7 11C5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @11BD stack[0] = 0x11c6 // @11C0 stack[1] = 0x00 // } // Block ends with call to 0x1ea7, returns to 0x11C6 label_11C6: // Incoming return from call to 0x1EA7 at 0x11C5 // Inputs[1] { @11C7 stack[-1] } 11C6 5B JUMPDEST 11C7 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_11C8: // Incoming call from 0x0620, returns to 0x030A // Inputs[2] // { // @11CB memory[0x40:0x60] // @11E2 stack[-1] // } 11C8 5B JUMPDEST 11C9 60 PUSH1 0x40 11CB 51 MLOAD 11CC 80 DUP1 11CD 60 PUSH1 0x60 11CF 01 ADD 11D0 60 PUSH1 0x40 11D2 52 MSTORE 11D3 80 DUP1 11D4 60 PUSH1 0x40 11D6 81 DUP2 11D7 52 MSTORE 11D8 60 PUSH1 0x20 11DA 01 ADD 11DB 61 PUSH2 0x2de7 11DE 60 PUSH1 0x40 11E0 91 SWAP2 11E1 39 CODECOPY 11E2 81 DUP2 11E3 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @11CB stack[0] = memory[0x40:0x60] // @11D2 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @11D7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x40 // @11E1 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x40] = code[0x2de7:0x2e27] // } // Block ends with unconditional jump to stack[-1] label_11E4: // Incoming call from 0x0635, returns to 0x030A // Inputs[1] { @11EA storage[0x01] } 11E4 5B JUMPDEST 11E5 60 PUSH1 0x60 11E7 60 PUSH1 0x01 11E9 80 DUP1 11EA 54 SLOAD 11EB 61 PUSH2 0x07e3 11EE 90 SWAP1 11EF 61 PUSH2 0x2cf8 11F2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @11E5 stack[0] = 0x60 // @11E7 stack[1] = 0x01 // @11EE stack[2] = 0x07e3 // @11EE stack[3] = storage[0x01] // } // Block ends with call to 0x2cf8, returns to 0x07E3 label_11F3: // Incoming jump from 0x0667 // Inputs[1] { @11F6 storage[0x0e] } 11F3 5B JUMPDEST 11F4 60 PUSH1 0x0e 11F6 54 SLOAD 11F7 60 PUSH1 0xff 11F9 16 AND 11FA 15 ISZERO 11FB 80 DUP1 11FC 15 ISZERO 11FD 61 PUSH2 0x120e 1200 57 *JUMPI // Stack delta = +1 // Outputs[1] { @11FA stack[0] = !(0xff & storage[0x0e]) } // Block ends with conditional jump to 0x120e, if !!(0xff & storage[0x0e]) label_1201: // Incoming jump from 0x1200, if not !!(0xff & storage[0x0e]) // Inputs[1] { @1204 storage[0x0e] } 1201 50 POP 1202 60 PUSH1 0x0e 1204 54 SLOAD 1205 61 PUSH2 0x0100 1208 90 SWAP1 1209 04 DIV 120A 60 PUSH1 0xff 120C 16 AND 120D 15 ISZERO 120E 5B JUMPDEST 120F 61 PUSH2 0x125a 1212 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x125a, if !(0xff & storage[0x0e] / 0x0100) label_1213: // Incoming jump from 0x1212, if not !(0xff & storage[0x0e] / 0x0100) // Incoming jump from 0x1212, if not stack[-1] // Inputs[1] { @1215 memory[0x40:0x60] } 1213 60 PUSH1 0x40 1215 51 MLOAD 1216 62 PUSH3 0x461bcd 121A 60 PUSH1 0xe5 121C 1B SHL 121D 81 DUP2 121E 52 MSTORE 121F 60 PUSH1 0x20 1221 60 PUSH1 0x04 1223 82 DUP3 1224 01 ADD 1225 52 MSTORE 1226 60 PUSH1 0x0c 1228 60 PUSH1 0x24 122A 82 DUP3 122B 01 ADD 122C 52 MSTORE 122D 7F PUSH32 0x53616c6520636c6f7365642e0000000000000000000000000000000000000000 124E 60 PUSH1 0x44 1250 82 DUP3 1251 01 ADD 1252 52 MSTORE 1253 60 PUSH1 0x64 1255 01 ADD 1256 61 PUSH2 0x08ec 1259 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @121E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1225 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @122C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @1252 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53616c6520636c6f7365642e0000000000000000000000000000000000000000 // @1255 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_125A: // Incoming jump from 0x1212, if !(0xff & storage[0x0e] / 0x0100) // Incoming jump from 0x1212, if stack[-1] // Inputs[1] { @125D stack[-1] } 125A 5B JUMPDEST 125B 60 PUSH1 0x0a 125D 81 DUP2 125E 11 GT 125F 15 ISZERO 1260 61 PUSH2 0x12ab 1263 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12ab, if !(stack[-1] > 0x0a) label_1264: // Incoming jump from 0x1263, if not !(stack[-1] > 0x0a) // Inputs[1] { @1266 memory[0x40:0x60] } 1264 60 PUSH1 0x40 1266 51 MLOAD 1267 62 PUSH3 0x461bcd 126B 60 PUSH1 0xe5 126D 1B SHL 126E 81 DUP2 126F 52 MSTORE 1270 60 PUSH1 0x20 1272 60 PUSH1 0x04 1274 82 DUP3 1275 01 ADD 1276 52 MSTORE 1277 60 PUSH1 0x13 1279 60 PUSH1 0x24 127B 82 DUP3 127C 01 ADD 127D 52 MSTORE 127E 7F PUSH32 0x457863656564206d617820706572206d696e7400000000000000000000000000 129F 60 PUSH1 0x44 12A1 82 DUP3 12A2 01 ADD 12A3 52 MSTORE 12A4 60 PUSH1 0x64 12A6 01 ADD 12A7 61 PUSH2 0x08ec 12AA 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @126F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1276 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @127D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x13 // @12A3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x457863656564206d617820706572206d696e7400000000000000000000000000 // @12A6 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_12AB: // Incoming jump from 0x1263, if !(stack[-1] > 0x0a) // Inputs[1] { @12B3 storage[0x08] } 12AB 5B JUMPDEST 12AC 60 PUSH1 0x00 12AE 61 PUSH2 0x12b6 12B1 60 PUSH1 0x08 12B3 54 SLOAD 12B4 90 SWAP1 12B5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @12AC stack[0] = 0x00 // @12B4 stack[1] = storage[0x08] // } // Block ends with unconditional jump to 0x12b6 label_12B6: // Incoming jump from 0x12B5 // Inputs[2] // { // @12B7 stack[-2] // @12B7 stack[-1] // } 12B6 5B JUMPDEST 12B7 90 SWAP1 12B8 50 POP 12B9 61 PUSH2 0x05dd 12BC 81 DUP2 12BD 10 LT 12BE 61 PUSH2 0x12f9 12C1 57 *JUMPI // Stack delta = -1 // Outputs[1] { @12B7 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x12f9, if stack[-1] < 0x05dd label_12C2: // Incoming jump from 0x12C1, if not stack[-1] < 0x05dd // Inputs[1] { @12C4 memory[0x40:0x60] } 12C2 60 PUSH1 0x40 12C4 51 MLOAD 12C5 62 PUSH3 0x461bcd 12C9 60 PUSH1 0xe5 12CB 1B SHL 12CC 81 DUP2 12CD 52 MSTORE 12CE 60 PUSH1 0x20 12D0 60 PUSH1 0x04 12D2 82 DUP3 12D3 01 ADD 12D4 52 MSTORE 12D5 60 PUSH1 0x0d 12D7 60 PUSH1 0x24 12D9 82 DUP3 12DA 01 ADD 12DB 52 MSTORE 12DC 6C PUSH13 0x27baba1037b31039ba37b1b597 12EA 60 PUSH1 0x99 12EC 1B SHL 12ED 60 PUSH1 0x44 12EF 82 DUP3 12F0 01 ADD 12F1 52 MSTORE 12F2 60 PUSH1 0x64 12F4 01 ADD 12F5 61 PUSH2 0x08ec 12F8 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @12CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12D4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @12DB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0d // @12F1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x27baba1037b31039ba37b1b597 << 0x99 // @12F4 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_12F9: // Incoming jump from 0x12C1, if stack[-1] < 0x05dd // Inputs[2] // { // @12FD stack[-2] // @1300 storage[0x0b] // } 12F9 5B JUMPDEST 12FA 61 PUSH2 0x0457 12FD 82 DUP3 12FE 60 PUSH1 0x0b 1300 54 SLOAD 1301 61 PUSH2 0x130a 1304 91 SWAP2 1305 90 SWAP1 1306 61 PUSH2 0x2c6a 1309 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @12FA stack[0] = 0x0457 // @1304 stack[1] = 0x130a // @1305 stack[2] = stack[-2] // @1305 stack[3] = storage[0x0b] // } // Block ends with call to 0x2c6a, returns to 0x130A label_130A: // Incoming return from call to 0x2C6A at 0x1309 // Inputs[2] // { // @130B stack[-1] // @130B stack[-2] // } 130A 5B JUMPDEST 130B 11 GT 130C 15 ISZERO 130D 61 PUSH2 0x1358 1310 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1358, if !(stack[-1] > stack[-2]) label_1311: // Incoming jump from 0x1310, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1313 memory[0x40:0x60] } 1311 60 PUSH1 0x40 1313 51 MLOAD 1314 62 PUSH3 0x461bcd 1318 60 PUSH1 0xe5 131A 1B SHL 131B 81 DUP2 131C 52 MSTORE 131D 60 PUSH1 0x20 131F 60 PUSH1 0x04 1321 82 DUP3 1322 01 ADD 1323 52 MSTORE 1324 60 PUSH1 0x14 1326 60 PUSH1 0x24 1328 82 DUP3 1329 01 ADD 132A 52 MSTORE 132B 7F PUSH32 0x5075626c6963206d696e74206578636565646564000000000000000000000000 134C 60 PUSH1 0x44 134E 82 DUP3 134F 01 ADD 1350 52 MSTORE 1351 60 PUSH1 0x64 1353 01 ADD 1354 61 PUSH2 0x08ec 1357 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @131C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1323 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @132A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @1350 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5075626c6963206d696e74206578636565646564000000000000000000000000 // @1353 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_1358: // Incoming jump from 0x1310, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @1359 msg.value // @135D stack[-2] // } 1358 5B JUMPDEST 1359 34 CALLVALUE 135A 61 PUSH2 0x136a 135D 83 DUP4 135E 66 PUSH7 0x8e1bc9bf040000 1366 61 PUSH2 0x2c96 1369 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1359 stack[0] = msg.value // @135A stack[1] = 0x136a // @135D stack[2] = stack[-2] // @135E stack[3] = 0x8e1bc9bf040000 // } // Block ends with call to 0x2c96, returns to 0x136A label_136A: // Incoming return from call to 0x2C96 at 0x1369 // Inputs[2] // { // @136B stack[-2] // @136B stack[-1] // } 136A 5B JUMPDEST 136B 11 GT 136C 15 ISZERO 136D 61 PUSH2 0x13b8 1370 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x13b8, if !(stack[-1] > stack[-2]) label_1371: // Incoming jump from 0x1370, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1373 memory[0x40:0x60] } 1371 60 PUSH1 0x40 1373 51 MLOAD 1374 62 PUSH3 0x461bcd 1378 60 PUSH1 0xe5 137A 1B SHL 137B 81 DUP2 137C 52 MSTORE 137D 60 PUSH1 0x20 137F 60 PUSH1 0x04 1381 82 DUP3 1382 01 ADD 1383 52 MSTORE 1384 60 PUSH1 0x10 1386 60 PUSH1 0x24 1388 82 DUP3 1389 01 ADD 138A 52 MSTORE 138B 7F PUSH32 0x496e73756666696369656e742045746800000000000000000000000000000000 13AC 60 PUSH1 0x44 13AE 82 DUP3 13AF 01 ADD 13B0 52 MSTORE 13B1 60 PUSH1 0x64 13B3 01 ADD 13B4 61 PUSH2 0x08ec 13B7 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @137C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1383 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @138A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @13B0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e73756666696369656e742045746800000000000000000000000000000000 // @13B3 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_13B8: // Incoming jump from 0x1370, if !(stack[-1] > stack[-2]) // Inputs[1] { @13BC stack[-2] } 13B8 5B JUMPDEST 13B9 60 PUSH1 0x00 13BB 5B JUMPDEST 13BC 82 DUP3 13BD 81 DUP2 13BE 10 LT 13BF 15 ISZERO 13C0 61 PUSH2 0x0a3e 13C3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @13B9 stack[0] = 0x00 } // Block ends with conditional jump to 0x0a3e, if !(0x00 < stack[-2]) label_13C4: // Incoming jump from 0x13C3, if not !(0x00 < stack[-2]) // Incoming jump from 0x13C3, if not !(stack[-1] < stack[-3]) // Inputs[3] // { // @13C7 msg.sender // @13CB stack[-1] // @13CC stack[-2] // } 13C4 61 PUSH2 0x13d1 13C7 33 CALLER 13C8 61 PUSH2 0x0e67 13CB 83 DUP4 13CC 85 DUP6 13CD 61 PUSH2 0x2c6a 13D0 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @13C4 stack[0] = 0x13d1 // @13C7 stack[1] = msg.sender // @13C8 stack[2] = 0x0e67 // @13CB stack[3] = stack[-1] // @13CC stack[4] = stack[-2] // } // Block ends with call to 0x2c6a, returns to 0x0E67 label_13D1: // Incoming return from call to 0x0E67 at 0x13D0 // Inputs[1] { @13D5 storage[0x0b] } 13D1 5B JUMPDEST 13D2 60 PUSH1 0x0b 13D4 80 DUP1 13D5 54 SLOAD 13D6 90 SWAP1 13D7 60 PUSH1 0x00 13D9 61 PUSH2 0x13e1 13DC 83 DUP4 13DD 61 PUSH2 0x2d33 13E0 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @13D6 stack[0] = storage[0x0b] // @13D6 stack[1] = 0x0b // @13D7 stack[2] = 0x00 // @13D9 stack[3] = 0x13e1 // @13DC stack[4] = storage[0x0b] // } // Block ends with call to 0x2d33, returns to 0x13E1 label_13E1: // Incoming return from call to 0x2D33 at 0x13E0 // Inputs[4] // { // @13E2 stack[-1] // @13E2 stack[-3] // @13E3 stack[-2] // @13E7 stack[-5] // } 13E1 5B JUMPDEST 13E2 91 SWAP2 13E3 90 SWAP1 13E4 50 POP 13E5 55 SSTORE 13E6 50 POP 13E7 80 DUP1 13E8 80 DUP1 13E9 61 PUSH2 0x13f1 13EC 90 SWAP1 13ED 61 PUSH2 0x2d33 13F0 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @13E5 storage[stack[-3]] = stack[-1] // @13E7 stack[-4] = stack[-5] // @13EC stack[-2] = stack[-5] // @13EC stack[-3] = 0x13f1 // } // Block ends with call to 0x2d33, returns to 0x13F1 label_13F1: // Incoming return from call to 0x2D33 at 0x13F0 // Inputs[2] // { // @13F2 stack[-3] // @13F2 stack[-1] // } 13F1 5B JUMPDEST 13F2 91 SWAP2 13F3 50 POP 13F4 50 POP 13F5 61 PUSH2 0x13bb 13F8 56 *JUMP // Stack delta = -2 // Outputs[1] { @13F2 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x13bb label_13F9: // Incoming jump from 0x0687 // Inputs[2] // { // @1402 stack[-2] // @1404 msg.sender // } 13F9 5B JUMPDEST 13FA 60 PUSH1 0x01 13FC 60 PUSH1 0x01 13FE 60 PUSH1 0xa0 1400 1B SHL 1401 03 SUB 1402 82 DUP3 1403 16 AND 1404 33 CALLER 1405 14 EQ 1406 15 ISZERO 1407 61 PUSH2 0x1452 140A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1452, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) label_140B: // Incoming jump from 0x140A, if not !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[1] { @140D memory[0x40:0x60] } 140B 60 PUSH1 0x40 140D 51 MLOAD 140E 62 PUSH3 0x461bcd 1412 60 PUSH1 0xe5 1414 1B SHL 1415 81 DUP2 1416 52 MSTORE 1417 60 PUSH1 0x20 1419 60 PUSH1 0x04 141B 82 DUP3 141C 01 ADD 141D 52 MSTORE 141E 60 PUSH1 0x19 1420 60 PUSH1 0x24 1422 82 DUP3 1423 01 ADD 1424 52 MSTORE 1425 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 1446 60 PUSH1 0x44 1448 82 DUP3 1449 01 ADD 144A 52 MSTORE 144B 60 PUSH1 0x64 144D 01 ADD 144E 61 PUSH2 0x08ec 1451 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1416 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @141D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1424 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @144A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @144D stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_1452: // Incoming jump from 0x140A, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[10] // { // @1453 msg.sender // @1464 memory[0x00:0x40] // @146D stack[-2] // @1478 memory[0x00:0x40] // @147A storage[keccak256(memory[0x00:0x40])] // @147F stack[-1] // @1489 memory[0x40:0x60] // @14B5 memory[0x40:0x60] // @14BA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @14BD stack[-3] // } 1452 5B JUMPDEST 1453 33 CALLER 1454 60 PUSH1 0x00 1456 81 DUP2 1457 81 DUP2 1458 52 MSTORE 1459 60 PUSH1 0x05 145B 60 PUSH1 0x20 145D 90 SWAP1 145E 81 DUP2 145F 52 MSTORE 1460 60 PUSH1 0x40 1462 80 DUP1 1463 83 DUP4 1464 20 SHA3 1465 60 PUSH1 0x01 1467 60 PUSH1 0x01 1469 60 PUSH1 0xa0 146B 1B SHL 146C 03 SUB 146D 87 DUP8 146E 16 AND 146F 80 DUP1 1470 85 DUP6 1471 52 MSTORE 1472 90 SWAP1 1473 83 DUP4 1474 52 MSTORE 1475 92 SWAP3 1476 81 DUP2 1477 90 SWAP1 1478 20 SHA3 1479 80 DUP1 147A 54 SLOAD 147B 60 PUSH1 0xff 147D 19 NOT 147E 16 AND 147F 86 DUP7 1480 15 ISZERO 1481 15 ISZERO 1482 90 SWAP1 1483 81 DUP2 1484 17 OR 1485 90 SWAP1 1486 91 SWAP2 1487 55 SSTORE 1488 90 SWAP1 1489 51 MLOAD 148A 90 SWAP1 148B 81 DUP2 148C 52 MSTORE 148D 91 SWAP2 148E 92 SWAP3 148F 91 SWAP2 1490 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 14B1 91 SWAP2 14B2 01 ADD 14B3 60 PUSH1 0x40 14B5 51 MLOAD 14B6 80 DUP1 14B7 91 SWAP2 14B8 03 SUB 14B9 90 SWAP1 14BA A3 LOG3 14BB 50 POP 14BC 50 POP 14BD 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @1458 memory[0x00:0x20] = msg.sender // @145F memory[0x20:0x40] = 0x05 // @1471 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1474 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1487 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @148C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @14BA 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_14BE: // Incoming jump from 0x0D1F // Incoming jump from 0x06A7 // Inputs[2] // { // @14C2 msg.sender // @14C3 stack[-2] // } 14BE 5B JUMPDEST 14BF 61 PUSH2 0x14c8 14C2 33 CALLER 14C3 83 DUP4 14C4 61 PUSH2 0x1ba0 14C7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @14BF stack[0] = 0x14c8 // @14C2 stack[1] = msg.sender // @14C3 stack[2] = stack[-2] // } // Block ends with call to 0x1ba0, returns to 0x14C8 label_14C8: // Incoming return from call to 0x1BA0 at 0x14C7 // Inputs[1] { @14CC stack[-1] } 14C8 5B JUMPDEST 14C9 61 PUSH2 0x153a 14CC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x153a, if stack[-1] label_14CD: // Incoming jump from 0x14CC, if not stack[-1] // Inputs[1] { @14CF memory[0x40:0x60] } 14CD 60 PUSH1 0x40 14CF 51 MLOAD 14D0 62 PUSH3 0x461bcd 14D4 60 PUSH1 0xe5 14D6 1B SHL 14D7 81 DUP2 14D8 52 MSTORE 14D9 60 PUSH1 0x20 14DB 60 PUSH1 0x04 14DD 82 DUP3 14DE 01 ADD 14DF 52 MSTORE 14E0 60 PUSH1 0x31 14E2 60 PUSH1 0x24 14E4 82 DUP3 14E5 01 ADD 14E6 52 MSTORE 14E7 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 1508 60 PUSH1 0x44 150A 82 DUP3 150B 01 ADD 150C 52 MSTORE 150D 7F PUSH32 0x776e6572206e6f7220617070726f766564000000000000000000000000000000 152E 60 PUSH1 0x64 1530 82 DUP3 1531 01 ADD 1532 52 MSTORE 1533 60 PUSH1 0x84 1535 01 ADD 1536 61 PUSH2 0x08ec 1539 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @14D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @14DF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @14E6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x31 // @150C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f // @1532 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x776e6572206e6f7220617070726f766564000000000000000000000000000000 // @1535 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_153A: // Incoming jump from 0x14CC, if stack[-1] // Inputs[4] // { // @153E stack[-4] // @153F stack[-3] // @1540 stack[-2] // @1541 stack[-1] // } 153A 5B JUMPDEST 153B 61 PUSH2 0x0e94 153E 84 DUP5 153F 84 DUP5 1540 84 DUP5 1541 84 DUP5 1542 61 PUSH2 0x1f06 1545 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @153B stack[0] = 0x0e94 // @153E stack[1] = stack[-4] // @153F stack[2] = stack[-3] // @1540 stack[3] = stack[-2] // @1541 stack[4] = stack[-1] // } // Block ends with call to 0x1f06, returns to 0x0E94 label_1546: // Incoming jump from 0x06F8 // Inputs[3] // { // @1549 stack[-1] // @1554 memory[0x00:0x40] // @1555 storage[keccak256(memory[0x00:0x40])] // } 1546 5B JUMPDEST 1547 60 PUSH1 0x00 1549 81 DUP2 154A 81 DUP2 154B 52 MSTORE 154C 60 PUSH1 0x02 154E 60 PUSH1 0x20 1550 52 MSTORE 1551 60 PUSH1 0x40 1553 90 SWAP1 1554 20 SHA3 1555 54 SLOAD 1556 60 PUSH1 0x60 1558 90 SWAP1 1559 60 PUSH1 0x01 155B 60 PUSH1 0x01 155D 60 PUSH1 0xa0 155F 1B SHL 1560 03 SUB 1561 16 AND 1562 61 PUSH2 0x15d3 1565 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @154B memory[0x00:0x20] = stack[-1] // @1550 memory[0x20:0x40] = 0x02 // @1558 stack[0] = 0x60 // } // Block ends with conditional jump to 0x15d3, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_1566: // Incoming jump from 0x1565, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1568 memory[0x40:0x60] } 1566 60 PUSH1 0x40 1568 51 MLOAD 1569 62 PUSH3 0x461bcd 156D 60 PUSH1 0xe5 156F 1B SHL 1570 81 DUP2 1571 52 MSTORE 1572 60 PUSH1 0x20 1574 60 PUSH1 0x04 1576 82 DUP3 1577 01 ADD 1578 52 MSTORE 1579 60 PUSH1 0x2f 157B 60 PUSH1 0x24 157D 82 DUP3 157E 01 ADD 157F 52 MSTORE 1580 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 15A1 60 PUSH1 0x44 15A3 82 DUP3 15A4 01 ADD 15A5 52 MSTORE 15A6 7F PUSH32 0x6e6578697374656e7420746f6b656e0000000000000000000000000000000000 15C7 60 PUSH1 0x64 15C9 82 DUP3 15CA 01 ADD 15CB 52 MSTORE 15CC 60 PUSH1 0x84 15CE 01 ADD 15CF 61 PUSH2 0x08ec 15D2 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1571 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1578 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @157F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @15A5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @15CB memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6e6578697374656e7420746f6b656e0000000000000000000000000000000000 // @15CE stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_15D3: // Incoming jump from 0x1565, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @15D9 stack[-2] } 15D3 5B JUMPDEST 15D4 60 PUSH1 0x0d 15D6 61 PUSH2 0x15de 15D9 83 DUP4 15DA 61 PUSH2 0x1f8f 15DD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @15D4 stack[0] = 0x0d // @15D6 stack[1] = 0x15de // @15D9 stack[2] = stack[-2] // } // Block ends with call to 0x1f8f, returns to 0x15DE label_15DE: // Incoming return from call to 0x1F8F at 0x15DD // Inputs[4] // { // @15E1 memory[0x40:0x60] // @15FF memory[0x40:0x60] // @1606 stack[-2] // @1607 stack[-1] // } 15DE 5B JUMPDEST 15DF 60 PUSH1 0x40 15E1 51 MLOAD 15E2 80 DUP1 15E3 60 PUSH1 0x40 15E5 01 ADD 15E6 60 PUSH1 0x40 15E8 52 MSTORE 15E9 80 DUP1 15EA 60 PUSH1 0x05 15EC 81 DUP2 15ED 52 MSTORE 15EE 60 PUSH1 0x20 15F0 01 ADD 15F1 64 PUSH5 0x173539b7b7 15F7 60 PUSH1 0xd9 15F9 1B SHL 15FA 81 DUP2 15FB 52 MSTORE 15FC 50 POP 15FD 60 PUSH1 0x40 15FF 51 MLOAD 1600 60 PUSH1 0x20 1602 01 ADD 1603 61 PUSH2 0x160e 1606 93 SWAP4 1607 92 SWAP3 1608 91 SWAP2 1609 90 SWAP1 160A 61 PUSH2 0x2b74 160D 56 *JUMP // Stack delta = +3 // Outputs[8] // { // @15E8 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @15ED memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x05 // @15FB memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x173539b7b7 << 0xd9 // @1606 stack[-2] = 0x160e // @1607 stack[-1] = stack[-2] // @1608 stack[0] = stack[-1] // @1609 stack[1] = memory[0x40:0x60] // @1609 stack[2] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x2b74, returns to 0x160E label_160E: // Incoming return from call to 0x2B74 at 0x160D // Inputs[5] // { // @1611 memory[0x40:0x60] // @1615 stack[-1] // @161E stack[-2] // @1620 stack[-4] // @1621 stack[-3] // } 160E 5B JUMPDEST 160F 60 PUSH1 0x40 1611 51 MLOAD 1612 60 PUSH1 0x20 1614 81 DUP2 1615 83 DUP4 1616 03 SUB 1617 03 SUB 1618 81 DUP2 1619 52 MSTORE 161A 90 SWAP1 161B 60 PUSH1 0x40 161D 52 MSTORE 161E 90 SWAP1 161F 50 POP 1620 91 SWAP2 1621 90 SWAP1 1622 50 POP 1623 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1619 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @161D memory[0x40:0x60] = stack[-1] // @1620 stack[-4] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-4] label_1624: // Incoming jump from 0x070B // Inputs[1] { @1627 storage[0x0e] } 1624 5B JUMPDEST 1625 60 PUSH1 0x0e 1627 54 SLOAD 1628 60 PUSH1 0xff 162A 16 AND 162B 15 ISZERO 162C 80 DUP1 162D 15 ISZERO 162E 61 PUSH2 0x163e 1631 57 *JUMPI // Stack delta = +1 // Outputs[1] { @162B stack[0] = !(0xff & storage[0x0e]) } // Block ends with conditional jump to 0x163e, if !!(0xff & storage[0x0e]) label_1632: // Incoming jump from 0x1631, if not !!(0xff & storage[0x0e]) // Inputs[1] { @1635 storage[0x0e] } 1632 50 POP 1633 60 PUSH1 0x0e 1635 54 SLOAD 1636 61 PUSH2 0x0100 1639 90 SWAP1 163A 04 DIV 163B 60 PUSH1 0xff 163D 16 AND 163E 5B JUMPDEST 163F 61 PUSH2 0x168a 1642 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x168a, if 0xff & storage[0x0e] / 0x0100 label_1643: // Incoming jump from 0x1642, if not stack[-1] // Incoming jump from 0x1642, if not 0xff & storage[0x0e] / 0x0100 // Inputs[1] { @1645 memory[0x40:0x60] } 1643 60 PUSH1 0x40 1645 51 MLOAD 1646 62 PUSH3 0x461bcd 164A 60 PUSH1 0xe5 164C 1B SHL 164D 81 DUP2 164E 52 MSTORE 164F 60 PUSH1 0x20 1651 60 PUSH1 0x04 1653 82 DUP3 1654 01 ADD 1655 52 MSTORE 1656 60 PUSH1 0x0f 1658 60 PUSH1 0x24 165A 82 DUP3 165B 01 ADD 165C 52 MSTORE 165D 7F PUSH32 0x57686974656c697374206f6e6c792e0000000000000000000000000000000000 167E 60 PUSH1 0x44 1680 82 DUP3 1681 01 ADD 1682 52 MSTORE 1683 60 PUSH1 0x64 1685 01 ADD 1686 61 PUSH2 0x08ec 1689 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @164E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1655 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @165C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0f // @1682 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x57686974656c697374206f6e6c792e0000000000000000000000000000000000 // @1685 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_168A: // Incoming jump from 0x1642, if stack[-1] // Incoming jump from 0x1642, if 0xff & storage[0x0e] / 0x0100 // Inputs[1] { @168D stack[-3] } 168A 5B JUMPDEST 168B 60 PUSH1 0x0a 168D 83 DUP4 168E 11 GT 168F 15 ISZERO 1690 61 PUSH2 0x16db 1693 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x16db, if !(stack[-3] > 0x0a) label_1694: // Incoming jump from 0x1693, if not !(stack[-3] > 0x0a) // Inputs[1] { @1696 memory[0x40:0x60] } 1694 60 PUSH1 0x40 1696 51 MLOAD 1697 62 PUSH3 0x461bcd 169B 60 PUSH1 0xe5 169D 1B SHL 169E 81 DUP2 169F 52 MSTORE 16A0 60 PUSH1 0x20 16A2 60 PUSH1 0x04 16A4 82 DUP3 16A5 01 ADD 16A6 52 MSTORE 16A7 60 PUSH1 0x13 16A9 60 PUSH1 0x24 16AB 82 DUP3 16AC 01 ADD 16AD 52 MSTORE 16AE 7F PUSH32 0x457863656564206d617820706572206d696e7400000000000000000000000000 16CF 60 PUSH1 0x44 16D1 82 DUP3 16D2 01 ADD 16D3 52 MSTORE 16D4 60 PUSH1 0x64 16D6 01 ADD 16D7 61 PUSH2 0x08ec 16DA 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @169F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @16A6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @16AD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x13 // @16D3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x457863656564206d617820706572206d696e7400000000000000000000000000 // @16D6 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_16DB: // Incoming jump from 0x1693, if !(stack[-3] > 0x0a) // Inputs[1] { @16DF msg.sender } 16DB 5B JUMPDEST 16DC 61 PUSH2 0x16e4 16DF 33 CALLER 16E0 61 PUSH2 0x10c8 16E3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @16DC stack[0] = 0x16e4 // @16DF stack[1] = msg.sender // } // Block ends with call to 0x10c8, returns to 0x16E4 label_16E4: // Incoming return from call to 0x10C8 at 0x16E3 // Inputs[1] { @16E5 stack[-1] } 16E4 5B JUMPDEST 16E5 15 ISZERO 16E6 61 PUSH2 0x1757 16E9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1757, if !stack[-1] label_16EA: // Incoming jump from 0x16E9, if not !stack[-1] // Inputs[1] { @16EC memory[0x40:0x60] } 16EA 60 PUSH1 0x40 16EC 51 MLOAD 16ED 62 PUSH3 0x461bcd 16F1 60 PUSH1 0xe5 16F3 1B SHL 16F4 81 DUP2 16F5 52 MSTORE 16F6 60 PUSH1 0x20 16F8 60 PUSH1 0x04 16FA 82 DUP3 16FB 01 ADD 16FC 52 MSTORE 16FD 60 PUSH1 0x26 16FF 60 PUSH1 0x24 1701 82 DUP3 1702 01 ADD 1703 52 MSTORE 1704 7F PUSH32 0x4f6e6c79206f6e652077686974656c697374207472616e73616374696f6e2061 1725 60 PUSH1 0x44 1727 82 DUP3 1728 01 ADD 1729 52 MSTORE 172A 7F PUSH32 0x6c6c6f7765640000000000000000000000000000000000000000000000000000 174B 60 PUSH1 0x64 174D 82 DUP3 174E 01 ADD 174F 52 MSTORE 1750 60 PUSH1 0x84 1752 01 ADD 1753 61 PUSH2 0x08ec 1756 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @16F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @16FC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1703 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1729 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f6e6c79206f6e652077686974656c697374207472616e73616374696f6e2061 // @174F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6c6c6f7765640000000000000000000000000000000000000000000000000000 // @1752 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_1757: // Incoming jump from 0x16E9, if !stack[-1] // Inputs[9] // { // @175A memory[0x40:0x60] // @177C msg.sender // @178E memory[0x40:0x60] // @179C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @17A1 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @17A7 stack[-2] // @17A8 stack[-1] // @17B3 memory[0x40:0x60] // @17CD msg.data[stack[-2]:stack[-2] + 0x20 * stack[-1]] // } 1757 5B JUMPDEST 1758 60 PUSH1 0x40 175A 51 MLOAD 175B 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 177C 33 CALLER 177D 60 PUSH1 0x60 177F 1B SHL 1780 16 AND 1781 60 PUSH1 0x20 1783 82 DUP3 1784 01 ADD 1785 52 MSTORE 1786 60 PUSH1 0x00 1788 90 SWAP1 1789 60 PUSH1 0x34 178B 01 ADD 178C 60 PUSH1 0x40 178E 51 MLOAD 178F 60 PUSH1 0x20 1791 81 DUP2 1792 83 DUP4 1793 03 SUB 1794 03 SUB 1795 81 DUP2 1796 52 MSTORE 1797 90 SWAP1 1798 60 PUSH1 0x40 179A 52 MSTORE 179B 80 DUP1 179C 51 MLOAD 179D 90 SWAP1 179E 60 PUSH1 0x20 17A0 01 ADD 17A1 20 SHA3 17A2 90 SWAP1 17A3 50 POP 17A4 61 PUSH2 0x1803 17A7 83 DUP4 17A8 83 DUP4 17A9 80 DUP1 17AA 80 DUP1 17AB 60 PUSH1 0x20 17AD 02 MUL 17AE 60 PUSH1 0x20 17B0 01 ADD 17B1 60 PUSH1 0x40 17B3 51 MLOAD 17B4 90 SWAP1 17B5 81 DUP2 17B6 01 ADD 17B7 60 PUSH1 0x40 17B9 52 MSTORE 17BA 80 DUP1 17BB 93 SWAP4 17BC 92 SWAP3 17BD 91 SWAP2 17BE 90 SWAP1 17BF 81 DUP2 17C0 81 DUP2 17C1 52 MSTORE 17C2 60 PUSH1 0x20 17C4 01 ADD 17C5 83 DUP4 17C6 83 DUP4 17C7 60 PUSH1 0x20 17C9 02 MUL 17CA 80 DUP1 17CB 82 DUP3 17CC 84 DUP5 17CD 37 CALLDATACOPY 17CE 60 PUSH1 0x00 17D0 92 SWAP3 17D1 01 ADD 17D2 91 SWAP2 17D3 90 SWAP1 17D4 91 SWAP2 17D5 52 MSTORE 17D6 50 POP 17D7 7F PUSH32 0x1c59172521baca45ea5b482a6849c951386a295e51a04b71cd09dd1a515fe8dc 17F8 92 SWAP3 17F9 50 POP 17FA 85 DUP6 17FB 91 SWAP2 17FC 50 POP 17FD 61 PUSH2 0x20c1 1800 90 SWAP1 1801 50 POP 1802 56 *JUMP // Stack delta = +5 // Outputs[12] // { // @1785 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (msg.sender << 0x60) & 0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 // @1796 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x34 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @179A memory[0x40:0x60] = 0x34 + memory[0x40:0x60] // @17A2 stack[0] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @17A4 stack[1] = 0x1803 // @17B9 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // @17BB stack[2] = memory[0x40:0x60] // @17C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @17CD memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-1]] = msg.data[stack[-2]:stack[-2] + 0x20 * stack[-1]] // @17D5 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-1]:0x20 + memory[0x40:0x60] + 0x20 * stack[-1] + 0x20] = 0x00 // @17F8 stack[3] = 0x1c59172521baca45ea5b482a6849c951386a295e51a04b71cd09dd1a515fe8dc // @17FB stack[4] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with call to 0x20c1, returns to 0x1803 label_1803: // Incoming return from call to 0x20C1 at 0x1802 // Inputs[1] { @1807 stack[-1] } 1803 5B JUMPDEST 1804 61 PUSH2 0x184f 1807 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x184f, if stack[-1] label_1808: // Incoming jump from 0x1807, if not stack[-1] // Inputs[1] { @180A memory[0x40:0x60] } 1808 60 PUSH1 0x40 180A 51 MLOAD 180B 62 PUSH3 0x461bcd 180F 60 PUSH1 0xe5 1811 1B SHL 1812 81 DUP2 1813 52 MSTORE 1814 60 PUSH1 0x20 1816 60 PUSH1 0x04 1818 82 DUP3 1819 01 ADD 181A 52 MSTORE 181B 60 PUSH1 0x16 181D 60 PUSH1 0x24 181F 82 DUP3 1820 01 ADD 1821 52 MSTORE 1822 7F PUSH32 0x55736572206e6f74206f6e2077686974656c6973742e00000000000000000000 1843 60 PUSH1 0x44 1845 82 DUP3 1846 01 ADD 1847 52 MSTORE 1848 60 PUSH1 0x64 184A 01 ADD 184B 61 PUSH2 0x08ec 184E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1813 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @181A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1821 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x16 // @1847 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x55736572206e6f74206f6e2077686974656c6973742e00000000000000000000 // @184A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_184F: // Incoming jump from 0x1807, if stack[-1] // Inputs[1] { @1857 storage[0x08] } 184F 5B JUMPDEST 1850 60 PUSH1 0x00 1852 61 PUSH2 0x185a 1855 60 PUSH1 0x08 1857 54 SLOAD 1858 90 SWAP1 1859 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1850 stack[0] = 0x00 // @1858 stack[1] = storage[0x08] // } // Block ends with unconditional jump to 0x185a label_185A: // Incoming jump from 0x1859 // Inputs[2] // { // @185B stack[-2] // @185B stack[-1] // } 185A 5B JUMPDEST 185B 90 SWAP1 185C 50 POP 185D 61 PUSH2 0x05dd 1860 81 DUP2 1861 10 LT 1862 61 PUSH2 0x189d 1865 57 *JUMPI // Stack delta = -1 // Outputs[1] { @185B stack[-2] = stack[-1] } // Block ends with conditional jump to 0x189d, if stack[-1] < 0x05dd label_1866: // Incoming jump from 0x1865, if not stack[-1] < 0x05dd // Inputs[1] { @1868 memory[0x40:0x60] } 1866 60 PUSH1 0x40 1868 51 MLOAD 1869 62 PUSH3 0x461bcd 186D 60 PUSH1 0xe5 186F 1B SHL 1870 81 DUP2 1871 52 MSTORE 1872 60 PUSH1 0x20 1874 60 PUSH1 0x04 1876 82 DUP3 1877 01 ADD 1878 52 MSTORE 1879 60 PUSH1 0x0d 187B 60 PUSH1 0x24 187D 82 DUP3 187E 01 ADD 187F 52 MSTORE 1880 6C PUSH13 0x27baba1037b31039ba37b1b597 188E 60 PUSH1 0x99 1890 1B SHL 1891 60 PUSH1 0x44 1893 82 DUP3 1894 01 ADD 1895 52 MSTORE 1896 60 PUSH1 0x64 1898 01 ADD 1899 61 PUSH2 0x08ec 189C 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1871 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1878 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @187F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0d // @1895 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x27baba1037b31039ba37b1b597 << 0x99 // @1898 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_189D: // Incoming jump from 0x1865, if stack[-1] < 0x05dd // Inputs[2] // { // @18A1 stack[-5] // @18A4 storage[0x0b] // } 189D 5B JUMPDEST 189E 61 PUSH2 0x0457 18A1 85 DUP6 18A2 60 PUSH1 0x0b 18A4 54 SLOAD 18A5 61 PUSH2 0x18ae 18A8 91 SWAP2 18A9 90 SWAP1 18AA 61 PUSH2 0x2c6a 18AD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @189E stack[0] = 0x0457 // @18A8 stack[1] = 0x18ae // @18A9 stack[2] = stack[-5] // @18A9 stack[3] = storage[0x0b] // } // Block ends with call to 0x2c6a, returns to 0x18AE label_18AE: // Incoming return from call to 0x2C6A at 0x18AD // Inputs[2] // { // @18AF stack[-2] // @18AF stack[-1] // } 18AE 5B JUMPDEST 18AF 11 GT 18B0 15 ISZERO 18B1 61 PUSH2 0x18fc 18B4 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x18fc, if !(stack[-1] > stack[-2]) label_18B5: // Incoming jump from 0x18B4, if not !(stack[-1] > stack[-2]) // Inputs[1] { @18B7 memory[0x40:0x60] } 18B5 60 PUSH1 0x40 18B7 51 MLOAD 18B8 62 PUSH3 0x461bcd 18BC 60 PUSH1 0xe5 18BE 1B SHL 18BF 81 DUP2 18C0 52 MSTORE 18C1 60 PUSH1 0x20 18C3 60 PUSH1 0x04 18C5 82 DUP3 18C6 01 ADD 18C7 52 MSTORE 18C8 60 PUSH1 0x14 18CA 60 PUSH1 0x24 18CC 82 DUP3 18CD 01 ADD 18CE 52 MSTORE 18CF 7F PUSH32 0x5075626c6963206d696e74206578636565646564000000000000000000000000 18F0 60 PUSH1 0x44 18F2 82 DUP3 18F3 01 ADD 18F4 52 MSTORE 18F5 60 PUSH1 0x64 18F7 01 ADD 18F8 61 PUSH2 0x08ec 18FB 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @18C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @18C7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @18CE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @18F4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5075626c6963206d696e74206578636565646564000000000000000000000000 // @18F7 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_18FC: // Incoming jump from 0x18B4, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @18FD msg.value // @1901 stack[-5] // } 18FC 5B JUMPDEST 18FD 34 CALLVALUE 18FE 61 PUSH2 0x190e 1901 86 DUP7 1902 66 PUSH7 0x6a94d74f430000 190A 61 PUSH2 0x2c96 190D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @18FD stack[0] = msg.value // @18FE stack[1] = 0x190e // @1901 stack[2] = stack[-5] // @1902 stack[3] = 0x6a94d74f430000 // } // Block ends with call to 0x2c96, returns to 0x190E label_190E: // Incoming return from call to 0x2C96 at 0x190D // Inputs[2] // { // @190F stack[-2] // @190F stack[-1] // } 190E 5B JUMPDEST 190F 11 GT 1910 15 ISZERO 1911 61 PUSH2 0x195c 1914 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x195c, if !(stack[-1] > stack[-2]) label_1915: // Incoming jump from 0x1914, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1917 memory[0x40:0x60] } 1915 60 PUSH1 0x40 1917 51 MLOAD 1918 62 PUSH3 0x461bcd 191C 60 PUSH1 0xe5 191E 1B SHL 191F 81 DUP2 1920 52 MSTORE 1921 60 PUSH1 0x20 1923 60 PUSH1 0x04 1925 82 DUP3 1926 01 ADD 1927 52 MSTORE 1928 60 PUSH1 0x10 192A 60 PUSH1 0x24 192C 82 DUP3 192D 01 ADD 192E 52 MSTORE 192F 7F PUSH32 0x496e73756666696369656e742045746800000000000000000000000000000000 1950 60 PUSH1 0x44 1952 82 DUP3 1953 01 ADD 1954 52 MSTORE 1955 60 PUSH1 0x64 1957 01 ADD 1958 61 PUSH2 0x08ec 195B 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1920 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1927 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @192E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @1954 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e73756666696369656e742045746800000000000000000000000000000000 // @1957 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_195C: // Incoming jump from 0x1914, if !(stack[-1] > stack[-2]) // Inputs[1] { @1960 stack[-5] } 195C 5B JUMPDEST 195D 60 PUSH1 0x00 195F 5B JUMPDEST 1960 85 DUP6 1961 81 DUP2 1962 10 LT 1963 15 ISZERO 1964 61 PUSH2 0x199d 1967 57 *JUMPI // Stack delta = +1 // Outputs[1] { @195D stack[0] = 0x00 } // Block ends with conditional jump to 0x199d, if !(0x00 < stack[-5]) label_1968: // Incoming jump from 0x1967, if not !(0x00 < stack[-5]) // Incoming jump from 0x1967, if not !(stack[-1] < stack[-6]) // Inputs[3] // { // @196B msg.sender // @196F stack[-1] // @1970 stack[-2] // } 1968 61 PUSH2 0x1975 196B 33 CALLER 196C 61 PUSH2 0x0e67 196F 83 DUP4 1970 85 DUP6 1971 61 PUSH2 0x2c6a 1974 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1968 stack[0] = 0x1975 // @196B stack[1] = msg.sender // @196C stack[2] = 0x0e67 // @196F stack[3] = stack[-1] // @1970 stack[4] = stack[-2] // } // Block ends with call to 0x2c6a, returns to 0x0E67 label_1975: // Incoming return from call to 0x0E67 at 0x1974 // Inputs[1] { @1979 storage[0x0b] } 1975 5B JUMPDEST 1976 60 PUSH1 0x0b 1978 80 DUP1 1979 54 SLOAD 197A 90 SWAP1 197B 60 PUSH1 0x00 197D 61 PUSH2 0x1985 1980 83 DUP4 1981 61 PUSH2 0x2d33 1984 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @197A stack[0] = storage[0x0b] // @197A stack[1] = 0x0b // @197B stack[2] = 0x00 // @197D stack[3] = 0x1985 // @1980 stack[4] = storage[0x0b] // } // Block ends with call to 0x2d33, returns to 0x1985 label_1985: // Incoming return from call to 0x2D33 at 0x1984 // Inputs[4] // { // @1986 stack[-3] // @1986 stack[-1] // @1987 stack[-2] // @198B stack[-5] // } 1985 5B JUMPDEST 1986 91 SWAP2 1987 90 SWAP1 1988 50 POP 1989 55 SSTORE 198A 50 POP 198B 80 DUP1 198C 80 DUP1 198D 61 PUSH2 0x1995 1990 90 SWAP1 1991 61 PUSH2 0x2d33 1994 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1989 storage[stack[-3]] = stack[-1] // @198B stack[-4] = stack[-5] // @1990 stack[-2] = stack[-5] // @1990 stack[-3] = 0x1995 // } // Block ends with call to 0x2d33, returns to 0x1995 label_1995: // Incoming return from call to 0x2D33 at 0x1994 // Inputs[2] // { // @1996 stack[-3] // @1996 stack[-1] // } 1995 5B JUMPDEST 1996 91 SWAP2 1997 50 POP 1998 50 POP 1999 61 PUSH2 0x195f 199C 56 *JUMP // Stack delta = -2 // Outputs[1] { @1996 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x195f label_199D: // Incoming jump from 0x1967, if !(0x00 < stack[-5]) // Incoming jump from 0x1967, if !(stack[-1] < stack[-6]) // Inputs[1] { @19A4 stack[-7] } 199D 5B JUMPDEST 199E 50 POP 199F 50 POP 19A0 50 POP 19A1 50 POP 19A2 50 POP 19A3 50 POP 19A4 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_19A5: // Incoming jump from 0x078F // Inputs[2] // { // @19A8 storage[0x0a] // @19B2 msg.sender // } 19A5 5B JUMPDEST 19A6 60 PUSH1 0x0a 19A8 54 SLOAD 19A9 60 PUSH1 0x01 19AB 60 PUSH1 0x01 19AD 60 PUSH1 0xa0 19AF 1B SHL 19B0 03 SUB 19B1 16 AND 19B2 33 CALLER 19B3 14 EQ 19B4 61 PUSH2 0x19ff 19B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x19ff, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] label_19B8: // Incoming jump from 0x19B7, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @19BA memory[0x40:0x60] } 19B8 60 PUSH1 0x40 19BA 51 MLOAD 19BB 62 PUSH3 0x461bcd 19BF 60 PUSH1 0xe5 19C1 1B SHL 19C2 81 DUP2 19C3 52 MSTORE 19C4 60 PUSH1 0x20 19C6 60 PUSH1 0x04 19C8 82 DUP3 19C9 01 ADD 19CA 81 DUP2 19CB 90 SWAP1 19CC 52 MSTORE 19CD 60 PUSH1 0x24 19CF 82 DUP3 19D0 01 ADD 19D1 52 MSTORE 19D2 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 19F3 60 PUSH1 0x44 19F5 82 DUP3 19F6 01 ADD 19F7 52 MSTORE 19F8 60 PUSH1 0x64 19FA 01 ADD 19FB 61 PUSH2 0x08ec 19FE 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @19C3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @19CC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @19D1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @19F7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @19FA stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_19FF: // Incoming jump from 0x19B7, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @1A08 stack[-1] } 19FF 5B JUMPDEST 1A00 60 PUSH1 0x01 1A02 60 PUSH1 0x01 1A04 60 PUSH1 0xa0 1A06 1B SHL 1A07 03 SUB 1A08 81 DUP2 1A09 16 AND 1A0A 61 PUSH2 0x1a7b 1A0D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1a7b, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1A0E: // Incoming jump from 0x1A0D, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1A10 memory[0x40:0x60] } 1A0E 60 PUSH1 0x40 1A10 51 MLOAD 1A11 62 PUSH3 0x461bcd 1A15 60 PUSH1 0xe5 1A17 1B SHL 1A18 81 DUP2 1A19 52 MSTORE 1A1A 60 PUSH1 0x20 1A1C 60 PUSH1 0x04 1A1E 82 DUP3 1A1F 01 ADD 1A20 52 MSTORE 1A21 60 PUSH1 0x26 1A23 60 PUSH1 0x24 1A25 82 DUP3 1A26 01 ADD 1A27 52 MSTORE 1A28 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 1A49 60 PUSH1 0x44 1A4B 82 DUP3 1A4C 01 ADD 1A4D 52 MSTORE 1A4E 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 1A6F 60 PUSH1 0x64 1A71 82 DUP3 1A72 01 ADD 1A73 52 MSTORE 1A74 60 PUSH1 0x84 1A76 01 ADD 1A77 61 PUSH2 0x08ec 1A7A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1A19 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1A20 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1A27 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1A4D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @1A73 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // @1A76 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_1A7B: // Incoming jump from 0x1A0D, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1A7F stack[-1] } 1A7B 5B JUMPDEST 1A7C 61 PUSH2 0x0d02 1A7F 81 DUP2 1A80 61 PUSH2 0x1ea7 1A83 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A7C stack[0] = 0x0d02 // @1A7F stack[1] = stack[-1] // } // Block ends with call to 0x1ea7, returns to 0x0D02 1A84 5B JUMPDEST 1A85 3B EXTCODESIZE 1A86 15 ISZERO 1A87 15 ISZERO 1A88 90 SWAP1 1A89 56 *JUMP label_1A8A: // Incoming call from 0x07CD, returns to 0x07CE // Inputs[1] { @1A96 stack[-1] } 1A8A 5B JUMPDEST 1A8B 60 PUSH1 0x00 1A8D 60 PUSH1 0x01 1A8F 60 PUSH1 0x01 1A91 60 PUSH1 0xe0 1A93 1B SHL 1A94 03 SUB 1A95 19 NOT 1A96 82 DUP3 1A97 16 AND 1A98 7F PUSH32 0x80ac58cd00000000000000000000000000000000000000000000000000000000 1AB9 14 EQ 1ABA 80 DUP1 1ABB 61 PUSH2 0x1aed 1ABE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A8B stack[0] = 0x00 // @1AB9 stack[1] = 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x1aed, if 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1ABF: // Incoming jump from 0x1ABE, if not 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1AC9 stack[-3] } 1ABF 50 POP 1AC0 60 PUSH1 0x01 1AC2 60 PUSH1 0x01 1AC4 60 PUSH1 0xe0 1AC6 1B SHL 1AC7 03 SUB 1AC8 19 NOT 1AC9 82 DUP3 1ACA 16 AND 1ACB 7F PUSH32 0x5b5e139f00000000000000000000000000000000000000000000000000000000 1AEC 14 EQ 1AED 5B JUMPDEST 1AEE 80 DUP1 1AEF 61 PUSH2 0x07ce 1AF2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1AEC stack[-1] = 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x07ce, if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_1AF3: // Incoming jump from 0x1AF2, if not 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x1AF2, if not stack[-1] // Inputs[1] { @1B1E stack[-3] } 1AF3 50 POP 1AF4 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 1B15 60 PUSH1 0x01 1B17 60 PUSH1 0x01 1B19 60 PUSH1 0xe0 1B1B 1B SHL 1B1C 03 SUB 1B1D 19 NOT 1B1E 83 DUP4 1B1F 16 AND 1B20 14 EQ 1B21 61 PUSH2 0x07ce 1B24 56 *JUMP // Stack delta = +0 // Outputs[1] { @1B20 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to 0x07ce label_1B25: // Incoming call from 0x1DC7, returns to 0x1DC8 // Incoming call from 0x0A3D, returns to 0x0A3E // Inputs[4] // { // @1B28 stack[-1] // @1B33 memory[0x00:0x40] // @1B35 storage[keccak256(memory[0x00:0x40])] // @1B55 stack[-2] // } 1B25 5B JUMPDEST 1B26 60 PUSH1 0x00 1B28 81 DUP2 1B29 81 DUP2 1B2A 52 MSTORE 1B2B 60 PUSH1 0x04 1B2D 60 PUSH1 0x20 1B2F 52 MSTORE 1B30 60 PUSH1 0x40 1B32 90 SWAP1 1B33 20 SHA3 1B34 80 DUP1 1B35 54 SLOAD 1B36 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B4B 19 NOT 1B4C 16 AND 1B4D 60 PUSH1 0x01 1B4F 60 PUSH1 0x01 1B51 60 PUSH1 0xa0 1B53 1B SHL 1B54 03 SUB 1B55 84 DUP5 1B56 16 AND 1B57 90 SWAP1 1B58 81 DUP2 1B59 17 OR 1B5A 90 SWAP1 1B5B 91 SWAP2 1B5C 55 SSTORE 1B5D 81 DUP2 1B5E 90 SWAP1 1B5F 61 PUSH2 0x1b67 1B62 82 DUP3 1B63 61 PUSH2 0x0faf 1B66 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @1B2A memory[0x00:0x20] = stack[-1] // @1B2F memory[0x20:0x40] = 0x04 // @1B5C storage[keccak256(memory[0x00:0x40])] = (stack[-2] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @1B5E stack[0] = stack[-1] // @1B5E stack[1] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1B5F stack[2] = 0x1b67 // @1B62 stack[3] = stack[-1] // } // Block ends with call to 0x0faf, returns to 0x1B67 label_1B67: // Incoming return from call to 0x0FAF at 0x1B66 // Inputs[7] // { // @1B70 stack[-1] // @1B94 memory[0x40:0x60] // @1B97 memory[0x40:0x60] // @1B9C stack[-2] // @1B9C stack[-3] // @1B9C memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1B9F stack[-6] // } 1B67 5B JUMPDEST 1B68 60 PUSH1 0x01 1B6A 60 PUSH1 0x01 1B6C 60 PUSH1 0xa0 1B6E 1B SHL 1B6F 03 SUB 1B70 16 AND 1B71 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1B92 60 PUSH1 0x40 1B94 51 MLOAD 1B95 60 PUSH1 0x40 1B97 51 MLOAD 1B98 80 DUP1 1B99 91 SWAP2 1B9A 03 SUB 1B9B 90 SWAP1 1B9C A4 LOG4 1B9D 50 POP 1B9E 50 POP 1B9F 56 *JUMP // Stack delta = -6 // Outputs[1] { @1B9C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-2], stack[-3]]); } // Block ends with unconditional jump to stack[-6] label_1BA0: // Incoming call from 0x0AB9, returns to 0x0ABA // Incoming call from 0x14C7, returns to 0x14C8 // Inputs[3] // { // @1BA3 stack[-1] // @1BAE memory[0x00:0x40] // @1BAF storage[keccak256(memory[0x00:0x40])] // } 1BA0 5B JUMPDEST 1BA1 60 PUSH1 0x00 1BA3 81 DUP2 1BA4 81 DUP2 1BA5 52 MSTORE 1BA6 60 PUSH1 0x02 1BA8 60 PUSH1 0x20 1BAA 52 MSTORE 1BAB 60 PUSH1 0x40 1BAD 81 DUP2 1BAE 20 SHA3 1BAF 54 SLOAD 1BB0 60 PUSH1 0x01 1BB2 60 PUSH1 0x01 1BB4 60 PUSH1 0xa0 1BB6 1B SHL 1BB7 03 SUB 1BB8 16 AND 1BB9 61 PUSH2 0x1c2a 1BBC 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1BA1 stack[0] = 0x00 // @1BA5 memory[0x00:0x20] = stack[-1] // @1BAA memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x1c2a, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_1BBD: // Incoming jump from 0x1BBC, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1BBF memory[0x40:0x60] } 1BBD 60 PUSH1 0x40 1BBF 51 MLOAD 1BC0 62 PUSH3 0x461bcd 1BC4 60 PUSH1 0xe5 1BC6 1B SHL 1BC7 81 DUP2 1BC8 52 MSTORE 1BC9 60 PUSH1 0x20 1BCB 60 PUSH1 0x04 1BCD 82 DUP3 1BCE 01 ADD 1BCF 52 MSTORE 1BD0 60 PUSH1 0x2c 1BD2 60 PUSH1 0x24 1BD4 82 DUP3 1BD5 01 ADD 1BD6 52 MSTORE 1BD7 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 1BF8 60 PUSH1 0x44 1BFA 82 DUP3 1BFB 01 ADD 1BFC 52 MSTORE 1BFD 7F PUSH32 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 1C1E 60 PUSH1 0x64 1C20 82 DUP3 1C21 01 ADD 1C22 52 MSTORE 1C23 60 PUSH1 0x84 1C25 01 ADD 1C26 61 PUSH2 0x08ec 1C29 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1BC8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1BCF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1BD6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @1BFC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 // @1C22 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 // @1C25 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_1C2A: // Incoming jump from 0x1BBC, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1C30 stack[-2] } 1C2A 5B JUMPDEST 1C2B 60 PUSH1 0x00 1C2D 61 PUSH2 0x1c35 1C30 83 DUP4 1C31 61 PUSH2 0x0faf 1C34 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C2B stack[0] = 0x00 // @1C2D stack[1] = 0x1c35 // @1C30 stack[2] = stack[-2] // } // Block ends with call to 0x0faf, returns to 0x1C35 label_1C35: // Incoming return from call to 0x0FAF at 0x1C34 // Inputs[3] // { // @1C36 stack[-1] // @1C36 stack[-2] // @1C42 stack[-5] // } 1C35 5B JUMPDEST 1C36 90 SWAP1 1C37 50 POP 1C38 80 DUP1 1C39 60 PUSH1 0x01 1C3B 60 PUSH1 0x01 1C3D 60 PUSH1 0xa0 1C3F 1B SHL 1C40 03 SUB 1C41 16 AND 1C42 84 DUP5 1C43 60 PUSH1 0x01 1C45 60 PUSH1 0x01 1C47 60 PUSH1 0xa0 1C49 1B SHL 1C4A 03 SUB 1C4B 16 AND 1C4C 14 EQ 1C4D 80 DUP1 1C4E 61 PUSH2 0x1c70 1C51 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1C36 stack[-2] = stack[-1] // @1C4C stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // } // Block ends with conditional jump to 0x1c70, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] label_1C52: // Incoming jump from 0x1C51, if not (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[2] // { // @1C53 stack[-5] // @1C60 stack[-4] // } 1C52 50 POP 1C53 83 DUP4 1C54 60 PUSH1 0x01 1C56 60 PUSH1 0x01 1C58 60 PUSH1 0xa0 1C5A 1B SHL 1C5B 03 SUB 1C5C 16 AND 1C5D 61 PUSH2 0x1c65 1C60 84 DUP5 1C61 61 PUSH2 0x0866 1C64 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1C5C stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1C5D stack[0] = 0x1c65 // @1C60 stack[1] = stack[-4] // } // Block ends with call to 0x0866, returns to 0x1C65 label_1C65: // Incoming return from call to 0x0866 at 0x1C64 // Inputs[2] // { // @1C6E stack[-1] // @1C6F stack[-2] // } 1C65 5B JUMPDEST 1C66 60 PUSH1 0x01 1C68 60 PUSH1 0x01 1C6A 60 PUSH1 0xa0 1C6C 1B SHL 1C6D 03 SUB 1C6E 16 AND 1C6F 14 EQ // Stack delta = -1 // Outputs[1] { @1C6F stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_1C70: // Incoming jump from 0x1C51, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Incoming jump from 0x1C6F // Inputs[1] { @1C71 stack[-1] } 1C70 5B JUMPDEST 1C71 80 DUP1 1C72 61 PUSH2 0x1ca0 1C75 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ca0, if stack[-1] label_1C76: // Incoming jump from 0x1C75, if not stack[-1] // Inputs[5] // { // @1C80 stack[-2] // @1C92 memory[0x00:0x40] // @1C94 stack[-5] // @1C9B memory[0x00:0x40] // @1C9C storage[keccak256(memory[0x00:0x40])] // } 1C76 50 POP 1C77 60 PUSH1 0x01 1C79 60 PUSH1 0x01 1C7B 60 PUSH1 0xa0 1C7D 1B SHL 1C7E 03 SUB 1C7F 80 DUP1 1C80 82 DUP3 1C81 16 AND 1C82 60 PUSH1 0x00 1C84 90 SWAP1 1C85 81 DUP2 1C86 52 MSTORE 1C87 60 PUSH1 0x05 1C89 60 PUSH1 0x20 1C8B 90 SWAP1 1C8C 81 DUP2 1C8D 52 MSTORE 1C8E 60 PUSH1 0x40 1C90 80 DUP1 1C91 83 DUP4 1C92 20 SHA3 1C93 93 SWAP4 1C94 88 DUP9 1C95 16 AND 1C96 83 DUP4 1C97 52 MSTORE 1C98 92 SWAP3 1C99 90 SWAP1 1C9A 52 MSTORE 1C9B 20 SHA3 1C9C 54 SLOAD 1C9D 60 PUSH1 0xff 1C9F 16 AND // Stack delta = +0 // Outputs[5] // { // @1C86 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1C8D memory[0x20:0x40] = 0x05 // @1C97 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1C9A memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1C9F stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block continues label_1CA0: // Incoming jump from 0x2048, if !stack[-7] // Incoming jump from 0x2048, if !stack[-5] // Incoming jump from 0x1C9F // Incoming jump from 0x2048, if !stack[-7] // Incoming return from call to 0x2798 at 0x2AC6 // Incoming jump from 0x1C75, if stack[-1] // Inputs[3] // { // @1CA1 stack[-1] // @1CA1 stack[-6] // @1CA2 stack[-5] // } 1CA0 5B JUMPDEST 1CA1 94 SWAP5 1CA2 93 SWAP4 1CA3 50 POP 1CA4 50 POP 1CA5 50 POP 1CA6 50 POP 1CA7 56 *JUMP // Stack delta = -5 // Outputs[1] { @1CA1 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1CA8: // Incoming call from 0x0B36, returns to 0x0A3E // Incoming call from 0x1F10, returns to 0x1F11 // Inputs[2] // { // @1CA9 stack[-3] // @1CB6 stack[-1] // } 1CA8 5B JUMPDEST 1CA9 82 DUP3 1CAA 60 PUSH1 0x01 1CAC 60 PUSH1 0x01 1CAE 60 PUSH1 0xa0 1CB0 1B SHL 1CB1 03 SUB 1CB2 16 AND 1CB3 61 PUSH2 0x1cbb 1CB6 82 DUP3 1CB7 61 PUSH2 0x0faf 1CBA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1CB2 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-3] // @1CB3 stack[1] = 0x1cbb // @1CB6 stack[2] = stack[-1] // } // Block ends with call to 0x0faf, returns to 0x1CBB label_1CBB: // Incoming return from call to 0x0FAF at 0x1CBA // Inputs[2] // { // @1CC4 stack[-1] // @1CC5 stack[-2] // } 1CBB 5B JUMPDEST 1CBC 60 PUSH1 0x01 1CBE 60 PUSH1 0x01 1CC0 60 PUSH1 0xa0 1CC2 1B SHL 1CC3 03 SUB 1CC4 16 AND 1CC5 14 EQ 1CC6 61 PUSH2 0x1d37 1CC9 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1d37, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_1CCA: // Incoming jump from 0x1CC9, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1CCC memory[0x40:0x60] } 1CCA 60 PUSH1 0x40 1CCC 51 MLOAD 1CCD 62 PUSH3 0x461bcd 1CD1 60 PUSH1 0xe5 1CD3 1B SHL 1CD4 81 DUP2 1CD5 52 MSTORE 1CD6 60 PUSH1 0x20 1CD8 60 PUSH1 0x04 1CDA 82 DUP3 1CDB 01 ADD 1CDC 52 MSTORE 1CDD 60 PUSH1 0x29 1CDF 60 PUSH1 0x24 1CE1 82 DUP3 1CE2 01 ADD 1CE3 52 MSTORE 1CE4 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 1D05 60 PUSH1 0x44 1D07 82 DUP3 1D08 01 ADD 1D09 52 MSTORE 1D0A 7F PUSH32 0x73206e6f74206f776e0000000000000000000000000000000000000000000000 1D2B 60 PUSH1 0x64 1D2D 82 DUP3 1D2E 01 ADD 1D2F 52 MSTORE 1D30 60 PUSH1 0x84 1D32 01 ADD 1D33 61 PUSH2 0x08ec 1D36 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1CD5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1CDC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1CE3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @1D09 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 // @1D2F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x73206e6f74206f776e0000000000000000000000000000000000000000000000 // @1D32 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_1D37: // Incoming jump from 0x1CC9, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1D40 stack[-2] } 1D37 5B JUMPDEST 1D38 60 PUSH1 0x01 1D3A 60 PUSH1 0x01 1D3C 60 PUSH1 0xa0 1D3E 1B SHL 1D3F 03 SUB 1D40 82 DUP3 1D41 16 AND 1D42 61 PUSH2 0x1db2 1D45 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1db2, if stack[-2] & (0x01 << 0xa0) - 0x01 label_1D46: // Incoming jump from 0x1D45, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1D48 memory[0x40:0x60] } 1D46 60 PUSH1 0x40 1D48 51 MLOAD 1D49 62 PUSH3 0x461bcd 1D4D 60 PUSH1 0xe5 1D4F 1B SHL 1D50 81 DUP2 1D51 52 MSTORE 1D52 60 PUSH1 0x20 1D54 60 PUSH1 0x04 1D56 82 DUP3 1D57 01 ADD 1D58 52 MSTORE 1D59 60 PUSH1 0x24 1D5B 80 DUP1 1D5C 82 DUP3 1D5D 01 ADD 1D5E 52 MSTORE 1D5F 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 1D80 60 PUSH1 0x44 1D82 82 DUP3 1D83 01 ADD 1D84 52 MSTORE 1D85 7F PUSH32 0x7265737300000000000000000000000000000000000000000000000000000000 1DA6 60 PUSH1 0x64 1DA8 82 DUP3 1DA9 01 ADD 1DAA 52 MSTORE 1DAB 60 PUSH1 0x84 1DAD 01 ADD 1DAE 61 PUSH2 0x08ec 1DB1 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1D51 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1D58 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1D5E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @1D84 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 // @1DAA memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7265737300000000000000000000000000000000000000000000000000000000 // @1DAD stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_1DB2: // Incoming jump from 0x1D45, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1DB6 stack[-3] // @1DB7 stack[-2] // @1DB8 stack[-1] // } 1DB2 5B JUMPDEST 1DB3 61 PUSH2 0x1dbd 1DB6 83 DUP4 1DB7 83 DUP4 1DB8 83 DUP4 1DB9 61 PUSH2 0x2170 1DBC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DB3 stack[0] = 0x1dbd // @1DB6 stack[1] = stack[-3] // @1DB7 stack[2] = stack[-2] // @1DB8 stack[3] = stack[-1] // } // Block ends with call to 0x2170, returns to 0x1DBD label_1DBD: // Incoming return from call to 0x2170 at 0x1DBC // Inputs[1] { @1DC3 stack[-1] } 1DBD 5B JUMPDEST 1DBE 61 PUSH2 0x1dc8 1DC1 60 PUSH1 0x00 1DC3 82 DUP3 1DC4 61 PUSH2 0x1b25 1DC7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1DBE stack[0] = 0x1dc8 // @1DC1 stack[1] = 0x00 // @1DC3 stack[2] = stack[-1] // } // Block ends with call to 0x1b25, returns to 0x1DC8 label_1DC8: // Incoming return from call to 0x1B25 at 0x1DC7 // Inputs[3] // { // @1DD1 stack[-3] // @1DE0 memory[0x00:0x40] // @1DE2 storage[keccak256(memory[0x00:0x40])] // } 1DC8 5B JUMPDEST 1DC9 60 PUSH1 0x01 1DCB 60 PUSH1 0x01 1DCD 60 PUSH1 0xa0 1DCF 1B SHL 1DD0 03 SUB 1DD1 83 DUP4 1DD2 16 AND 1DD3 60 PUSH1 0x00 1DD5 90 SWAP1 1DD6 81 DUP2 1DD7 52 MSTORE 1DD8 60 PUSH1 0x03 1DDA 60 PUSH1 0x20 1DDC 52 MSTORE 1DDD 60 PUSH1 0x40 1DDF 81 DUP2 1DE0 20 SHA3 1DE1 80 DUP1 1DE2 54 SLOAD 1DE3 60 PUSH1 0x01 1DE5 92 SWAP3 1DE6 90 SWAP1 1DE7 61 PUSH2 0x1df1 1DEA 90 SWAP1 1DEB 84 DUP5 1DEC 90 SWAP1 1DED 61 PUSH2 0x2cb5 1DF0 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @1DD7 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1DDC memory[0x20:0x40] = 0x03 // @1DE0 stack[1] = keccak256(memory[0x00:0x40]) // @1DE5 stack[0] = 0x01 // @1DE6 stack[2] = 0x00 // @1DEA stack[3] = 0x1df1 // @1DEC stack[4] = 0x01 // @1DEC stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2cb5, returns to 0x1DF1 label_1DF1: // Incoming return from call to 0x2CB5 at 0x1DF0 // Inputs[6] // { // @1DF2 stack[-2] // @1DF2 stack[-1] // @1DF3 stack[-3] // @1DFF stack[-6] // @1E0E memory[0x00:0x40] // @1E10 storage[keccak256(memory[0x00:0x40])] // } 1DF1 5B JUMPDEST 1DF2 90 SWAP1 1DF3 91 SWAP2 1DF4 55 SSTORE 1DF5 50 POP 1DF6 50 POP 1DF7 60 PUSH1 0x01 1DF9 60 PUSH1 0x01 1DFB 60 PUSH1 0xa0 1DFD 1B SHL 1DFE 03 SUB 1DFF 82 DUP3 1E00 16 AND 1E01 60 PUSH1 0x00 1E03 90 SWAP1 1E04 81 DUP2 1E05 52 MSTORE 1E06 60 PUSH1 0x03 1E08 60 PUSH1 0x20 1E0A 52 MSTORE 1E0B 60 PUSH1 0x40 1E0D 81 DUP2 1E0E 20 SHA3 1E0F 80 DUP1 1E10 54 SLOAD 1E11 60 PUSH1 0x01 1E13 92 SWAP3 1E14 90 SWAP1 1E15 61 PUSH2 0x1e1f 1E18 90 SWAP1 1E19 84 DUP5 1E1A 90 SWAP1 1E1B 61 PUSH2 0x2c6a 1E1E 56 *JUMP // Stack delta = +2 // Outputs[9] // { // @1DF4 storage[stack[-3]] = stack[-1] // @1E05 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @1E0A memory[0x20:0x40] = 0x03 // @1E0E stack[-3] = keccak256(memory[0x00:0x40]) // @1E13 stack[-4] = 0x01 // @1E14 stack[-2] = 0x00 // @1E18 stack[-1] = 0x1e1f // @1E1A stack[0] = 0x01 // @1E1A stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2c6a, returns to 0x1E1F label_1E1F: // Incoming return from call to 0x2C6A at 0x1E1E // Inputs[11] // { // @1E20 stack[-2] // @1E20 stack[-1] // @1E21 stack[-3] // @1E27 stack[-5] // @1E33 memory[0x00:0x40] // @1E35 storage[keccak256(memory[0x00:0x40])] // @1E55 stack[-6] // @1E5F memory[0x40:0x60] // @1E63 stack[-7] // @1E88 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1E8C stack[-8] // } 1E1F 5B JUMPDEST 1E20 90 SWAP1 1E21 91 SWAP2 1E22 55 SSTORE 1E23 50 POP 1E24 50 POP 1E25 60 PUSH1 0x00 1E27 81 DUP2 1E28 81 DUP2 1E29 52 MSTORE 1E2A 60 PUSH1 0x02 1E2C 60 PUSH1 0x20 1E2E 52 MSTORE 1E2F 60 PUSH1 0x40 1E31 80 DUP1 1E32 82 DUP3 1E33 20 SHA3 1E34 80 DUP1 1E35 54 SLOAD 1E36 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E4B 19 NOT 1E4C 16 AND 1E4D 60 PUSH1 0x01 1E4F 60 PUSH1 0x01 1E51 60 PUSH1 0xa0 1E53 1B SHL 1E54 03 SUB 1E55 86 DUP7 1E56 81 DUP2 1E57 16 AND 1E58 91 SWAP2 1E59 82 DUP3 1E5A 17 OR 1E5B 90 SWAP1 1E5C 92 SWAP3 1E5D 55 SSTORE 1E5E 91 SWAP2 1E5F 51 MLOAD 1E60 84 DUP5 1E61 93 SWAP4 1E62 91 SWAP2 1E63 87 DUP8 1E64 16 AND 1E65 91 SWAP2 1E66 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1E87 91 SWAP2 1E88 A4 LOG4 1E89 50 POP 1E8A 50 POP 1E8B 50 POP 1E8C 56 *JUMP // Stack delta = -8 // Outputs[5] // { // @1E22 storage[stack[-3]] = stack[-1] // @1E29 memory[0x00:0x20] = stack[-5] // @1E2E memory[0x20:0x40] = 0x02 // @1E5D storage[keccak256(memory[0x00:0x40])] = (stack[-6] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @1E88 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5]]); // } // Block ends with unconditional jump to stack[-8] label_1E8D: // Incoming jump from 0x0E6B // Inputs[3] // { // @1E91 stack[-2] // @1E92 stack[-1] // @1E95 memory[0x40:0x60] // } 1E8D 5B JUMPDEST 1E8E 61 PUSH2 0x0fab 1E91 82 DUP3 1E92 82 DUP3 1E93 60 PUSH1 0x40 1E95 51 MLOAD 1E96 80 DUP1 1E97 60 PUSH1 0x20 1E99 01 ADD 1E9A 60 PUSH1 0x40 1E9C 52 MSTORE 1E9D 80 DUP1 1E9E 60 PUSH1 0x00 1EA0 81 DUP2 1EA1 52 MSTORE 1EA2 50 POP 1EA3 61 PUSH2 0x2228 1EA6 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1E8E stack[0] = 0x0fab // @1E91 stack[1] = stack[-2] // @1E92 stack[2] = stack[-1] // @1E95 stack[3] = memory[0x40:0x60] // @1E9C memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1EA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x2228, returns to 0x0FAB label_1EA7: // Incoming call from 0x1A83, returns to 0x0D02 // Incoming call from 0x11C5, returns to 0x11C6 // Inputs[5] // { // @1EAB storage[0x0a] // @1EB4 stack[-1] // @1ED6 memory[0x40:0x60] // @1F02 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1F05 stack[-2] // } 1EA7 5B JUMPDEST 1EA8 60 PUSH1 0x0a 1EAA 80 DUP1 1EAB 54 SLOAD 1EAC 60 PUSH1 0x01 1EAE 60 PUSH1 0x01 1EB0 60 PUSH1 0xa0 1EB2 1B SHL 1EB3 03 SUB 1EB4 83 DUP4 1EB5 81 DUP2 1EB6 16 AND 1EB7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1ECC 19 NOT 1ECD 83 DUP4 1ECE 16 AND 1ECF 81 DUP2 1ED0 17 OR 1ED1 90 SWAP1 1ED2 93 SWAP4 1ED3 55 SSTORE 1ED4 60 PUSH1 0x40 1ED6 51 MLOAD 1ED7 91 SWAP2 1ED8 16 AND 1ED9 91 SWAP2 1EDA 90 SWAP1 1EDB 82 DUP3 1EDC 90 SWAP1 1EDD 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1EFE 90 SWAP1 1EFF 60 PUSH1 0x00 1F01 90 SWAP1 1F02 A3 LOG3 1F03 50 POP 1F04 50 POP 1F05 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1ED3 storage[0x0a] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x0a] & ~0xffffffffffffffffffffffffffffffffffffffff) // @1F02 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0a] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_1F06: // Incoming call from 0x1545, returns to 0x0E94 // Inputs[3] // { // @1F0A stack[-4] // @1F0B stack[-3] // @1F0C stack[-2] // } 1F06 5B JUMPDEST 1F07 61 PUSH2 0x1f11 1F0A 84 DUP5 1F0B 84 DUP5 1F0C 84 DUP5 1F0D 61 PUSH2 0x1ca8 1F10 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F07 stack[0] = 0x1f11 // @1F0A stack[1] = stack[-4] // @1F0B stack[2] = stack[-3] // @1F0C stack[3] = stack[-2] // } // Block ends with call to 0x1ca8, returns to 0x1F11 label_1F11: // Incoming return from call to 0x1CA8 at 0x1F10 // Inputs[4] // { // @1F15 stack[-4] // @1F16 stack[-3] // @1F17 stack[-2] // @1F18 stack[-1] // } 1F11 5B JUMPDEST 1F12 61 PUSH2 0x1f1d 1F15 84 DUP5 1F16 84 DUP5 1F17 84 DUP5 1F18 84 DUP5 1F19 61 PUSH2 0x22b1 1F1C 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1F12 stack[0] = 0x1f1d // @1F15 stack[1] = stack[-4] // @1F16 stack[2] = stack[-3] // @1F17 stack[3] = stack[-2] // @1F18 stack[4] = stack[-1] // } // Block ends with call to 0x22b1, returns to 0x1F1D label_1F1D: // Incoming return from call to 0x22B1 at 0x1F1C // Inputs[1] { @1F21 stack[-1] } 1F1D 5B JUMPDEST 1F1E 61 PUSH2 0x0e94 1F21 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e94, if stack[-1] label_1F22: // Incoming jump from 0x1F21, if not stack[-1] // Inputs[1] { @1F24 memory[0x40:0x60] } 1F22 60 PUSH1 0x40 1F24 51 MLOAD 1F25 62 PUSH3 0x461bcd 1F29 60 PUSH1 0xe5 1F2B 1B SHL 1F2C 81 DUP2 1F2D 52 MSTORE 1F2E 60 PUSH1 0x20 1F30 60 PUSH1 0x04 1F32 82 DUP3 1F33 01 ADD 1F34 52 MSTORE 1F35 60 PUSH1 0x32 1F37 60 PUSH1 0x24 1F39 82 DUP3 1F3A 01 ADD 1F3B 52 MSTORE 1F3C 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 1F5D 60 PUSH1 0x44 1F5F 82 DUP3 1F60 01 ADD 1F61 52 MSTORE 1F62 7F PUSH32 0x63656976657220696d706c656d656e7465720000000000000000000000000000 1F83 60 PUSH1 0x64 1F85 82 DUP3 1F86 01 ADD 1F87 52 MSTORE 1F88 60 PUSH1 0x84 1F8A 01 ADD 1F8B 61 PUSH2 0x08ec 1F8E 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1F2D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1F34 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1F3B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x32 // @1F61 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 // @1F87 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x63656976657220696d706c656d656e7465720000000000000000000000000000 // @1F8A stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_1F8F: // Incoming call from 0x15DD, returns to 0x15DE // Inputs[1] { @1F92 stack[-1] } 1F8F 5B JUMPDEST 1F90 60 PUSH1 0x60 1F92 81 DUP2 1F93 61 PUSH2 0x1fcf 1F96 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F90 stack[0] = 0x60 } // Block ends with conditional jump to 0x1fcf, if stack[-1] label_1F97: // Incoming jump from 0x1F96, if not stack[-1] // Inputs[2] // { // @1F9C memory[0x40:0x60] // @1FCD stack[-3] // } 1F97 50 POP 1F98 50 POP 1F99 60 PUSH1 0x40 1F9B 80 DUP1 1F9C 51 MLOAD 1F9D 80 DUP1 1F9E 82 DUP3 1F9F 01 ADD 1FA0 90 SWAP1 1FA1 91 SWAP2 1FA2 52 MSTORE 1FA3 60 PUSH1 0x01 1FA5 81 DUP2 1FA6 52 MSTORE 1FA7 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 1FC8 60 PUSH1 0x20 1FCA 82 DUP3 1FCB 01 ADD 1FCC 52 MSTORE 1FCD 90 SWAP1 1FCE 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @1FA2 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1FA6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @1FCC memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x3000000000000000000000000000000000000000000000000000000000000000 // @1FCD stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_1FCF: // Incoming jump from 0x1F96, if stack[-1] // Inputs[1] { @1FD0 stack[-2] } 1FCF 5B JUMPDEST 1FD0 81 DUP2 1FD1 60 PUSH1 0x00 1FD3 5B JUMPDEST 1FD4 81 DUP2 1FD5 15 ISZERO 1FD6 61 PUSH2 0x1ff9 1FD9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1FD0 stack[0] = stack[-2] // @1FD1 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ff9, if !stack[-2] label_1FDA: // Incoming jump from 0x1FD9, if not !stack[-2] // Incoming jump from 0x1FD9, if not !stack[-2] // Inputs[1] { @1FDA stack[-1] } 1FDA 80 DUP1 1FDB 61 PUSH2 0x1fe3 1FDE 81 DUP2 1FDF 61 PUSH2 0x2d33 1FE2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1FDA stack[0] = stack[-1] // @1FDB stack[1] = 0x1fe3 // @1FDE stack[2] = stack[-1] // } // Block ends with call to 0x2d33, returns to 0x1FE3 label_1FE3: // Incoming return from call to 0x2D33 at 0x1FE2 // Inputs[4] // { // @1FE4 stack[-3] // @1FE4 stack[-1] // @1FE9 stack[-2] // @1FED stack[-4] // } 1FE3 5B JUMPDEST 1FE4 91 SWAP2 1FE5 50 POP 1FE6 61 PUSH2 0x1ff2 1FE9 90 SWAP1 1FEA 50 POP 1FEB 60 PUSH1 0x0a 1FED 83 DUP4 1FEE 61 PUSH2 0x2c82 1FF1 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1FE4 stack[-3] = stack[-1] // @1FE9 stack[-2] = 0x1ff2 // @1FEB stack[-1] = 0x0a // @1FED stack[0] = stack[-4] // } // Block ends with call to 0x2c82, returns to 0x1FF2 label_1FF2: // Incoming return from call to 0x2C82 at 0x1FF1 // Inputs[2] // { // @1FF3 stack[-1] // @1FF3 stack[-3] // } 1FF2 5B JUMPDEST 1FF3 91 SWAP2 1FF4 50 POP 1FF5 61 PUSH2 0x1fd3 1FF8 56 *JUMP // Stack delta = -1 // Outputs[1] { @1FF3 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1fd3 label_1FF9: // Incoming jump from 0x1FD9, if !stack[-2] // Incoming jump from 0x1FD9, if !stack[-2] // Inputs[1] { @1FFC stack[-1] } 1FF9 5B JUMPDEST 1FFA 60 PUSH1 0x00 1FFC 81 DUP2 1FFD 67 PUSH8 0xffffffffffffffff 2006 81 DUP2 2007 11 GT 2008 15 ISZERO 2009 61 PUSH2 0x2014 200C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1FFA stack[0] = 0x00 // @1FFC stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2014, if !(stack[-1] > 0xffffffffffffffff) label_200D: // Incoming jump from 0x200C, if not !(stack[-1] > 0xffffffffffffffff) 200D 61 PUSH2 0x2014 2010 61 PUSH2 0x2dba 2013 56 *JUMP // Stack delta = +1 // Outputs[1] { @200D stack[0] = 0x2014 } // Block ends with unconditional jump to 0x2dba label_2014: // Incoming jump from 0x200C, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @2017 memory[0x40:0x60] // @2018 stack[-1] // } 2014 5B JUMPDEST 2015 60 PUSH1 0x40 2017 51 MLOAD 2018 90 SWAP1 2019 80 DUP1 201A 82 DUP3 201B 52 MSTORE 201C 80 DUP1 201D 60 PUSH1 0x1f 201F 01 ADD 2020 60 PUSH1 0x1f 2022 19 NOT 2023 16 AND 2024 60 PUSH1 0x20 2026 01 ADD 2027 82 DUP3 2028 01 ADD 2029 60 PUSH1 0x40 202B 52 MSTORE 202C 80 DUP1 202D 15 ISZERO 202E 61 PUSH2 0x203e 2031 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @2018 stack[-1] = memory[0x40:0x60] // @2018 stack[0] = stack[-1] // @201B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @202B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x203e, if !stack[-1] label_2032: // Incoming jump from 0x2031, if not !stack[-1] // Inputs[6] // { // @2034 stack[-2] // @2036 stack[-1] // @2038 msg.data.length // @203A msg.data[msg.data.length:msg.data.length + stack[-1]] // @2040 stack[-3] // @2043 stack[-7] // } 2032 60 PUSH1 0x20 2034 82 DUP3 2035 01 ADD 2036 81 DUP2 2037 80 DUP1 2038 36 CALLDATASIZE 2039 83 DUP4 203A 37 CALLDATACOPY 203B 01 ADD 203C 90 SWAP1 203D 50 POP 203E 5B JUMPDEST 203F 50 POP 2040 90 SWAP1 2041 50 POP 2042 5B JUMPDEST 2043 84 DUP5 2044 15 ISZERO 2045 61 PUSH2 0x1ca0 2048 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @203A memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @2040 stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x1ca0, if !stack[-7] label_2049: // Incoming jump from 0x2048, if not !stack[-7] // Incoming jump from 0x2048, if not !stack[-5] // Incoming jump from 0x2048, if not !stack[-7] // Inputs[1] { @204E stack[-2] } 2049 61 PUSH2 0x2053 204C 60 PUSH1 0x01 204E 83 DUP4 204F 61 PUSH2 0x2cb5 2052 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2049 stack[0] = 0x2053 // @204C stack[1] = 0x01 // @204E stack[2] = stack[-2] // } // Block ends with call to 0x2cb5, returns to 0x2053 label_2053: // Incoming return from call to 0x2CB5 at 0x2052 // Inputs[3] // { // @2054 stack[-3] // @2054 stack[-1] // @205B stack[-6] // } 2053 5B JUMPDEST 2054 91 SWAP2 2055 50 POP 2056 61 PUSH2 0x2060 2059 60 PUSH1 0x0a 205B 86 DUP7 205C 61 PUSH2 0x2d4e 205F 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2054 stack[-3] = stack[-1] // @2056 stack[-1] = 0x2060 // @2059 stack[0] = 0x0a // @205B stack[1] = stack[-6] // } // Block ends with call to 0x2d4e, returns to 0x2060 label_2060: // Incoming return from call to 0x2D4E at 0x205F // Inputs[1] { @2064 stack[-1] } 2060 5B JUMPDEST 2061 61 PUSH2 0x206b 2064 90 SWAP1 2065 60 PUSH1 0x30 2067 61 PUSH2 0x2c6a 206A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2064 stack[0] = stack[-1] // @2064 stack[-1] = 0x206b // @2065 stack[1] = 0x30 // } // Block ends with call to 0x2c6a, returns to 0x206B label_206B: // Incoming return from call to 0x2C6A at 0x206A // Inputs[4] // { // @206E stack[-1] // @206F stack[-2] // @2070 stack[-3] // @2072 memory[stack[-2]:stack[-2] + 0x20] // } 206B 5B JUMPDEST 206C 60 PUSH1 0xf8 206E 1B SHL 206F 81 DUP2 2070 83 DUP4 2071 81 DUP2 2072 51 MLOAD 2073 81 DUP2 2074 10 LT 2075 61 PUSH2 0x2080 2078 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @206E stack[-1] = stack[-1] << 0xf8 // @206F stack[0] = stack[-2] // @2070 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x2080, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_2079: // Incoming jump from 0x2078, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] 2079 61 PUSH2 0x2080 207C 61 PUSH2 0x2da4 207F 56 *JUMP // Stack delta = +1 // Outputs[1] { @2079 stack[0] = 0x2080 } // Block ends with unconditional jump to 0x2da4 label_2080: // Incoming jump from 0x2078, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @2083 stack[-1] // @2084 stack[-2] // @2085 stack[-3] // @20B5 stack[-8] // } 2080 5B JUMPDEST 2081 60 PUSH1 0x20 2083 01 ADD 2084 01 ADD 2085 90 SWAP1 2086 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 20A6 19 NOT 20A7 16 AND 20A8 90 SWAP1 20A9 81 DUP2 20AA 60 PUSH1 0x00 20AC 1A BYTE 20AD 90 SWAP1 20AE 53 MSTORE8 20AF 50 POP 20B0 61 PUSH2 0x20ba 20B3 60 PUSH1 0x0a 20B5 86 DUP7 20B6 61 PUSH2 0x2c82 20B9 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @20AE memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @20B0 stack[-3] = 0x20ba // @20B3 stack[-2] = 0x0a // @20B5 stack[-1] = stack[-8] // } // Block ends with call to 0x2c82, returns to 0x20BA label_20BA: // Incoming return from call to 0x2C82 at 0x20B9 // Inputs[2] // { // @20BB stack[-6] // @20BB stack[-1] // } 20BA 5B JUMPDEST 20BB 94 SWAP5 20BC 50 POP 20BD 61 PUSH2 0x2042 20C0 56 *JUMP // Stack delta = -1 // Outputs[1] { @20BB stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x2042 label_20C1: // Incoming call from 0x1802, returns to 0x1803 // Inputs[3] // { // @20C4 stack[-1] // @20C7 stack[-3] // @20C8 memory[stack[-3]:stack[-3] + 0x20] // } 20C1 5B JUMPDEST 20C2 60 PUSH1 0x00 20C4 81 DUP2 20C5 81 DUP2 20C6 5B JUMPDEST 20C7 85 DUP6 20C8 51 MLOAD 20C9 81 DUP2 20CA 10 LT 20CB 15 ISZERO 20CC 61 PUSH2 0x2165 20CF 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @20C2 stack[0] = 0x00 // @20C4 stack[1] = stack[-1] // @20C5 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2165, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_20D0: // Incoming jump from 0x20CF, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x20CF, if not !(stack[-1] < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[3] // { // @20D2 stack[-6] // @20D3 stack[-1] // @20D5 memory[stack[-6]:stack[-6] + 0x20] // } 20D0 60 PUSH1 0x00 20D2 86 DUP7 20D3 82 DUP3 20D4 81 DUP2 20D5 51 MLOAD 20D6 81 DUP2 20D7 10 LT 20D8 61 PUSH2 0x20e3 20DB 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @20D0 stack[0] = 0x00 // @20D2 stack[1] = stack[-6] // @20D3 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x20e3, if stack[-1] < memory[stack[-6]:stack[-6] + 0x20] label_20DC: // Incoming jump from 0x20DB, if not stack[-1] < memory[stack[-6]:stack[-6] + 0x20] 20DC 61 PUSH2 0x20e3 20DF 61 PUSH2 0x2da4 20E2 56 *JUMP // Stack delta = +1 // Outputs[1] { @20DC stack[0] = 0x20e3 } // Block ends with unconditional jump to 0x2da4 label_20E3: // Incoming jump from 0x20DB, if stack[-1] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[5] // { // @20E6 stack[-1] // @20EA stack[-2] // @20EB memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @20EC stack[-3] // @20EF stack[-5] // } 20E3 5B JUMPDEST 20E4 60 PUSH1 0x20 20E6 02 MUL 20E7 60 PUSH1 0x20 20E9 01 ADD 20EA 01 ADD 20EB 51 MLOAD 20EC 90 SWAP1 20ED 50 POP 20EE 80 DUP1 20EF 83 DUP4 20F0 11 GT 20F1 61 PUSH2 0x2125 20F4 57 *JUMPI // Stack delta = -2 // Outputs[1] { @20EC stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with conditional jump to 0x2125, if stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_20F5: // Incoming jump from 0x20F4, if not stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[6] // { // @20F8 memory[0x40:0x60] // @20FD stack[-3] // @2103 stack[-1] // @210B memory[0x40:0x60] // @2119 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @211E memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // } 20F5 60 PUSH1 0x40 20F7 80 DUP1 20F8 51 MLOAD 20F9 60 PUSH1 0x20 20FB 81 DUP2 20FC 01 ADD 20FD 85 DUP6 20FE 90 SWAP1 20FF 52 MSTORE 2100 90 SWAP1 2101 81 DUP2 2102 01 ADD 2103 82 DUP3 2104 90 SWAP1 2105 52 MSTORE 2106 60 PUSH1 0x60 2108 01 ADD 2109 60 PUSH1 0x40 210B 51 MLOAD 210C 60 PUSH1 0x20 210E 81 DUP2 210F 83 DUP4 2110 03 SUB 2111 03 SUB 2112 81 DUP2 2113 52 MSTORE 2114 90 SWAP1 2115 60 PUSH1 0x40 2117 52 MSTORE 2118 80 DUP1 2119 51 MLOAD 211A 90 SWAP1 211B 60 PUSH1 0x20 211D 01 ADD 211E 20 SHA3 211F 92 SWAP3 2120 50 POP 2121 61 PUSH2 0x2152 2124 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @20FF memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-3] // @2105 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-1] // @2113 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x60 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @2117 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @211F stack[-3] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with unconditional jump to 0x2152 label_2125: // Incoming jump from 0x20F4, if stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[7] // { // @2129 memory[0x40:0x60] // @212E stack[-1] // @2134 stack[-3] // @213C memory[0x40:0x60] // @214A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @214F memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @2154 stack[-2] // } 2125 5B JUMPDEST 2126 60 PUSH1 0x40 2128 80 DUP1 2129 51 MLOAD 212A 60 PUSH1 0x20 212C 81 DUP2 212D 01 ADD 212E 83 DUP4 212F 90 SWAP1 2130 52 MSTORE 2131 90 SWAP1 2132 81 DUP2 2133 01 ADD 2134 84 DUP5 2135 90 SWAP1 2136 52 MSTORE 2137 60 PUSH1 0x60 2139 01 ADD 213A 60 PUSH1 0x40 213C 51 MLOAD 213D 60 PUSH1 0x20 213F 81 DUP2 2140 83 DUP4 2141 03 SUB 2142 03 SUB 2143 81 DUP2 2144 52 MSTORE 2145 90 SWAP1 2146 60 PUSH1 0x40 2148 52 MSTORE 2149 80 DUP1 214A 51 MLOAD 214B 90 SWAP1 214C 60 PUSH1 0x20 214E 01 ADD 214F 20 SHA3 2150 92 SWAP3 2151 50 POP 2152 5B JUMPDEST 2153 50 POP 2154 80 DUP1 2155 61 PUSH2 0x215d 2158 81 DUP2 2159 61 PUSH2 0x2d33 215C 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @2130 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @2136 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-3] // @2144 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x60 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @2148 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @2150 stack[-3] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @2154 stack[-1] = stack[-2] // @2155 stack[0] = 0x215d // @2158 stack[1] = stack[-2] // } // Block ends with call to 0x2d33, returns to 0x215D label_215D: // Incoming return from call to 0x2D33 at 0x215C // Incoming return from call to 0x2D33 at 0x215C // Inputs[2] // { // @215E stack[-3] // @215E stack[-1] // } 215D 5B JUMPDEST 215E 91 SWAP2 215F 50 POP 2160 50 POP 2161 61 PUSH2 0x20c6 2164 56 *JUMP // Stack delta = -2 // Outputs[1] { @215E stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x20c6 label_2165: // Incoming jump from 0x20CF, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x20CF, if !(stack[-1] < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[5] // { // @2167 stack[-2] // @2167 stack[-3] // @2168 stack[-5] // @216A stack[-7] // @216B stack[-6] // } 2165 5B JUMPDEST 2166 50 POP 2167 90 SWAP1 2168 92 SWAP3 2169 14 EQ 216A 93 SWAP4 216B 92 SWAP3 216C 50 POP 216D 50 POP 216E 50 POP 216F 56 *JUMP // Stack delta = -6 // Outputs[1] { @216A stack[-7] = stack[-5] == stack[-2] } // Block ends with unconditional jump to stack[-7] label_2170: // Incoming call from 0x1DBC, returns to 0x1DBD // Incoming call from 0x266A, returns to 0x266B // Inputs[1] { @2179 stack[-3] } 2170 5B JUMPDEST 2171 60 PUSH1 0x01 2173 60 PUSH1 0x01 2175 60 PUSH1 0xa0 2177 1B SHL 2178 03 SUB 2179 83 DUP4 217A 16 AND 217B 61 PUSH2 0x21cb 217E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x21cb, if stack[-3] & (0x01 << 0xa0) - 0x01 label_217F: // Incoming jump from 0x217E, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @2182 stack[-1] // @2186 storage[0x08] // @2194 memory[0x00:0x40] // } 217F 61 PUSH2 0x21c6 2182 81 DUP2 2183 60 PUSH1 0x08 2185 80 DUP1 2186 54 SLOAD 2187 60 PUSH1 0x00 2189 83 DUP4 218A 81 DUP2 218B 52 MSTORE 218C 60 PUSH1 0x09 218E 60 PUSH1 0x20 2190 52 MSTORE 2191 60 PUSH1 0x40 2193 81 DUP2 2194 20 SHA3 2195 82 DUP3 2196 90 SWAP1 2197 55 SSTORE 2198 60 PUSH1 0x01 219A 82 DUP3 219B 01 ADD 219C 83 DUP4 219D 55 SSTORE 219E 91 SWAP2 219F 90 SWAP1 21A0 91 SWAP2 21A1 52 MSTORE 21A2 7F PUSH32 0xf3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee3 21C3 01 ADD 21C4 55 SSTORE 21C5 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @218B memory[0x00:0x20] = stack[-1] // @2190 memory[0x20:0x40] = 0x09 // @2197 storage[keccak256(memory[0x00:0x40])] = storage[0x08] // @219D storage[0x08] = storage[0x08] + 0x01 // @21A1 memory[0x00:0x20] = 0x08 // @21C4 storage[0xf3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee3 + storage[0x08]] = stack[-1] // } // Block ends with unconditional jump to 0x21c6 label_21C6: // Incoming jump from 0x21C5 21C6 5B JUMPDEST 21C7 61 PUSH2 0x21ee 21CA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x21ee label_21CB: // Incoming jump from 0x217E, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @21CC stack[-2] // @21D6 stack[-3] // } 21CB 5B JUMPDEST 21CC 81 DUP2 21CD 60 PUSH1 0x01 21CF 60 PUSH1 0x01 21D1 60 PUSH1 0xa0 21D3 1B SHL 21D4 03 SUB 21D5 16 AND 21D6 83 DUP4 21D7 60 PUSH1 0x01 21D9 60 PUSH1 0x01 21DB 60 PUSH1 0xa0 21DD 1B SHL 21DE 03 SUB 21DF 16 AND 21E0 14 EQ 21E1 61 PUSH2 0x21ee 21E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x21ee, if (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] label_21E5: // Incoming jump from 0x21E4, if not (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] // Inputs[2] // { // @21E8 stack[-3] // @21E9 stack[-1] // } 21E5 61 PUSH2 0x21ee 21E8 83 DUP4 21E9 82 DUP3 21EA 61 PUSH2 0x2414 21ED 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @21E5 stack[0] = 0x21ee // @21E8 stack[1] = stack[-3] // @21E9 stack[2] = stack[-1] // } // Block ends with call to 0x2414, returns to 0x21EE label_21EE: // Incoming jump from 0x21CA // Incoming return from call to 0x2414 at 0x21ED // Incoming jump from 0x21E4, if (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] // Inputs[1] { @21F7 stack[-2] } 21EE 5B JUMPDEST 21EF 60 PUSH1 0x01 21F1 60 PUSH1 0x01 21F3 60 PUSH1 0xa0 21F5 1B SHL 21F6 03 SUB 21F7 82 DUP3 21F8 16 AND 21F9 61 PUSH2 0x2205 21FC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2205, if stack[-2] & (0x01 << 0xa0) - 0x01 label_21FD: // Incoming jump from 0x21FC, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2200 stack[-1] } 21FD 61 PUSH2 0x0a3e 2200 81 DUP2 2201 61 PUSH2 0x24b1 2204 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @21FD stack[0] = 0x0a3e // @2200 stack[1] = stack[-1] // } // Block ends with call to 0x24b1, returns to 0x0A3E label_2205: // Incoming jump from 0x21FC, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @2206 stack[-3] // @2210 stack[-2] // } 2205 5B JUMPDEST 2206 82 DUP3 2207 60 PUSH1 0x01 2209 60 PUSH1 0x01 220B 60 PUSH1 0xa0 220D 1B SHL 220E 03 SUB 220F 16 AND 2210 82 DUP3 2211 60 PUSH1 0x01 2213 60 PUSH1 0x01 2215 60 PUSH1 0xa0 2217 1B SHL 2218 03 SUB 2219 16 AND 221A 14 EQ 221B 61 PUSH2 0x0a3e 221E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a3e, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] label_221F: // Incoming jump from 0x221E, if not (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[2] // { // @2222 stack[-2] // @2223 stack[-1] // } 221F 61 PUSH2 0x0a3e 2222 82 DUP3 2223 82 DUP3 2224 61 PUSH2 0x2560 2227 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @221F stack[0] = 0x0a3e // @2222 stack[1] = stack[-2] // @2223 stack[2] = stack[-1] // } // Block ends with call to 0x2560, returns to 0x0A3E label_2228: // Incoming call from 0x1EA6, returns to 0x0FAB // Inputs[2] // { // @222C stack[-3] // @222D stack[-2] // } 2228 5B JUMPDEST 2229 61 PUSH2 0x2232 222C 83 DUP4 222D 83 DUP4 222E 61 PUSH2 0x25a4 2231 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2229 stack[0] = 0x2232 // @222C stack[1] = stack[-3] // @222D stack[2] = stack[-2] // } // Block ends with call to 0x25a4, returns to 0x2232 label_2232: // Incoming return from call to 0x25A4 at 0x2231 // Inputs[3] // { // @2238 stack[-3] // @2239 stack[-2] // @223A stack[-1] // } 2232 5B JUMPDEST 2233 61 PUSH2 0x223f 2236 60 PUSH1 0x00 2238 84 DUP5 2239 84 DUP5 223A 84 DUP5 223B 61 PUSH2 0x22b1 223E 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2233 stack[0] = 0x223f // @2236 stack[1] = 0x00 // @2238 stack[2] = stack[-3] // @2239 stack[3] = stack[-2] // @223A stack[4] = stack[-1] // } // Block ends with call to 0x22b1, returns to 0x223F label_223F: // Incoming return from call to 0x22B1 at 0x223E // Inputs[1] { @2243 stack[-1] } 223F 5B JUMPDEST 2240 61 PUSH2 0x0a3e 2243 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a3e, if stack[-1] label_2244: // Incoming jump from 0x2243, if not stack[-1] // Inputs[1] { @2246 memory[0x40:0x60] } 2244 60 PUSH1 0x40 2246 51 MLOAD 2247 62 PUSH3 0x461bcd 224B 60 PUSH1 0xe5 224D 1B SHL 224E 81 DUP2 224F 52 MSTORE 2250 60 PUSH1 0x20 2252 60 PUSH1 0x04 2254 82 DUP3 2255 01 ADD 2256 52 MSTORE 2257 60 PUSH1 0x32 2259 60 PUSH1 0x24 225B 82 DUP3 225C 01 ADD 225D 52 MSTORE 225E 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 227F 60 PUSH1 0x44 2281 82 DUP3 2282 01 ADD 2283 52 MSTORE 2284 7F PUSH32 0x63656976657220696d706c656d656e7465720000000000000000000000000000 22A5 60 PUSH1 0x64 22A7 82 DUP3 22A8 01 ADD 22A9 52 MSTORE 22AA 60 PUSH1 0x84 22AC 01 ADD 22AD 61 PUSH2 0x08ec 22B0 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @224F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2256 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @225D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x32 // @2283 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 // @22A9 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x63656976657220696d706c656d656e7465720000000000000000000000000000 // @22AC stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_22B1: // Incoming call from 0x1F1C, returns to 0x1F1D // Incoming call from 0x223E, returns to 0x223F // Inputs[2] // { // @22BC stack[-3] // @22BE address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 22B1 5B JUMPDEST 22B2 60 PUSH1 0x00 22B4 60 PUSH1 0x01 22B6 60 PUSH1 0x01 22B8 60 PUSH1 0xa0 22BA 1B SHL 22BB 03 SUB 22BC 84 DUP5 22BD 16 AND 22BE 3B EXTCODESIZE 22BF 15 ISZERO 22C0 61 PUSH2 0x2409 22C3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22B2 stack[0] = 0x00 } // Block ends with conditional jump to 0x2409, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_22C4: // Incoming jump from 0x22C3, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[6] // { // @22C6 memory[0x40:0x60] // @22D9 stack[-4] // @22E6 msg.sender // @22E8 stack[-5] // @22EA stack[-3] // @22EC stack[-2] // } 22C4 60 PUSH1 0x40 22C6 51 MLOAD 22C7 63 PUSH4 0x0a85bd01 22CC 60 PUSH1 0xe1 22CE 1B SHL 22CF 81 DUP2 22D0 52 MSTORE 22D1 60 PUSH1 0x01 22D3 60 PUSH1 0x01 22D5 60 PUSH1 0xa0 22D7 1B SHL 22D8 03 SUB 22D9 85 DUP6 22DA 16 AND 22DB 90 SWAP1 22DC 63 PUSH4 0x150b7a02 22E1 90 SWAP1 22E2 61 PUSH2 0x22f5 22E5 90 SWAP1 22E6 33 CALLER 22E7 90 SWAP1 22E8 89 DUP10 22E9 90 SWAP1 22EA 88 DUP9 22EB 90 SWAP1 22EC 88 DUP9 22ED 90 SWAP1 22EE 60 PUSH1 0x04 22F0 01 ADD 22F1 61 PUSH2 0x2c25 22F4 56 *JUMP // Stack delta = +8 // Outputs[9] // { // @22D0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @22DB stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @22E1 stack[1] = 0x150b7a02 // @22E5 stack[2] = 0x22f5 // @22E7 stack[3] = msg.sender // @22E9 stack[4] = stack[-5] // @22EB stack[5] = stack[-3] // @22ED stack[6] = stack[-2] // @22F0 stack[7] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2c25 22F5 5B JUMPDEST 22F6 60 PUSH1 0x20 22F8 60 PUSH1 0x40 22FA 51 MLOAD 22FB 80 DUP1 22FC 83 DUP4 22FD 03 SUB 22FE 81 DUP2 22FF 60 PUSH1 0x00 2301 87 DUP8 2302 80 DUP1 2303 3B EXTCODESIZE 2304 15 ISZERO 2305 80 DUP1 2306 15 ISZERO 2307 61 PUSH2 0x230f 230A 57 *JUMPI 230B 60 PUSH1 0x00 230D 80 DUP1 230E FD *REVERT 230F 5B JUMPDEST 2310 50 POP 2311 5A GAS 2312 F1 CALL 2313 92 SWAP3 2314 50 POP 2315 50 POP 2316 50 POP 2317 80 DUP1 2318 15 ISZERO 2319 61 PUSH2 0x233f 231C 57 *JUMPI 231D 50 POP 231E 60 PUSH1 0x40 2320 80 DUP1 2321 51 MLOAD 2322 60 PUSH1 0x1f 2324 3D RETURNDATASIZE 2325 90 SWAP1 2326 81 DUP2 2327 01 ADD 2328 60 PUSH1 0x1f 232A 19 NOT 232B 16 AND 232C 82 DUP3 232D 01 ADD 232E 90 SWAP1 232F 92 SWAP3 2330 52 MSTORE 2331 61 PUSH2 0x233c 2334 91 SWAP2 2335 81 DUP2 2336 01 ADD 2337 90 SWAP1 2338 61 PUSH2 0x2a61 233B 56 *JUMP 233C 5B JUMPDEST 233D 60 PUSH1 0x01 233F 5B JUMPDEST 2340 61 PUSH2 0x23ef 2343 57 *JUMPI 2344 3D RETURNDATASIZE 2345 80 DUP1 2346 80 DUP1 2347 15 ISZERO 2348 61 PUSH2 0x236d 234B 57 *JUMPI 234C 60 PUSH1 0x40 234E 51 MLOAD 234F 91 SWAP2 2350 50 POP 2351 60 PUSH1 0x1f 2353 19 NOT 2354 60 PUSH1 0x3f 2356 3D RETURNDATASIZE 2357 01 ADD 2358 16 AND 2359 82 DUP3 235A 01 ADD 235B 60 PUSH1 0x40 235D 52 MSTORE 235E 3D RETURNDATASIZE 235F 82 DUP3 2360 52 MSTORE 2361 3D RETURNDATASIZE 2362 60 PUSH1 0x00 2364 60 PUSH1 0x20 2366 84 DUP5 2367 01 ADD 2368 3E RETURNDATACOPY 2369 61 PUSH2 0x2372 236C 56 *JUMP 236D 5B JUMPDEST 236E 60 PUSH1 0x60 2370 91 SWAP2 2371 50 POP 2372 5B JUMPDEST 2373 50 POP 2374 80 DUP1 2375 51 MLOAD 2376 61 PUSH2 0x23e7 2379 57 *JUMPI 237A 60 PUSH1 0x40 237C 51 MLOAD 237D 62 PUSH3 0x461bcd 2381 60 PUSH1 0xe5 2383 1B SHL 2384 81 DUP2 2385 52 MSTORE 2386 60 PUSH1 0x20 2388 60 PUSH1 0x04 238A 82 DUP3 238B 01 ADD 238C 52 MSTORE 238D 60 PUSH1 0x32 238F 60 PUSH1 0x24 2391 82 DUP3 2392 01 ADD 2393 52 MSTORE 2394 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 23B5 60 PUSH1 0x44 23B7 82 DUP3 23B8 01 ADD 23B9 52 MSTORE 23BA 7F PUSH32 0x63656976657220696d706c656d656e7465720000000000000000000000000000 23DB 60 PUSH1 0x64 23DD 82 DUP3 23DE 01 ADD 23DF 52 MSTORE 23E0 60 PUSH1 0x84 23E2 01 ADD 23E3 61 PUSH2 0x08ec 23E6 56 *JUMP 23E7 5B JUMPDEST 23E8 80 DUP1 23E9 51 MLOAD 23EA 81 DUP2 23EB 60 PUSH1 0x20 23ED 01 ADD 23EE FD *REVERT 23EF 5B JUMPDEST 23F0 60 PUSH1 0x01 23F2 60 PUSH1 0x01 23F4 60 PUSH1 0xe0 23F6 1B SHL 23F7 03 SUB 23F8 19 NOT 23F9 16 AND 23FA 63 PUSH4 0x0a85bd01 23FF 60 PUSH1 0xe1 2401 1B SHL 2402 14 EQ 2403 90 SWAP1 2404 50 POP 2405 61 PUSH2 0x1ca0 2408 56 *JUMP label_2409: // Incoming jump from 0x22C3, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[2] // { // @240D stack[-6] // @240E stack[-5] // } 2409 5B JUMPDEST 240A 50 POP 240B 60 PUSH1 0x01 240D 94 SWAP5 240E 93 SWAP4 240F 50 POP 2410 50 POP 2411 50 POP 2412 50 POP 2413 56 *JUMP // Stack delta = -5 // Outputs[1] { @240D stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_2414: // Incoming call from 0x21ED, returns to 0x21EE // Inputs[1] { @241C stack[-2] } 2414 5B JUMPDEST 2415 60 PUSH1 0x00 2417 60 PUSH1 0x01 2419 61 PUSH2 0x2421 241C 84 DUP5 241D 61 PUSH2 0x10c8 2420 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2415 stack[0] = 0x00 // @2417 stack[1] = 0x01 // @2419 stack[2] = 0x2421 // @241C stack[3] = stack[-2] // } // Block ends with call to 0x10c8, returns to 0x2421 label_2421: // Incoming return from call to 0x10C8 at 0x2420 // Inputs[2] // { // @2425 stack[-2] // @2426 stack[-1] // } 2421 5B JUMPDEST 2422 61 PUSH2 0x242b 2425 91 SWAP2 2426 90 SWAP1 2427 61 PUSH2 0x2cb5 242A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2425 stack[-2] = 0x242b // @2426 stack[-1] = stack[-2] // @2426 stack[0] = stack[-1] // } // Block ends with call to 0x2cb5, returns to 0x242B label_242B: // Incoming return from call to 0x2CB5 at 0x242A // Inputs[5] // { // @242E stack[-3] // @2439 memory[0x00:0x40] // @243A storage[keccak256(memory[0x00:0x40])] // @243B stack[-1] // @243C stack[-2] // } 242B 5B JUMPDEST 242C 60 PUSH1 0x00 242E 83 DUP4 242F 81 DUP2 2430 52 MSTORE 2431 60 PUSH1 0x07 2433 60 PUSH1 0x20 2435 52 MSTORE 2436 60 PUSH1 0x40 2438 90 SWAP1 2439 20 SHA3 243A 54 SLOAD 243B 90 SWAP1 243C 91 SWAP2 243D 50 POP 243E 80 DUP1 243F 82 DUP3 2440 14 EQ 2441 61 PUSH2 0x247e 2444 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2430 memory[0x00:0x20] = stack[-3] // @2435 memory[0x20:0x40] = 0x07 // @243B stack[-1] = storage[keccak256(memory[0x00:0x40])] // @243C stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x247e, if stack[-1] == storage[keccak256(memory[0x00:0x40])] label_2445: // Incoming jump from 0x2444, if not stack[-1] == storage[keccak256(memory[0x00:0x40])] // Inputs[13] // { // @244D stack[-4] // @245F memory[0x00:0x40] // @2460 stack[-2] // @2467 memory[0x00:0x40] // @2468 storage[keccak256(memory[0x00:0x40])] // @2469 stack[-1] // @246E memory[0x00:0x40] // @247A memory[0x00:0x40] // @2482 stack[-3] // @2490 memory[0x00:0x40] // @24A7 memory[0x00:0x40] // @24AE memory[0x00:0x40] // @24B0 stack[-5] // } 2445 60 PUSH1 0x01 2447 60 PUSH1 0x01 2449 60 PUSH1 0xa0 244B 1B SHL 244C 03 SUB 244D 84 DUP5 244E 16 AND 244F 60 PUSH1 0x00 2451 90 SWAP1 2452 81 DUP2 2453 52 MSTORE 2454 60 PUSH1 0x06 2456 60 PUSH1 0x20 2458 90 SWAP1 2459 81 DUP2 245A 52 MSTORE 245B 60 PUSH1 0x40 245D 80 DUP1 245E 83 DUP4 245F 20 SHA3 2460 85 DUP6 2461 84 DUP5 2462 52 MSTORE 2463 82 DUP3 2464 52 MSTORE 2465 80 DUP1 2466 83 DUP4 2467 20 SHA3 2468 54 SLOAD 2469 84 DUP5 246A 84 DUP5 246B 52 MSTORE 246C 81 DUP2 246D 84 DUP5 246E 20 SHA3 246F 81 DUP2 2470 90 SWAP1 2471 55 SSTORE 2472 83 DUP4 2473 52 MSTORE 2474 60 PUSH1 0x07 2476 90 SWAP1 2477 91 SWAP2 2478 52 MSTORE 2479 90 SWAP1 247A 20 SHA3 247B 81 DUP2 247C 90 SWAP1 247D 55 SSTORE 247E 5B JUMPDEST 247F 50 POP 2480 60 PUSH1 0x00 2482 91 SWAP2 2483 82 DUP3 2484 52 MSTORE 2485 60 PUSH1 0x07 2487 60 PUSH1 0x20 2489 90 SWAP1 248A 81 DUP2 248B 52 MSTORE 248C 60 PUSH1 0x40 248E 80 DUP1 248F 84 DUP5 2490 20 SHA3 2491 84 DUP5 2492 90 SWAP1 2493 55 SSTORE 2494 60 PUSH1 0x01 2496 60 PUSH1 0x01 2498 60 PUSH1 0xa0 249A 1B SHL 249B 03 SUB 249C 90 SWAP1 249D 94 SWAP5 249E 16 AND 249F 83 DUP4 24A0 52 MSTORE 24A1 60 PUSH1 0x06 24A3 81 DUP2 24A4 52 MSTORE 24A5 83 DUP4 24A6 83 DUP4 24A7 20 SHA3 24A8 91 SWAP2 24A9 83 DUP4 24AA 52 MSTORE 24AB 52 MSTORE 24AC 90 SWAP1 24AD 81 DUP2 24AE 20 SHA3 24AF 55 SSTORE 24B0 56 *JUMP // Stack delta = -5 // Outputs[17] // { // @2453 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @245A memory[0x20:0x40] = 0x06 // @2462 memory[0x00:0x20] = stack[-2] // @2464 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @246B memory[0x00:0x20] = stack[-1] // @2471 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] // @2473 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @2478 memory[0x20:0x40] = 0x07 // @247D storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2484 memory[0x00:0x20] = stack[-3] // @248B memory[0x20:0x40] = 0x07 // @2493 storage[keccak256(memory[0x00:0x40])] = 0x00 // @24A0 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @24A4 memory[0x20:0x40] = 0x06 // @24AA memory[0x00:0x20] = stack[-2] // @24AB memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @24AF storage[keccak256(memory[0x00:0x40])] = 0x00 // } // Block ends with unconditional jump to stack[-5] label_24B1: // Incoming call from 0x2204, returns to 0x0A3E // Inputs[1] { @24B4 storage[0x08] } 24B1 5B JUMPDEST 24B2 60 PUSH1 0x08 24B4 54 SLOAD 24B5 60 PUSH1 0x00 24B7 90 SWAP1 24B8 61 PUSH2 0x24c3 24BB 90 SWAP1 24BC 60 PUSH1 0x01 24BE 90 SWAP1 24BF 61 PUSH2 0x2cb5 24C2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @24B7 stack[0] = 0x00 // @24BB stack[1] = 0x24c3 // @24BE stack[2] = 0x01 // @24BE stack[3] = storage[0x08] // } // Block ends with call to 0x2cb5, returns to 0x24C3 label_24C3: // Incoming return from call to 0x2CB5 at 0x24C2 // Inputs[6] // { // @24C6 stack[-3] // @24D1 memory[0x00:0x40] // @24D2 storage[keccak256(memory[0x00:0x40])] // @24D6 storage[0x08] // @24D7 stack[-1] // @24D8 stack[-2] // } 24C3 5B JUMPDEST 24C4 60 PUSH1 0x00 24C6 83 DUP4 24C7 81 DUP2 24C8 52 MSTORE 24C9 60 PUSH1 0x09 24CB 60 PUSH1 0x20 24CD 52 MSTORE 24CE 60 PUSH1 0x40 24D0 81 DUP2 24D1 20 SHA3 24D2 54 SLOAD 24D3 60 PUSH1 0x08 24D5 80 DUP1 24D6 54 SLOAD 24D7 93 SWAP4 24D8 94 SWAP5 24D9 50 POP 24DA 90 SWAP1 24DB 92 SWAP3 24DC 84 DUP5 24DD 90 SWAP1 24DE 81 DUP2 24DF 10 LT 24E0 61 PUSH2 0x24eb 24E3 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @24C4 stack[0] = 0x00 // @24C8 memory[0x00:0x20] = stack[-3] // @24CD memory[0x20:0x40] = 0x09 // @24D8 stack[-2] = stack[-1] // @24DA stack[1] = 0x08 // @24DB stack[-1] = storage[keccak256(memory[0x00:0x40])] // @24DD stack[2] = stack[-1] // } // Block ends with conditional jump to 0x24eb, if stack[-1] < storage[0x08] label_24E4: // Incoming jump from 0x24E3, if not stack[-1] < storage[0x08] 24E4 61 PUSH2 0x24eb 24E7 61 PUSH2 0x2da4 24EA 56 *JUMP // Stack delta = +1 // Outputs[1] { @24E4 stack[0] = 0x24eb } // Block ends with unconditional jump to 0x2da4 label_24EB: // Incoming jump from 0x24E3, if stack[-1] < storage[0x08] // Inputs[7] // { // @24EC stack[-1] // @24EC stack[-2] // @24F4 memory[0x00:0x20] // @24F6 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @24F7 stack[-3] // @24FC stack[-4] // @24FE storage[0x08] // } 24EB 5B JUMPDEST 24EC 90 SWAP1 24ED 60 PUSH1 0x00 24EF 52 MSTORE 24F0 60 PUSH1 0x20 24F2 60 PUSH1 0x00 24F4 20 SHA3 24F5 01 ADD 24F6 54 SLOAD 24F7 90 SWAP1 24F8 50 POP 24F9 80 DUP1 24FA 60 PUSH1 0x08 24FC 83 DUP4 24FD 81 DUP2 24FE 54 SLOAD 24FF 81 DUP2 2500 10 LT 2501 61 PUSH2 0x250c 2504 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @24EF memory[0x00:0x20] = stack[-2] // @24F7 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @24F9 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @24FA stack[-1] = 0x08 // @24FC stack[0] = stack[-4] // } // Block ends with conditional jump to 0x250c, if stack[-4] < storage[0x08] label_2505: // Incoming jump from 0x2504, if not stack[-4] < storage[0x08] 2505 61 PUSH2 0x250c 2508 61 PUSH2 0x2da4 250B 56 *JUMP // Stack delta = +1 // Outputs[1] { @2505 stack[0] = 0x250c } // Block ends with unconditional jump to 0x2da4 label_250C: // Incoming jump from 0x2504, if stack[-4] < storage[0x08] // Inputs[10] // { // @250F stack[-2] // @2516 memory[0x00:0x20] // @2518 stack[-1] // @251A stack[-3] // @251E stack[-4] // @252A memory[0x00:0x40] // @252B stack[-5] // @252E stack[-7] // @2532 memory[0x00:0x40] // @2537 storage[0x08] // } 250C 5B JUMPDEST 250D 60 PUSH1 0x00 250F 91 SWAP2 2510 82 DUP3 2511 52 MSTORE 2512 60 PUSH1 0x20 2514 80 DUP1 2515 83 DUP4 2516 20 SHA3 2517 90 SWAP1 2518 91 SWAP2 2519 01 ADD 251A 92 SWAP3 251B 90 SWAP1 251C 92 SWAP3 251D 55 SSTORE 251E 82 DUP3 251F 81 DUP2 2520 52 MSTORE 2521 60 PUSH1 0x09 2523 90 SWAP1 2524 91 SWAP2 2525 52 MSTORE 2526 60 PUSH1 0x40 2528 80 DUP1 2529 82 DUP3 252A 20 SHA3 252B 84 DUP5 252C 90 SWAP1 252D 55 SSTORE 252E 85 DUP6 252F 82 DUP3 2530 52 MSTORE 2531 81 DUP2 2532 20 SHA3 2533 55 SSTORE 2534 60 PUSH1 0x08 2536 80 DUP1 2537 54 SLOAD 2538 80 DUP1 2539 61 PUSH2 0x2544 253C 57 *JUMPI // Stack delta = -1 // Outputs[9] // { // @2511 memory[0x00:0x20] = stack[-2] // @251D storage[stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // @2520 memory[0x00:0x20] = stack[-4] // @2525 memory[0x20:0x40] = 0x09 // @252D storage[keccak256(memory[0x00:0x40])] = stack[-5] // @2530 memory[0x00:0x20] = stack[-7] // @2533 storage[keccak256(memory[0x00:0x40])] = 0x00 // @2534 stack[-3] = 0x08 // @2537 stack[-2] = storage[0x08] // } // Block ends with conditional jump to 0x2544, if storage[0x08] label_253D: // Incoming jump from 0x253C, if not storage[0x08] 253D 61 PUSH2 0x2544 2540 61 PUSH2 0x2d8e 2543 56 *JUMP // Stack delta = +1 // Outputs[1] { @253D stack[0] = 0x2544 } // Block ends with unconditional jump to 0x2d8e label_2544: // Incoming jump from 0x253C, if storage[0x08] // Inputs[4] // { // @2547 stack[-1] // @2549 stack[-2] // @2553 memory[0x00:0x20] // @255F stack[-7] // } 2544 5B JUMPDEST 2545 60 PUSH1 0x01 2547 90 SWAP1 2548 03 SUB 2549 81 DUP2 254A 81 DUP2 254B 90 SWAP1 254C 60 PUSH1 0x00 254E 52 MSTORE 254F 60 PUSH1 0x20 2551 60 PUSH1 0x00 2553 20 SHA3 2554 01 ADD 2555 60 PUSH1 0x00 2557 90 SWAP1 2558 55 SSTORE 2559 90 SWAP1 255A 55 SSTORE 255B 50 POP 255C 50 POP 255D 50 POP 255E 50 POP 255F 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @254E memory[0x00:0x20] = stack[-2] // @2558 storage[keccak256(memory[0x00:0x20]) + (stack[-1] - 0x01)] = 0x00 // @255A storage[stack[-2]] = stack[-1] - 0x01 // } // Block ends with unconditional jump to stack[-7] label_2560: // Incoming call from 0x2227, returns to 0x0A3E // Inputs[1] { @2566 stack[-2] } 2560 5B JUMPDEST 2561 60 PUSH1 0x00 2563 61 PUSH2 0x256b 2566 83 DUP4 2567 61 PUSH2 0x10c8 256A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2561 stack[0] = 0x00 // @2563 stack[1] = 0x256b // @2566 stack[2] = stack[-2] // } // Block ends with call to 0x10c8, returns to 0x256B label_256B: // Incoming return from call to 0x10C8 at 0x256A // Inputs[8] // { // @2574 stack[-1] // @2575 stack[-4] // @2587 memory[0x00:0x40] // @258F memory[0x00:0x40] // @2590 stack[-3] // @259B stack[-2] // @259D memory[0x00:0x40] // @25A3 stack[-5] // } 256B 5B JUMPDEST 256C 60 PUSH1 0x01 256E 60 PUSH1 0x01 2570 60 PUSH1 0xa0 2572 1B SHL 2573 03 SUB 2574 90 SWAP1 2575 93 SWAP4 2576 16 AND 2577 60 PUSH1 0x00 2579 90 SWAP1 257A 81 DUP2 257B 52 MSTORE 257C 60 PUSH1 0x06 257E 60 PUSH1 0x20 2580 90 SWAP1 2581 81 DUP2 2582 52 MSTORE 2583 60 PUSH1 0x40 2585 80 DUP1 2586 83 DUP4 2587 20 SHA3 2588 86 DUP7 2589 84 DUP5 258A 52 MSTORE 258B 82 DUP3 258C 52 MSTORE 258D 80 DUP1 258E 83 DUP4 258F 20 SHA3 2590 85 DUP6 2591 90 SWAP1 2592 55 SSTORE 2593 93 SWAP4 2594 82 DUP3 2595 52 MSTORE 2596 60 PUSH1 0x07 2598 90 SWAP1 2599 52 MSTORE 259A 91 SWAP2 259B 90 SWAP1 259C 91 SWAP2 259D 20 SHA3 259E 91 SWAP2 259F 90 SWAP1 25A0 91 SWAP2 25A1 55 SSTORE 25A2 50 POP 25A3 56 *JUMP // Stack delta = -5 // Outputs[8] // { // @257B memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2582 memory[0x20:0x40] = 0x06 // @258A memory[0x00:0x20] = stack[-1] // @258C memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2592 storage[keccak256(memory[0x00:0x40])] = stack[-3] // @2595 memory[0x00:0x20] = stack[-3] // @2599 memory[0x20:0x40] = 0x07 // @25A1 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_25A4: // Incoming call from 0x2231, returns to 0x2232 // Inputs[1] { @25AD stack[-2] } 25A4 5B JUMPDEST 25A5 60 PUSH1 0x01 25A7 60 PUSH1 0x01 25A9 60 PUSH1 0xa0 25AB 1B SHL 25AC 03 SUB 25AD 82 DUP3 25AE 16 AND 25AF 61 PUSH2 0x25fa 25B2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x25fa, if stack[-2] & (0x01 << 0xa0) - 0x01 label_25B3: // Incoming jump from 0x25B2, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @25B5 memory[0x40:0x60] } 25B3 60 PUSH1 0x40 25B5 51 MLOAD 25B6 62 PUSH3 0x461bcd 25BA 60 PUSH1 0xe5 25BC 1B SHL 25BD 81 DUP2 25BE 52 MSTORE 25BF 60 PUSH1 0x20 25C1 60 PUSH1 0x04 25C3 82 DUP3 25C4 01 ADD 25C5 81 DUP2 25C6 90 SWAP1 25C7 52 MSTORE 25C8 60 PUSH1 0x24 25CA 82 DUP3 25CB 01 ADD 25CC 52 MSTORE 25CD 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 25EE 60 PUSH1 0x44 25F0 82 DUP3 25F1 01 ADD 25F2 52 MSTORE 25F3 60 PUSH1 0x64 25F5 01 ADD 25F6 61 PUSH2 0x08ec 25F9 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @25BE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @25C7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @25CC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @25F2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 // @25F5 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_25FA: // Incoming jump from 0x25B2, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @25FD stack[-1] // @2608 memory[0x00:0x40] // @2609 storage[keccak256(memory[0x00:0x40])] // } 25FA 5B JUMPDEST 25FB 60 PUSH1 0x00 25FD 81 DUP2 25FE 81 DUP2 25FF 52 MSTORE 2600 60 PUSH1 0x02 2602 60 PUSH1 0x20 2604 52 MSTORE 2605 60 PUSH1 0x40 2607 90 SWAP1 2608 20 SHA3 2609 54 SLOAD 260A 60 PUSH1 0x01 260C 60 PUSH1 0x01 260E 60 PUSH1 0xa0 2610 1B SHL 2611 03 SUB 2612 16 AND 2613 15 ISZERO 2614 61 PUSH2 0x265f 2617 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @25FF memory[0x00:0x20] = stack[-1] // @2604 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x265f, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_2618: // Incoming jump from 0x2617, if not !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @261A memory[0x40:0x60] } 2618 60 PUSH1 0x40 261A 51 MLOAD 261B 62 PUSH3 0x461bcd 261F 60 PUSH1 0xe5 2621 1B SHL 2622 81 DUP2 2623 52 MSTORE 2624 60 PUSH1 0x20 2626 60 PUSH1 0x04 2628 82 DUP3 2629 01 ADD 262A 52 MSTORE 262B 60 PUSH1 0x1c 262D 60 PUSH1 0x24 262F 82 DUP3 2630 01 ADD 2631 52 MSTORE 2632 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 2653 60 PUSH1 0x44 2655 82 DUP3 2656 01 ADD 2657 52 MSTORE 2658 60 PUSH1 0x64 265A 01 ADD 265B 61 PUSH2 0x08ec 265E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @2623 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @262A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2631 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1c // @2657 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 // @265A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08ec label_265F: // Incoming jump from 0x2617, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @2665 stack[-2] // @2666 stack[-1] // } 265F 5B JUMPDEST 2660 61 PUSH2 0x266b 2663 60 PUSH1 0x00 2665 83 DUP4 2666 83 DUP4 2667 61 PUSH2 0x2170 266A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2660 stack[0] = 0x266b // @2663 stack[1] = 0x00 // @2665 stack[2] = stack[-2] // @2666 stack[3] = stack[-1] // } // Block ends with call to 0x2170, returns to 0x266B label_266B: // Incoming return from call to 0x2170 at 0x266A // Inputs[3] // { // @2674 stack[-2] // @2683 memory[0x00:0x40] // @2685 storage[keccak256(memory[0x00:0x40])] // } 266B 5B JUMPDEST 266C 60 PUSH1 0x01 266E 60 PUSH1 0x01 2670 60 PUSH1 0xa0 2672 1B SHL 2673 03 SUB 2674 82 DUP3 2675 16 AND 2676 60 PUSH1 0x00 2678 90 SWAP1 2679 81 DUP2 267A 52 MSTORE 267B 60 PUSH1 0x03 267D 60 PUSH1 0x20 267F 52 MSTORE 2680 60 PUSH1 0x40 2682 81 DUP2 2683 20 SHA3 2684 80 DUP1 2685 54 SLOAD 2686 60 PUSH1 0x01 2688 92 SWAP3 2689 90 SWAP1 268A 61 PUSH2 0x2694 268D 90 SWAP1 268E 84 DUP5 268F 90 SWAP1 2690 61 PUSH2 0x2c6a 2693 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @267A memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @267F memory[0x20:0x40] = 0x03 // @2683 stack[1] = keccak256(memory[0x00:0x40]) // @2688 stack[0] = 0x01 // @2689 stack[2] = 0x00 // @268D stack[3] = 0x2694 // @268F stack[4] = 0x01 // @268F stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2c6a, returns to 0x2694 label_2694: // Incoming return from call to 0x2C6A at 0x2693 // Inputs[10] // { // @2695 stack[-1] // @2695 stack[-2] // @2696 stack[-3] // @269C stack[-5] // @26A8 memory[0x00:0x40] // @26AA storage[keccak256(memory[0x00:0x40])] // @26CA stack[-6] // @26D3 memory[0x40:0x60] // @26FB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @26FE stack[-7] // } 2694 5B JUMPDEST 2695 90 SWAP1 2696 91 SWAP2 2697 55 SSTORE 2698 50 POP 2699 50 POP 269A 60 PUSH1 0x00 269C 81 DUP2 269D 81 DUP2 269E 52 MSTORE 269F 60 PUSH1 0x02 26A1 60 PUSH1 0x20 26A3 52 MSTORE 26A4 60 PUSH1 0x40 26A6 80 DUP1 26A7 82 DUP3 26A8 20 SHA3 26A9 80 DUP1 26AA 54 SLOAD 26AB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26C0 19 NOT 26C1 16 AND 26C2 60 PUSH1 0x01 26C4 60 PUSH1 0x01 26C6 60 PUSH1 0xa0 26C8 1B SHL 26C9 03 SUB 26CA 86 DUP7 26CB 16 AND 26CC 90 SWAP1 26CD 81 DUP2 26CE 17 OR 26CF 90 SWAP1 26D0 91 SWAP2 26D1 55 SSTORE 26D2 90 SWAP1 26D3 51 MLOAD 26D4 83 DUP4 26D5 92 SWAP3 26D6 90 SWAP1 26D7 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 26F8 90 SWAP1 26F9 82 DUP3 26FA 90 SWAP1 26FB A4 LOG4 26FC 50 POP 26FD 50 POP 26FE 56 *JUMP // Stack delta = -7 // Outputs[5] // { // @2697 storage[stack[-3]] = stack[-1] // @269E memory[0x00:0x20] = stack[-5] // @26A3 memory[0x20:0x40] = 0x02 // @26D1 storage[keccak256(memory[0x00:0x40])] = (stack[-6] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @26FB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5]]); // } // Block ends with unconditional jump to stack[-7] label_26FF: // Incoming jump from 0x0FAA // Inputs[2] // { // @2700 stack[-3] // @2702 storage[stack[-3]] // } 26FF 5B JUMPDEST 2700 82 DUP3 2701 80 DUP1 2702 54 SLOAD 2703 61 PUSH2 0x270b 2706 90 SWAP1 2707 61 PUSH2 0x2cf8 270A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2700 stack[0] = stack[-3] // @2706 stack[1] = 0x270b // @2706 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x2cf8, returns to 0x270B label_270B: // Incoming return from call to 0x2CF8 at 0x270A // Inputs[5] // { // @270C stack[-1] // @270C stack[-2] // @2714 memory[0x00:0x20] // @271F stack[-4] // @2720 stack[-3] // } 270B 5B JUMPDEST 270C 90 SWAP1 270D 60 PUSH1 0x00 270F 52 MSTORE 2710 60 PUSH1 0x20 2712 60 PUSH1 0x00 2714 20 SHA3 2715 90 SWAP1 2716 60 PUSH1 0x1f 2718 01 ADD 2719 60 PUSH1 0x20 271B 90 SWAP1 271C 04 DIV 271D 81 DUP2 271E 01 ADD 271F 92 SWAP3 2720 82 DUP3 2721 61 PUSH2 0x272d 2724 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @270F memory[0x00:0x20] = stack[-2] // @2715 stack[-2] = keccak256(memory[0x00:0x20]) // @271F stack[-1] = stack[-4] // @271F stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x272d, if stack[-3] label_2725: // Incoming jump from 0x2724, if not stack[-3] // Inputs[1] { @2727 stack[-5] } 2725 60 PUSH1 0x00 2727 85 DUP6 2728 55 SSTORE 2729 61 PUSH2 0x2773 272C 56 *JUMP // Stack delta = +0 // Outputs[1] { @2728 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x2773 label_272D: // Incoming jump from 0x2724, if stack[-3] // Inputs[1] { @272E stack[-3] } 272D 5B JUMPDEST 272E 82 DUP3 272F 60 PUSH1 0x1f 2731 10 LT 2732 61 PUSH2 0x2746 2735 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2746, if 0x1f < stack[-3] label_2736: // Incoming jump from 0x2735, if not 0x1f < stack[-3] // Inputs[4] // { // @2736 stack[-1] // @2737 memory[stack[-1]:stack[-1] + 0x20] // @273C stack[-3] // @2740 stack[-5] // } 2736 80 DUP1 2737 51 MLOAD 2738 60 PUSH1 0xff 273A 19 NOT 273B 16 AND 273C 83 DUP4 273D 80 DUP1 273E 01 ADD 273F 17 OR 2740 85 DUP6 2741 55 SSTORE 2742 61 PUSH2 0x2773 2745 56 *JUMP // Stack delta = +0 // Outputs[1] { @2741 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x2773 label_2746: // Incoming jump from 0x2735, if 0x1f < stack[-3] // Inputs[2] // { // @2747 stack[-3] // @274D stack[-5] // } 2746 5B JUMPDEST 2747 82 DUP3 2748 80 DUP1 2749 01 ADD 274A 60 PUSH1 0x01 274C 01 ADD 274D 85 DUP6 274E 55 SSTORE 274F 82 DUP3 2750 15 ISZERO 2751 61 PUSH2 0x2773 2754 57 *JUMPI // Stack delta = +0 // Outputs[1] { @274E storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x2773, if !stack[-3] label_2755: // Incoming jump from 0x2754, if not !stack[-3] // Inputs[2] // { // @2755 stack[-3] // @2755 stack[-1] // } 2755 91 SWAP2 2756 82 DUP3 2757 01 ADD 2758 5B JUMPDEST 2759 82 DUP3 275A 81 DUP2 275B 11 GT 275C 15 ISZERO 275D 61 PUSH2 0x2773 2760 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2755 stack[-3] = stack[-1] // @2757 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x2773, if !(stack[-1] + stack[-3] > stack[-1]) label_2761: // Incoming jump from 0x2760, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x2760, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @2761 stack[-3] // @2762 memory[stack[-3]:stack[-3] + 0x20] // @2763 stack[-2] // @2765 stack[-1] // } 2761 82 DUP3 2762 51 MLOAD 2763 82 DUP3 2764 55 SSTORE 2765 91 SWAP2 2766 60 PUSH1 0x20 2768 01 ADD 2769 91 SWAP2 276A 90 SWAP1 276B 60 PUSH1 0x01 276D 01 ADD 276E 90 SWAP1 276F 61 PUSH2 0x2758 2772 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2764 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @2769 stack[-3] = 0x20 + stack[-3] // @276E stack[-2] = 0x01 + stack[-2] // @276E stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x2758 label_2773: // Incoming jump from 0x2754, if !stack[-3] // Incoming jump from 0x2745 // Incoming jump from 0x2760, if !(stack[-1] > stack[-3]) // Incoming jump from 0x272C // Incoming jump from 0x2760, if !(stack[-1] + stack[-3] > stack[-1]) // Inputs[2] // { // @2778 stack[-4] // @2779 stack[-3] // } 2773 5B JUMPDEST 2774 50 POP 2775 61 PUSH2 0x277f 2778 92 SWAP3 2779 91 SWAP2 277A 50 POP 277B 61 PUSH2 0x2783 277E 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2778 stack[-4] = 0x277f // @2779 stack[-3] = stack[-4] // } // Block ends with call to 0x2783, returns to 0x277F label_277F: // Incoming jump from 0x278C, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x2783 at 0x277E // Incoming jump from 0x278C, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @2781 stack[-2] // @2781 stack[-3] // } 277F 5B JUMPDEST 2780 50 POP 2781 90 SWAP1 2782 56 *JUMP // Stack delta = -2 // Outputs[1] { @2781 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_2783: // Incoming call from 0x277E, returns to 0x277F // Inputs[2] // { // @2785 stack[-1] // @2786 stack[-2] // } 2783 5B JUMPDEST 2784 5B JUMPDEST 2785 80 DUP1 2786 82 DUP3 2787 11 GT 2788 15 ISZERO 2789 61 PUSH2 0x277f 278C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x277f, if !(stack[-2] > stack[-1]) label_278D: // Incoming jump from 0x278C, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x278C, if not !(stack[-2] > stack[-1]) // Inputs[1] { @278F stack[-1] } 278D 60 PUSH1 0x00 278F 81 DUP2 2790 55 SSTORE 2791 60 PUSH1 0x01 2793 01 ADD 2794 61 PUSH2 0x2784 2797 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2790 storage[stack[-1]] = 0x00 // @2793 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2784 label_2798: // Incoming call from 0x2AC6, returns to 0x1CA0 // Incoming call from 0x2986, returns to 0x2987 // Inputs[1] { @27A5 stack[-2] } 2798 5B JUMPDEST 2799 60 PUSH1 0x00 279B 67 PUSH8 0xffffffffffffffff 27A4 80 DUP1 27A5 84 DUP5 27A6 11 GT 27A7 15 ISZERO 27A8 61 PUSH2 0x27b3 27AB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2799 stack[0] = 0x00 // @279B stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x27b3, if !(stack[-2] > 0xffffffffffffffff) label_27AC: // Incoming jump from 0x27AB, if not !(stack[-2] > 0xffffffffffffffff) 27AC 61 PUSH2 0x27b3 27AF 61 PUSH2 0x2dba 27B2 56 *JUMP // Stack delta = +1 // Outputs[1] { @27AC stack[0] = 0x27b3 } // Block ends with unconditional jump to 0x2dba label_27B3: // Incoming jump from 0x27AB, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @27B6 memory[0x40:0x60] // @27B9 stack[-4] // @27C8 stack[-1] // } 27B3 5B JUMPDEST 27B4 60 PUSH1 0x40 27B6 51 MLOAD 27B7 60 PUSH1 0x1f 27B9 85 DUP6 27BA 01 ADD 27BB 60 PUSH1 0x1f 27BD 19 NOT 27BE 90 SWAP1 27BF 81 DUP2 27C0 16 AND 27C1 60 PUSH1 0x3f 27C3 01 ADD 27C4 16 AND 27C5 81 DUP2 27C6 01 ADD 27C7 90 SWAP1 27C8 82 DUP3 27C9 82 DUP3 27CA 11 GT 27CB 81 DUP2 27CC 83 DUP4 27CD 10 LT 27CE 17 OR 27CF 15 ISZERO 27D0 61 PUSH2 0x27db 27D3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @27C7 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @27C7 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x27db, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_27D4: // Incoming jump from 0x27D3, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 27D4 61 PUSH2 0x27db 27D7 61 PUSH2 0x2dba 27DA 56 *JUMP // Stack delta = +1 // Outputs[1] { @27D4 stack[0] = 0x27db } // Block ends with unconditional jump to 0x2dba label_27DB: // Incoming jump from 0x27D3, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @27DC stack[-2] // @27E0 stack[-1] // @27E1 stack[-4] // @27E3 stack[-6] // @27E6 stack[-7] // @27E8 stack[-5] // } 27DB 5B JUMPDEST 27DC 81 DUP2 27DD 60 PUSH1 0x40 27DF 52 MSTORE 27E0 80 DUP1 27E1 93 SWAP4 27E2 50 POP 27E3 85 DUP6 27E4 81 DUP2 27E5 52 MSTORE 27E6 86 DUP7 27E7 86 DUP7 27E8 86 DUP7 27E9 01 ADD 27EA 11 GT 27EB 15 ISZERO 27EC 61 PUSH2 0x27f4 27EF 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @27DF memory[0x40:0x60] = stack[-2] // @27E1 stack[-4] = stack[-1] // @27E5 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x27f4, if !(stack[-5] + stack[-6] > stack[-7]) label_27F0: // Incoming jump from 0x27EF, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @27F3 memory[0x00:0x00] } 27F0 60 PUSH1 0x00 27F2 80 DUP1 27F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @27F3 revert(memory[0x00:0x00]); } // Block terminates label_27F4: // Incoming jump from 0x27EF, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @27F5 stack[-6] // @27F6 stack[-5] // @27F9 stack[-1] // @27FB msg.data[stack[-5]:stack[-5] + stack[-6]] // @2808 stack[-8] // @2808 stack[-4] // @2809 stack[-7] // } 27F4 5B JUMPDEST 27F5 85 DUP6 27F6 85 DUP6 27F7 60 PUSH1 0x20 27F9 83 DUP4 27FA 01 ADD 27FB 37 CALLDATACOPY 27FC 60 PUSH1 0x00 27FE 60 PUSH1 0x20 2800 87 DUP8 2801 83 DUP4 2802 01 ADD 2803 01 ADD 2804 52 MSTORE 2805 50 POP 2806 50 POP 2807 50 POP 2808 93 SWAP4 2809 92 SWAP3 280A 50 POP 280B 50 POP 280C 50 POP 280D 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @27FB memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @2804 memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @2808 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_280E: // Incoming call from 0x2935, returns to 0x2936 // Incoming call from 0x28F8, returns to 0x28F9 // Incoming call from 0x29D8, returns to 0x29D9 // Incoming call from 0x28D1, returns to 0x28D2 // Incoming call from 0x2906, returns to 0x2907 // Incoming call from 0x29AE, returns to 0x29AF // Incoming call from 0x28A0, returns to 0x28A1 // Incoming call from 0x2943, returns to 0x2944 // Incoming call from 0x28C3, returns to 0x28C4 // Inputs[2] // { // @280F stack[-1] // @2810 msg.data[stack[-1]:stack[-1] + 0x20] // } 280E 5B JUMPDEST 280F 80 DUP1 2810 35 CALLDATALOAD 2811 60 PUSH1 0x01 2813 60 PUSH1 0x01 2815 60 PUSH1 0xa0 2817 1B SHL 2818 03 SUB 2819 81 DUP2 281A 16 AND 281B 81 DUP2 281C 14 EQ 281D 61 PUSH2 0x2825 2820 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2810 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x2825, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_2821: // Incoming jump from 0x2820, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2824 memory[0x00:0x00] } 2821 60 PUSH1 0x00 2823 80 DUP1 2824 FD *REVERT // Stack delta = +0 // Outputs[1] { @2824 revert(memory[0x00:0x00]); } // Block terminates label_2825: // Incoming jump from 0x2820, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x2881, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @2826 stack[-3] // @2826 stack[-1] // @2827 stack[-2] // } 2825 5B JUMPDEST 2826 91 SWAP2 2827 90 SWAP1 2828 50 POP 2829 56 *JUMP // Stack delta = -2 // Outputs[1] { @2826 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_282A: // Incoming call from 0x2A1C, returns to 0x2A1D // Incoming call from 0x2B1E, returns to 0x2B1F // Inputs[2] // { // @282E stack[-2] // @2831 stack[-1] // } 282A 5B JUMPDEST 282B 60 PUSH1 0x00 282D 80 DUP1 282E 83 DUP4 282F 60 PUSH1 0x1f 2831 84 DUP5 2832 01 ADD 2833 12 SLT 2834 61 PUSH2 0x283c 2837 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @282B stack[0] = 0x00 // @282D stack[1] = 0x00 // } // Block ends with conditional jump to 0x283c, if stack[-1] + 0x1f i< stack[-2] label_2838: // Incoming jump from 0x2837, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @283B memory[0x00:0x00] } 2838 60 PUSH1 0x00 283A 80 DUP1 283B FD *REVERT // Stack delta = +0 // Outputs[1] { @283B revert(memory[0x00:0x00]); } // Block terminates label_283C: // Incoming jump from 0x2837, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @283E stack[-3] // @283F msg.data[stack[-3]:stack[-3] + 0x20] // } 283C 5B JUMPDEST 283D 50 POP 283E 81 DUP2 283F 35 CALLDATALOAD 2840 67 PUSH8 0xffffffffffffffff 2849 81 DUP2 284A 11 GT 284B 15 ISZERO 284C 61 PUSH2 0x2854 284F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @283F stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x2854, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_2850: // Incoming jump from 0x284F, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2853 memory[0x00:0x00] } 2850 60 PUSH1 0x00 2852 80 DUP1 2853 FD *REVERT // Stack delta = +0 // Outputs[1] { @2853 revert(memory[0x00:0x00]); } // Block terminates label_2854: // Incoming jump from 0x284F, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @2857 stack[-3] // @2859 stack[-2] // @285B stack[-4] // @285E stack[-1] // } 2854 5B JUMPDEST 2855 60 PUSH1 0x20 2857 83 DUP4 2858 01 ADD 2859 91 SWAP2 285A 50 POP 285B 83 DUP4 285C 60 PUSH1 0x20 285E 82 DUP3 285F 60 PUSH1 0x05 2861 1B SHL 2862 85 DUP6 2863 01 ADD 2864 01 ADD 2865 11 GT 2866 15 ISZERO 2867 61 PUSH2 0x286f 286A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2859 stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x286f, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) label_286B: // Incoming jump from 0x286A, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Inputs[1] { @286E memory[0x00:0x00] } 286B 60 PUSH1 0x00 286D 80 DUP1 286E FD *REVERT // Stack delta = +0 // Outputs[1] { @286E revert(memory[0x00:0x00]); } // Block terminates label_286F: // Incoming jump from 0x286A, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Inputs[5] // { // @2870 stack[-1] // @2870 stack[-4] // @2872 stack[-5] // @2872 stack[-2] // @2873 stack[-3] // } 286F 5B JUMPDEST 2870 92 SWAP3 2871 50 POP 2872 92 SWAP3 2873 90 SWAP1 2874 50 POP 2875 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2870 stack[-4] = stack[-1] // @2872 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_2876: // Incoming call from 0x2A43, returns to 0x28A1 // Incoming call from 0x29BC, returns to 0x28D2 // Inputs[2] // { // @2877 stack[-1] // @2878 msg.data[stack[-1]:stack[-1] + 0x20] // } 2876 5B JUMPDEST 2877 80 DUP1 2878 35 CALLDATALOAD 2879 80 DUP1 287A 15 ISZERO 287B 15 ISZERO 287C 81 DUP2 287D 14 EQ 287E 61 PUSH2 0x2825 2881 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2878 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x2825, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_2882: // Incoming jump from 0x2881, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @2885 memory[0x00:0x00] } 2882 60 PUSH1 0x00 2884 80 DUP1 2885 FD *REVERT // Stack delta = +0 // Outputs[1] { @2885 revert(memory[0x00:0x00]); } // Block terminates label_2886: // Incoming call from 0x058C, returns to 0x058D // Incoming call from 0x078A, returns to 0x078B // Incoming call from 0x0E5C, returns to 0x0E5D // Inputs[2] // { // @288B stack[-1] // @288C stack[-2] // } 2886 5B JUMPDEST 2887 60 PUSH1 0x00 2889 60 PUSH1 0x20 288B 82 DUP3 288C 84 DUP5 288D 03 SUB 288E 12 SLT 288F 15 ISZERO 2890 61 PUSH2 0x2898 2893 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2887 stack[0] = 0x00 } // Block ends with conditional jump to 0x2898, if !(stack[-2] - stack[-1] i< 0x20) label_2894: // Incoming jump from 0x2893, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2897 memory[0x00:0x00] } 2894 60 PUSH1 0x00 2896 80 DUP1 2897 FD *REVERT // Stack delta = +0 // Outputs[1] { @2897 revert(memory[0x00:0x00]); } // Block terminates label_2898: // Incoming jump from 0x2893, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @289C stack[-2] } 2898 5B JUMPDEST 2899 61 PUSH2 0x28a1 289C 82 DUP3 289D 61 PUSH2 0x280e 28A0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2899 stack[0] = 0x28a1 // @289C stack[1] = stack[-2] // } // Block ends with call to 0x280e, returns to 0x28A1 label_28A1: // Incoming return from call to 0x2876 at 0x2A43 // Incoming return from call to 0x2DD0 at 0x2A60 // Incoming return from call to 0x2B2C at 0x2C69 // Incoming return from call to 0x280E at 0x28A0 // Inputs[3] // { // @28A2 stack[-1] // @28A2 stack[-5] // @28A3 stack[-4] // } 28A1 5B JUMPDEST 28A2 93 SWAP4 28A3 92 SWAP3 28A4 50 POP 28A5 50 POP 28A6 50 POP 28A7 56 *JUMP // Stack delta = -4 // Outputs[1] { @28A2 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_28A8: // Incoming call from 0x0741, returns to 0x0742 // Inputs[2] // { // @28AE stack[-1] // @28AF stack[-2] // } 28A8 5B JUMPDEST 28A9 60 PUSH1 0x00 28AB 80 DUP1 28AC 60 PUSH1 0x40 28AE 83 DUP4 28AF 85 DUP6 28B0 03 SUB 28B1 12 SLT 28B2 15 ISZERO 28B3 61 PUSH2 0x28bb 28B6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @28A9 stack[0] = 0x00 // @28AB stack[1] = 0x00 // } // Block ends with conditional jump to 0x28bb, if !(stack[-2] - stack[-1] i< 0x40) label_28B7: // Incoming jump from 0x28B6, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @28BA memory[0x00:0x00] } 28B7 60 PUSH1 0x00 28B9 80 DUP1 28BA FD *REVERT // Stack delta = +0 // Outputs[1] { @28BA revert(memory[0x00:0x00]); } // Block terminates label_28BB: // Incoming jump from 0x28B6, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @28BF stack[-3] } 28BB 5B JUMPDEST 28BC 61 PUSH2 0x28c4 28BF 83 DUP4 28C0 61 PUSH2 0x280e 28C3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @28BC stack[0] = 0x28c4 // @28BF stack[1] = stack[-3] // } // Block ends with call to 0x280e, returns to 0x28C4 label_28C4: // Incoming return from call to 0x280E at 0x28C3 // Inputs[3] // { // @28C5 stack[-1] // @28C5 stack[-3] // @28CC stack[-4] // } 28C4 5B JUMPDEST 28C5 91 SWAP2 28C6 50 POP 28C7 61 PUSH2 0x28d2 28CA 60 PUSH1 0x20 28CC 84 DUP5 28CD 01 ADD 28CE 61 PUSH2 0x280e 28D1 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @28C5 stack[-3] = stack[-1] // @28C7 stack[-1] = 0x28d2 // @28CD stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x280e, returns to 0x28D2 label_28D2: // Incoming return from call to 0x2876 at 0x29BC // Incoming return from call to 0x280E at 0x28D1 // Inputs[6] // { // @28D3 stack[-1] // @28D3 stack[-2] // @28D5 stack[-5] // @28D7 stack[-3] // @28D7 stack[-6] // @28D8 stack[-4] // } 28D2 5B JUMPDEST 28D3 90 SWAP1 28D4 50 POP 28D5 92 SWAP3 28D6 50 POP 28D7 92 SWAP3 28D8 90 SWAP1 28D9 50 POP 28DA 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @28D5 stack[-5] = stack[-1] // @28D7 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_28DB: // Incoming call from 0x04A8, returns to 0x04A9 // Incoming call from 0x03CA, returns to 0x03CB // Inputs[2] // { // @28E3 stack[-1] // @28E4 stack[-2] // } 28DB 5B JUMPDEST 28DC 60 PUSH1 0x00 28DE 80 DUP1 28DF 60 PUSH1 0x00 28E1 60 PUSH1 0x60 28E3 84 DUP5 28E4 86 DUP7 28E5 03 SUB 28E6 12 SLT 28E7 15 ISZERO 28E8 61 PUSH2 0x28f0 28EB 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @28DC stack[0] = 0x00 // @28DE stack[1] = 0x00 // @28DF stack[2] = 0x00 // } // Block ends with conditional jump to 0x28f0, if !(stack[-2] - stack[-1] i< 0x60) label_28EC: // Incoming jump from 0x28EB, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @28EF memory[0x00:0x00] } 28EC 60 PUSH1 0x00 28EE 80 DUP1 28EF FD *REVERT // Stack delta = +0 // Outputs[1] { @28EF revert(memory[0x00:0x00]); } // Block terminates label_28F0: // Incoming jump from 0x28EB, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @28F4 stack[-4] } 28F0 5B JUMPDEST 28F1 61 PUSH2 0x28f9 28F4 84 DUP5 28F5 61 PUSH2 0x280e 28F8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @28F1 stack[0] = 0x28f9 // @28F4 stack[1] = stack[-4] // } // Block ends with call to 0x280e, returns to 0x28F9 label_28F9: // Incoming return from call to 0x280E at 0x28F8 // Inputs[3] // { // @28FA stack[-4] // @28FA stack[-1] // @2901 stack[-5] // } 28F9 5B JUMPDEST 28FA 92 SWAP3 28FB 50 POP 28FC 61 PUSH2 0x2907 28FF 60 PUSH1 0x20 2901 85 DUP6 2902 01 ADD 2903 61 PUSH2 0x280e 2906 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @28FA stack[-4] = stack[-1] // @28FC stack[-1] = 0x2907 // @2902 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x280e, returns to 0x2907 label_2907: // Incoming return from call to 0x280E at 0x2906 // Inputs[8] // { // @2908 stack[-3] // @2908 stack[-1] // @290C stack[-5] // @290E msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @290F stack[-2] // @2913 stack[-6] // @2915 stack[-7] // @2915 stack[-4] // } 2907 5B JUMPDEST 2908 91 SWAP2 2909 50 POP 290A 60 PUSH1 0x40 290C 84 DUP5 290D 01 ADD 290E 35 CALLDATALOAD 290F 90 SWAP1 2910 50 POP 2911 92 SWAP3 2912 50 POP 2913 92 SWAP3 2914 50 POP 2915 92 SWAP3 2916 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2911 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2913 stack[-6] = stack[-1] // @2915 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_2917: // Incoming call from 0x06A2, returns to 0x06A3 // Inputs[2] // { // @2920 stack[-1] // @2921 stack[-2] // } 2917 5B JUMPDEST 2918 60 PUSH1 0x00 291A 80 DUP1 291B 60 PUSH1 0x00 291D 80 DUP1 291E 60 PUSH1 0x80 2920 85 DUP6 2921 87 DUP8 2922 03 SUB 2923 12 SLT 2924 15 ISZERO 2925 61 PUSH2 0x292d 2928 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2918 stack[0] = 0x00 // @291A stack[1] = 0x00 // @291B stack[2] = 0x00 // @291D stack[3] = 0x00 // } // Block ends with conditional jump to 0x292d, if !(stack[-2] - stack[-1] i< 0x80) label_2929: // Incoming jump from 0x2928, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @292C memory[0x00:0x00] } 2929 60 PUSH1 0x00 292B 80 DUP1 292C FD *REVERT // Stack delta = +0 // Outputs[1] { @292C revert(memory[0x00:0x00]); } // Block terminates label_292D: // Incoming jump from 0x2928, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2931 stack[-5] } 292D 5B JUMPDEST 292E 61 PUSH2 0x2936 2931 85 DUP6 2932 61 PUSH2 0x280e 2935 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @292E stack[0] = 0x2936 // @2931 stack[1] = stack[-5] // } // Block ends with call to 0x280e, returns to 0x2936 label_2936: // Incoming return from call to 0x280E at 0x2935 // Inputs[3] // { // @2937 stack[-1] // @2937 stack[-5] // @293E stack[-6] // } 2936 5B JUMPDEST 2937 93 SWAP4 2938 50 POP 2939 61 PUSH2 0x2944 293C 60 PUSH1 0x20 293E 86 DUP7 293F 01 ADD 2940 61 PUSH2 0x280e 2943 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2937 stack[-5] = stack[-1] // @2939 stack[-1] = 0x2944 // @293F stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x280e, returns to 0x2944 label_2944: // Incoming return from call to 0x280E at 0x2943 // Inputs[6] // { // @2945 stack[-1] // @2945 stack[-4] // @2949 stack[-6] // @294B msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @294C stack[-3] // @2952 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 2944 5B JUMPDEST 2945 92 SWAP3 2946 50 POP 2947 60 PUSH1 0x40 2949 85 DUP6 294A 01 ADD 294B 35 CALLDATALOAD 294C 91 SWAP2 294D 50 POP 294E 60 PUSH1 0x60 2950 85 DUP6 2951 01 ADD 2952 35 CALLDATALOAD 2953 67 PUSH8 0xffffffffffffffff 295C 81 DUP2 295D 11 GT 295E 15 ISZERO 295F 61 PUSH2 0x2967 2962 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2945 stack[-4] = stack[-1] // @294C stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2952 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x2967, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_2963: // Incoming jump from 0x2962, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2966 memory[0x00:0x00] } 2963 60 PUSH1 0x00 2965 80 DUP1 2966 FD *REVERT // Stack delta = +0 // Outputs[1] { @2966 revert(memory[0x00:0x00]); } // Block terminates label_2967: // Incoming jump from 0x2962, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2968 stack[-6] // @2969 stack[-1] // @296E stack[-7] // } 2967 5B JUMPDEST 2968 85 DUP6 2969 01 ADD 296A 60 PUSH1 0x1f 296C 81 DUP2 296D 01 ADD 296E 87 DUP8 296F 13 SGT 2970 61 PUSH2 0x2978 2973 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2969 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x2978, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_2974: // Incoming jump from 0x2973, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @2977 memory[0x00:0x00] } 2974 60 PUSH1 0x00 2976 80 DUP1 2977 FD *REVERT // Stack delta = +0 // Outputs[1] { @2977 revert(memory[0x00:0x00]); } // Block terminates label_2978: // Incoming jump from 0x2973, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @297C stack[-7] // @297D stack[-1] // @297E msg.data[stack[-1]:stack[-1] + 0x20] // } 2978 5B JUMPDEST 2979 61 PUSH2 0x2987 297C 87 DUP8 297D 82 DUP3 297E 35 CALLDATALOAD 297F 60 PUSH1 0x20 2981 84 DUP5 2982 01 ADD 2983 61 PUSH2 0x2798 2986 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2979 stack[0] = 0x2987 // @297C stack[1] = stack[-7] // @297E stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2982 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x2798, returns to 0x2987 label_2987: // Incoming return from call to 0x2798 at 0x2986 // Inputs[8] // { // @2988 stack[-3] // @2988 stack[-1] // @298B stack[-6] // @298C stack[-9] // @298D stack[-5] // @298E stack[-8] // @2990 stack[-4] // @2990 stack[-7] // } 2987 5B JUMPDEST 2988 91 SWAP2 2989 50 POP 298A 50 POP 298B 92 SWAP3 298C 95 SWAP6 298D 91 SWAP2 298E 94 SWAP5 298F 50 POP 2990 92 SWAP3 2991 50 POP 2992 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @298B stack[-6] = stack[-1] // @298C stack[-9] = stack[-6] // @298E stack[-8] = stack[-5] // @2990 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_2993: // Incoming call from 0x0682, returns to 0x0683 // Inputs[2] // { // @2999 stack[-1] // @299A stack[-2] // } 2993 5B JUMPDEST 2994 60 PUSH1 0x00 2996 80 DUP1 2997 60 PUSH1 0x40 2999 83 DUP4 299A 85 DUP6 299B 03 SUB 299C 12 SLT 299D 15 ISZERO 299E 61 PUSH2 0x29a6 29A1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2994 stack[0] = 0x00 // @2996 stack[1] = 0x00 // } // Block ends with conditional jump to 0x29a6, if !(stack[-2] - stack[-1] i< 0x40) label_29A2: // Incoming jump from 0x29A1, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @29A5 memory[0x00:0x00] } 29A2 60 PUSH1 0x00 29A4 80 DUP1 29A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @29A5 revert(memory[0x00:0x00]); } // Block terminates label_29A6: // Incoming jump from 0x29A1, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @29AA stack[-3] } 29A6 5B JUMPDEST 29A7 61 PUSH2 0x29af 29AA 83 DUP4 29AB 61 PUSH2 0x280e 29AE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @29A7 stack[0] = 0x29af // @29AA stack[1] = stack[-3] // } // Block ends with call to 0x280e, returns to 0x29AF label_29AF: // Incoming return from call to 0x280E at 0x29AE // Inputs[3] // { // @29B0 stack[-1] // @29B0 stack[-3] // @29B7 stack[-4] // } 29AF 5B JUMPDEST 29B0 91 SWAP2 29B1 50 POP 29B2 61 PUSH2 0x28d2 29B5 60 PUSH1 0x20 29B7 84 DUP5 29B8 01 ADD 29B9 61 PUSH2 0x2876 29BC 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @29B0 stack[-3] = stack[-1] // @29B2 stack[-1] = 0x28d2 // @29B8 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x2876, returns to 0x28D2 label_29BD: // Incoming call from 0x0369, returns to 0x036A // Incoming call from 0x044A, returns to 0x044B // Inputs[2] // { // @29C3 stack[-1] // @29C4 stack[-2] // } 29BD 5B JUMPDEST 29BE 60 PUSH1 0x00 29C0 80 DUP1 29C1 60 PUSH1 0x40 29C3 83 DUP4 29C4 85 DUP6 29C5 03 SUB 29C6 12 SLT 29C7 15 ISZERO 29C8 61 PUSH2 0x29d0 29CB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @29BE stack[0] = 0x00 // @29C0 stack[1] = 0x00 // } // Block ends with conditional jump to 0x29d0, if !(stack[-2] - stack[-1] i< 0x40) label_29CC: // Incoming jump from 0x29CB, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @29CF memory[0x00:0x00] } 29CC 60 PUSH1 0x00 29CE 80 DUP1 29CF FD *REVERT // Stack delta = +0 // Outputs[1] { @29CF revert(memory[0x00:0x00]); } // Block terminates label_29D0: // Incoming jump from 0x29CB, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @29D4 stack[-3] } 29D0 5B JUMPDEST 29D1 61 PUSH2 0x29d9 29D4 83 DUP4 29D5 61 PUSH2 0x280e 29D8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @29D1 stack[0] = 0x29d9 // @29D4 stack[1] = stack[-3] // } // Block ends with call to 0x280e, returns to 0x29D9 label_29D9: // Incoming return from call to 0x280E at 0x29D8 // Inputs[5] // { // @29DA stack[-6] // @29DA stack[-1] // @29DD stack[-4] // @29E1 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @29E2 stack[-5] // } 29D9 5B JUMPDEST 29DA 94 SWAP5 29DB 60 PUSH1 0x20 29DD 93 SWAP4 29DE 90 SWAP1 29DF 93 SWAP4 29E0 01 ADD 29E1 35 CALLDATALOAD 29E2 93 SWAP4 29E3 50 POP 29E4 50 POP 29E5 50 POP 29E6 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @29DA stack[-6] = stack[-1] // @29E2 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_29E7: // Incoming call from 0x04C8, returns to 0x04C9 // Inputs[2] // { // @29ED stack[-1] // @29EE stack[-2] // } 29E7 5B JUMPDEST 29E8 60 PUSH1 0x00 29EA 80 DUP1 29EB 60 PUSH1 0x20 29ED 83 DUP4 29EE 85 DUP6 29EF 03 SUB 29F0 12 SLT 29F1 15 ISZERO 29F2 61 PUSH2 0x29fa 29F5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @29E8 stack[0] = 0x00 // @29EA stack[1] = 0x00 // } // Block ends with conditional jump to 0x29fa, if !(stack[-2] - stack[-1] i< 0x20) label_29F6: // Incoming jump from 0x29F5, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @29F9 memory[0x00:0x00] } 29F6 60 PUSH1 0x00 29F8 80 DUP1 29F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @29F9 revert(memory[0x00:0x00]); } // Block terminates label_29FA: // Incoming jump from 0x29F5, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @29FB stack[-3] // @29FC msg.data[stack[-3]:stack[-3] + 0x20] // } 29FA 5B JUMPDEST 29FB 82 DUP3 29FC 35 CALLDATALOAD 29FD 67 PUSH8 0xffffffffffffffff 2A06 81 DUP2 2A07 11 GT 2A08 15 ISZERO 2A09 61 PUSH2 0x2a11 2A0C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @29FC stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x2a11, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_2A0D: // Incoming jump from 0x2A0C, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2A10 memory[0x00:0x00] } 2A0D 60 PUSH1 0x00 2A0F 80 DUP1 2A10 FD *REVERT // Stack delta = +0 // Outputs[1] { @2A10 revert(memory[0x00:0x00]); } // Block terminates label_2A11: // Incoming jump from 0x2A0C, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2A15 stack[-5] // @2A16 stack[-1] // @2A17 stack[-4] // } 2A11 5B JUMPDEST 2A12 61 PUSH2 0x2a1d 2A15 85 DUP6 2A16 82 DUP3 2A17 86 DUP7 2A18 01 ADD 2A19 61 PUSH2 0x282a 2A1C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2A12 stack[0] = 0x2a1d // @2A15 stack[1] = stack[-5] // @2A18 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x282a, returns to 0x2A1D label_2A1D: // Incoming return from call to 0x282A at 0x2A1C // Inputs[5] // { // @2A1E stack[-1] // @2A1E stack[-2] // @2A1F stack[-8] // @2A21 stack[-7] // @2A23 stack[-6] // } 2A1D 5B JUMPDEST 2A1E 90 SWAP1 2A1F 96 SWAP7 2A20 90 SWAP1 2A21 95 SWAP6 2A22 50 POP 2A23 93 SWAP4 2A24 50 POP 2A25 50 POP 2A26 50 POP 2A27 50 POP 2A28 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @2A1F stack[-8] = stack[-2] // @2A21 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_2A29: // Incoming call from 0x0480, returns to 0x0481 // Incoming call from 0x038B, returns to 0x038C // Inputs[2] // { // @2A2E stack[-1] // @2A2F stack[-2] // } 2A29 5B JUMPDEST 2A2A 60 PUSH1 0x00 2A2C 60 PUSH1 0x20 2A2E 82 DUP3 2A2F 84 DUP5 2A30 03 SUB 2A31 12 SLT 2A32 15 ISZERO 2A33 61 PUSH2 0x2a3b 2A36 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A2A stack[0] = 0x00 } // Block ends with conditional jump to 0x2a3b, if !(stack[-2] - stack[-1] i< 0x20) label_2A37: // Incoming jump from 0x2A36, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2A3A memory[0x00:0x00] } 2A37 60 PUSH1 0x00 2A39 80 DUP1 2A3A FD *REVERT // Stack delta = +0 // Outputs[1] { @2A3A revert(memory[0x00:0x00]); } // Block terminates label_2A3B: // Incoming jump from 0x2A36, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2A3F stack[-2] } 2A3B 5B JUMPDEST 2A3C 61 PUSH2 0x28a1 2A3F 82 DUP3 2A40 61 PUSH2 0x2876 2A43 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2A3C stack[0] = 0x28a1 // @2A3F stack[1] = stack[-2] // } // Block ends with call to 0x2876, returns to 0x28A1 label_2A44: // Incoming call from 0x02DA, returns to 0x02DB // Inputs[2] // { // @2A49 stack[-1] // @2A4A stack[-2] // } 2A44 5B JUMPDEST 2A45 60 PUSH1 0x00 2A47 60 PUSH1 0x20 2A49 82 DUP3 2A4A 84 DUP5 2A4B 03 SUB 2A4C 12 SLT 2A4D 15 ISZERO 2A4E 61 PUSH2 0x2a56 2A51 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A45 stack[0] = 0x00 } // Block ends with conditional jump to 0x2a56, if !(stack[-2] - stack[-1] i< 0x20) label_2A52: // Incoming jump from 0x2A51, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2A55 memory[0x00:0x00] } 2A52 60 PUSH1 0x00 2A54 80 DUP1 2A55 FD *REVERT // Stack delta = +0 // Outputs[1] { @2A55 revert(memory[0x00:0x00]); } // Block terminates label_2A56: // Incoming jump from 0x2A51, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2A57 stack[-2] // @2A58 msg.data[stack[-2]:stack[-2] + 0x20] // } 2A56 5B JUMPDEST 2A57 81 DUP2 2A58 35 CALLDATALOAD 2A59 61 PUSH2 0x28a1 2A5C 81 DUP2 2A5D 61 PUSH2 0x2dd0 2A60 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2A58 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2A59 stack[1] = 0x28a1 // @2A5C stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2dd0, returns to 0x28A1 2A61 5B JUMPDEST 2A62 60 PUSH1 0x00 2A64 60 PUSH1 0x20 2A66 82 DUP3 2A67 84 DUP5 2A68 03 SUB 2A69 12 SLT 2A6A 15 ISZERO 2A6B 61 PUSH2 0x2a73 2A6E 57 *JUMPI 2A6F 60 PUSH1 0x00 2A71 80 DUP1 2A72 FD *REVERT 2A73 5B JUMPDEST 2A74 81 DUP2 2A75 51 MLOAD 2A76 61 PUSH2 0x28a1 2A79 81 DUP2 2A7A 61 PUSH2 0x2dd0 2A7D 56 *JUMP label_2A7E: // Incoming call from 0x051D, returns to 0x051E // Inputs[2] // { // @2A83 stack[-1] // @2A84 stack[-2] // } 2A7E 5B JUMPDEST 2A7F 60 PUSH1 0x00 2A81 60 PUSH1 0x20 2A83 82 DUP3 2A84 84 DUP5 2A85 03 SUB 2A86 12 SLT 2A87 15 ISZERO 2A88 61 PUSH2 0x2a90 2A8B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A7F stack[0] = 0x00 } // Block ends with conditional jump to 0x2a90, if !(stack[-2] - stack[-1] i< 0x20) label_2A8C: // Incoming jump from 0x2A8B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2A8F memory[0x00:0x00] } 2A8C 60 PUSH1 0x00 2A8E 80 DUP1 2A8F FD *REVERT // Stack delta = +0 // Outputs[1] { @2A8F revert(memory[0x00:0x00]); } // Block terminates label_2A90: // Incoming jump from 0x2A8B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2A91 stack[-2] // @2A92 msg.data[stack[-2]:stack[-2] + 0x20] // } 2A90 5B JUMPDEST 2A91 81 DUP2 2A92 35 CALLDATALOAD 2A93 67 PUSH8 0xffffffffffffffff 2A9C 81 DUP2 2A9D 11 GT 2A9E 15 ISZERO 2A9F 61 PUSH2 0x2aa7 2AA2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A92 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2aa7, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_2AA3: // Incoming jump from 0x2AA2, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2AA6 memory[0x00:0x00] } 2AA3 60 PUSH1 0x00 2AA5 80 DUP1 2AA6 FD *REVERT // Stack delta = +0 // Outputs[1] { @2AA6 revert(memory[0x00:0x00]); } // Block terminates label_2AA7: // Incoming jump from 0x2AA2, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2AA8 stack[-3] // @2AA9 stack[-1] // @2AAE stack[-4] // } 2AA7 5B JUMPDEST 2AA8 82 DUP3 2AA9 01 ADD 2AAA 60 PUSH1 0x1f 2AAC 81 DUP2 2AAD 01 ADD 2AAE 84 DUP5 2AAF 13 SGT 2AB0 61 PUSH2 0x2ab8 2AB3 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2AA9 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x2ab8, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_2AB4: // Incoming jump from 0x2AB3, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @2AB7 memory[0x00:0x00] } 2AB4 60 PUSH1 0x00 2AB6 80 DUP1 2AB7 FD *REVERT // Stack delta = +0 // Outputs[1] { @2AB7 revert(memory[0x00:0x00]); } // Block terminates label_2AB8: // Incoming jump from 0x2AB3, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @2ABC stack[-4] // @2ABD stack[-1] // @2ABE msg.data[stack[-1]:stack[-1] + 0x20] // } 2AB8 5B JUMPDEST 2AB9 61 PUSH2 0x1ca0 2ABC 84 DUP5 2ABD 82 DUP3 2ABE 35 CALLDATALOAD 2ABF 60 PUSH1 0x20 2AC1 84 DUP5 2AC2 01 ADD 2AC3 61 PUSH2 0x2798 2AC6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2AB9 stack[0] = 0x1ca0 // @2ABC stack[1] = stack[-4] // @2ABE stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2AC2 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x2798, returns to 0x1CA0 label_2AC7: // Incoming call from 0x04FD, returns to 0x04FE // Incoming call from 0x0557, returns to 0x0558 // Incoming call from 0x06F3, returns to 0x06F4 // Incoming call from 0x0331, returns to 0x0332 // Incoming call from 0x0662, returns to 0x0663 // Inputs[2] // { // @2ACC stack[-1] // @2ACD stack[-2] // } 2AC7 5B JUMPDEST 2AC8 60 PUSH1 0x00 2ACA 60 PUSH1 0x20 2ACC 82 DUP3 2ACD 84 DUP5 2ACE 03 SUB 2ACF 12 SLT 2AD0 15 ISZERO 2AD1 61 PUSH2 0x2ad9 2AD4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2AC8 stack[0] = 0x00 } // Block ends with conditional jump to 0x2ad9, if !(stack[-2] - stack[-1] i< 0x20) label_2AD5: // Incoming jump from 0x2AD4, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2AD8 memory[0x00:0x00] } 2AD5 60 PUSH1 0x00 2AD7 80 DUP1 2AD8 FD *REVERT // Stack delta = +0 // Outputs[1] { @2AD8 revert(memory[0x00:0x00]); } // Block terminates label_2AD9: // Incoming jump from 0x2AD4, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @2ADB stack[-2] // @2ADB msg.data[stack[-2]:stack[-2] + 0x20] // @2ADC stack[-4] // @2ADD stack[-3] // } 2AD9 5B JUMPDEST 2ADA 50 POP 2ADB 35 CALLDATALOAD 2ADC 91 SWAP2 2ADD 90 SWAP1 2ADE 50 POP 2ADF 56 *JUMP // Stack delta = -3 // Outputs[1] { @2ADC stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_2AE0: // Incoming call from 0x0706, returns to 0x0707 // Inputs[2] // { // @2AE8 stack[-1] // @2AE9 stack[-2] // } 2AE0 5B JUMPDEST 2AE1 60 PUSH1 0x00 2AE3 80 DUP1 2AE4 60 PUSH1 0x00 2AE6 60 PUSH1 0x40 2AE8 84 DUP5 2AE9 86 DUP7 2AEA 03 SUB 2AEB 12 SLT 2AEC 15 ISZERO 2AED 61 PUSH2 0x2af5 2AF0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2AE1 stack[0] = 0x00 // @2AE3 stack[1] = 0x00 // @2AE4 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2af5, if !(stack[-2] - stack[-1] i< 0x40) label_2AF1: // Incoming jump from 0x2AF0, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2AF4 memory[0x00:0x00] } 2AF1 60 PUSH1 0x00 2AF3 80 DUP1 2AF4 FD *REVERT // Stack delta = +0 // Outputs[1] { @2AF4 revert(memory[0x00:0x00]); } // Block terminates label_2AF5: // Incoming jump from 0x2AF0, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @2AF6 stack[-4] // @2AF7 msg.data[stack[-4]:stack[-4] + 0x20] // @2AF8 stack[-3] // @2AFE msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 2AF5 5B JUMPDEST 2AF6 83 DUP4 2AF7 35 CALLDATALOAD 2AF8 92 SWAP3 2AF9 50 POP 2AFA 60 PUSH1 0x20 2AFC 84 DUP5 2AFD 01 ADD 2AFE 35 CALLDATALOAD 2AFF 67 PUSH8 0xffffffffffffffff 2B08 81 DUP2 2B09 11 GT 2B0A 15 ISZERO 2B0B 61 PUSH2 0x2b13 2B0E 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @2AF8 stack[-3] = msg.data[stack[-4]:stack[-4] + 0x20] // @2AFE stack[0] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2b13, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) label_2B0F: // Incoming jump from 0x2B0E, if not !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2B12 memory[0x00:0x00] } 2B0F 60 PUSH1 0x00 2B11 80 DUP1 2B12 FD *REVERT // Stack delta = +0 // Outputs[1] { @2B12 revert(memory[0x00:0x00]); } // Block terminates label_2B13: // Incoming jump from 0x2B0E, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2B17 stack[-6] // @2B18 stack[-1] // @2B19 stack[-5] // } 2B13 5B JUMPDEST 2B14 61 PUSH2 0x2b1f 2B17 86 DUP7 2B18 82 DUP3 2B19 87 DUP8 2B1A 01 ADD 2B1B 61 PUSH2 0x282a 2B1E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2B14 stack[0] = 0x2b1f // @2B17 stack[1] = stack[-6] // @2B1A stack[2] = stack[-5] + stack[-1] // } // Block ends with call to 0x282a, returns to 0x2B1F label_2B1F: // Incoming return from call to 0x282A at 0x2B1E // Inputs[6] // { // @2B20 stack[-6] // @2B20 stack[-1] // @2B21 stack[-9] // @2B22 stack[-2] // @2B23 stack[-8] // @2B26 stack[-7] // } 2B1F 5B JUMPDEST 2B20 94 SWAP5 2B21 97 SWAP8 2B22 90 SWAP1 2B23 96 SWAP7 2B24 50 POP 2B25 93 SWAP4 2B26 94 SWAP5 2B27 50 POP 2B28 50 POP 2B29 50 POP 2B2A 50 POP 2B2B 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @2B21 stack[-9] = stack[-6] // @2B23 stack[-8] = stack[-2] // @2B26 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-9] label_2B2C: // Incoming call from 0x2C69, returns to 0x28A1 // Incoming call from 0x2C56, returns to 0x2C1B // Inputs[3] // { // @2B2F stack[-1] // @2B30 memory[stack[-1]:stack[-1] + 0x20] // @2B32 stack[-2] // } 2B2C 5B JUMPDEST 2B2D 60 PUSH1 0x00 2B2F 81 DUP2 2B30 51 MLOAD 2B31 80 DUP1 2B32 84 DUP5 2B33 52 MSTORE 2B34 61 PUSH2 0x2b44 2B37 81 DUP2 2B38 60 PUSH1 0x20 2B3A 86 DUP7 2B3B 01 ADD 2B3C 60 PUSH1 0x20 2B3E 86 DUP7 2B3F 01 ADD 2B40 61 PUSH2 0x2ccc 2B43 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @2B2D stack[0] = 0x00 // @2B30 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @2B33 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2B34 stack[2] = 0x2b44 // @2B37 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @2B3B stack[4] = stack[-2] + 0x20 // @2B3F stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x2ccc, returns to 0x2B44 label_2B44: // Incoming return from call to 0x2CCC at 0x2B43 // Inputs[4] // { // @2B47 stack[-1] // @2B4C stack[-4] // @2B4D stack[-2] // @2B53 stack[-5] // } 2B44 5B JUMPDEST 2B45 60 PUSH1 0x1f 2B47 01 ADD 2B48 60 PUSH1 0x1f 2B4A 19 NOT 2B4B 16 AND 2B4C 92 SWAP3 2B4D 90 SWAP1 2B4E 92 SWAP3 2B4F 01 ADD 2B50 60 PUSH1 0x20 2B52 01 ADD 2B53 92 SWAP3 2B54 91 SWAP2 2B55 50 POP 2B56 50 POP 2B57 56 *JUMP // Stack delta = -4 // Outputs[1] { @2B53 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_2B58: // Incoming call from 0x2C14, returns to 0x2C15 // Incoming jump from 0x2C1A // Inputs[3] // { // @2B5B stack[-1] // @2B5C memory[stack[-1]:stack[-1] + 0x20] // @2B61 stack[-2] // } 2B58 5B JUMPDEST 2B59 60 PUSH1 0x00 2B5B 81 DUP2 2B5C 51 MLOAD 2B5D 61 PUSH2 0x2b6a 2B60 81 DUP2 2B61 85 DUP6 2B62 60 PUSH1 0x20 2B64 86 DUP7 2B65 01 ADD 2B66 61 PUSH2 0x2ccc 2B69 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2B59 stack[0] = 0x00 // @2B5C stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @2B5D stack[2] = 0x2b6a // @2B60 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @2B61 stack[4] = stack[-2] // @2B65 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x2ccc, returns to 0x2B6A label_2B6A: // Incoming return from call to 0x2CCC at 0x2B69 // Inputs[4] // { // @2B6B stack[-1] // @2B6B stack[-4] // @2B6C stack[-2] // @2B6F stack[-5] // } 2B6A 5B JUMPDEST 2B6B 92 SWAP3 2B6C 90 SWAP1 2B6D 92 SWAP3 2B6E 01 ADD 2B6F 92 SWAP3 2B70 91 SWAP2 2B71 50 POP 2B72 50 POP 2B73 56 *JUMP // Stack delta = -4 // Outputs[1] { @2B6F stack[-5] = stack[-1] + stack[-4] } // Block ends with unconditional jump to stack[-5] label_2B74: // Incoming call from 0x160D, returns to 0x160E // Inputs[2] // { // @2B78 stack[-4] // @2B79 storage[stack[-4]] // } 2B74 5B JUMPDEST 2B75 60 PUSH1 0x00 2B77 80 DUP1 2B78 85 DUP6 2B79 54 SLOAD 2B7A 81 DUP2 2B7B 60 PUSH1 0x01 2B7D 82 DUP3 2B7E 81 DUP2 2B7F 1C SHR 2B80 91 SWAP2 2B81 50 POP 2B82 80 DUP1 2B83 83 DUP4 2B84 16 AND 2B85 80 DUP1 2B86 61 PUSH2 0x2b90 2B89 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @2B75 stack[0] = 0x00 // @2B77 stack[1] = 0x00 // @2B79 stack[2] = storage[stack[-4]] // @2B7B stack[4] = 0x01 // @2B80 stack[3] = storage[stack[-4]] >> 0x01 // @2B84 stack[5] = storage[stack[-4]] & 0x01 // } // Block ends with conditional jump to 0x2b90, if storage[stack[-4]] & 0x01 label_2B8A: // Incoming jump from 0x2B89, if not storage[stack[-4]] & 0x01 // Inputs[2] // { // @2B8C stack[-3] // @2B96 stack[-1] // } 2B8A 60 PUSH1 0x7f 2B8C 83 DUP4 2B8D 16 AND 2B8E 92 SWAP3 2B8F 50 POP 2B90 5B JUMPDEST 2B91 60 PUSH1 0x20 2B93 80 DUP1 2B94 84 DUP5 2B95 10 LT 2B96 82 DUP3 2B97 14 EQ 2B98 15 ISZERO 2B99 61 PUSH2 0x2bb0 2B9C 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @2B8E stack[-3] = stack[-3] & 0x7f // @2B91 stack[0] = 0x20 // } // Block ends with conditional jump to 0x2bb0, if !(stack[-1] == (stack[-3] & 0x7f < 0x20)) label_2B9D: // Incoming jump from 0x2B9C, if not !(stack[-1] == (stack[-3] & 0x7f < 0x20)) // Incoming jump from 0x2B9C, if not !(stack[-1] == (stack[-3] < 0x20)) // Inputs[2] // { // @2BA5 stack[-6] // @2BAF memory[stack[-6]:stack[-6] + 0x24] // } 2B9D 63 PUSH4 0x4e487b71 2BA2 60 PUSH1 0xe0 2BA4 1B SHL 2BA5 86 DUP7 2BA6 52 MSTORE 2BA7 60 PUSH1 0x22 2BA9 60 PUSH1 0x04 2BAB 52 MSTORE 2BAC 60 PUSH1 0x24 2BAE 86 DUP7 2BAF FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2BA6 memory[stack[-6]:stack[-6] + 0x20] = 0x4e487b71 << 0xe0 // @2BAB memory[0x04:0x24] = 0x22 // @2BAF revert(memory[stack[-6]:stack[-6] + 0x24]); // } // Block terminates label_2BB0: // Incoming jump from 0x2B9C, if !(stack[-1] == (stack[-3] & 0x7f < 0x20)) // Incoming jump from 0x2B9C, if !(stack[-1] == (stack[-3] < 0x20)) // Inputs[1] { @2BB1 stack[-2] } 2BB0 5B JUMPDEST 2BB1 81 DUP2 2BB2 80 DUP1 2BB3 15 ISZERO 2BB4 61 PUSH2 0x2bc4 2BB7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2BB1 stack[0] = stack[-2] } // Block ends with conditional jump to 0x2bc4, if !stack[-2] label_2BB8: // Incoming jump from 0x2BB7, if not !stack[-2] // Inputs[1] { @2BBA stack[-1] } 2BB8 60 PUSH1 0x01 2BBA 81 DUP2 2BBB 14 EQ 2BBC 61 PUSH2 0x2bd5 2BBF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2bd5, if stack[-1] == 0x01 label_2BC0: // Incoming jump from 0x2BBF, if not stack[-1] == 0x01 2BC0 61 PUSH2 0x2c02 2BC3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2c02 label_2BC4: // Incoming jump from 0x2BB7, if !stack[-2] // Inputs[4] // { // @2BC8 stack[-6] // @2BCA stack[-9] // @2BCC stack[-5] // @2BCF stack[-7] // } 2BC4 5B JUMPDEST 2BC5 60 PUSH1 0xff 2BC7 19 NOT 2BC8 86 DUP7 2BC9 16 AND 2BCA 89 DUP10 2BCB 52 MSTORE 2BCC 84 DUP5 2BCD 89 DUP10 2BCE 01 ADD 2BCF 96 SWAP7 2BD0 50 POP 2BD1 61 PUSH2 0x2c02 2BD4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2BCB memory[stack[-9]:stack[-9] + 0x20] = stack[-6] & ~0xff // @2BCF stack[-7] = stack[-9] + stack[-5] // } // Block ends with unconditional jump to 0x2c02 label_2BD5: // Incoming jump from 0x2BBF, if stack[-1] == 0x01 // Inputs[3] // { // @2BD8 stack[-12] // @2BDE memory[0x00:0x20] // @2BE2 stack[-5] // } 2BD5 5B JUMPDEST 2BD6 60 PUSH1 0x00 2BD8 8C DUP13 2BD9 81 DUP2 2BDA 52 MSTORE 2BDB 60 PUSH1 0x20 2BDD 90 SWAP1 2BDE 20 SHA3 2BDF 60 PUSH1 0x00 2BE1 5B JUMPDEST 2BE2 86 DUP7 2BE3 81 DUP2 2BE4 10 LT 2BE5 15 ISZERO 2BE6 61 PUSH2 0x2bfa 2BE9 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2BDA memory[0x00:0x20] = stack[-12] // @2BDE stack[0] = keccak256(memory[0x00:0x20]) // @2BDF stack[1] = 0x00 // } // Block ends with conditional jump to 0x2bfa, if !(0x00 < stack[-5]) label_2BEA: // Incoming jump from 0x2BE9, if not !(0x00 < stack[-5]) // Incoming jump from 0x2BE9, if not !(stack[-1] < stack[-7]) // Inputs[6] // { // @2BEA stack[-2] // @2BEB storage[stack[-2]] // @2BEC stack[-11] // @2BED stack[-1] // @2BF1 stack[-6] // @2BF4 stack[-4] // } 2BEA 81 DUP2 2BEB 54 SLOAD 2BEC 8B DUP12 2BED 82 DUP3 2BEE 01 ADD 2BEF 52 MSTORE 2BF0 90 SWAP1 2BF1 85 DUP6 2BF2 01 ADD 2BF3 90 SWAP1 2BF4 83 DUP4 2BF5 01 ADD 2BF6 61 PUSH2 0x2be1 2BF9 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2BEF memory[stack[-1] + stack[-11]:stack[-1] + stack[-11] + 0x20] = storage[stack[-2]] // @2BF3 stack[-2] = stack[-6] + stack[-2] // @2BF5 stack[-1] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x2be1 label_2BFA: // Incoming jump from 0x2BE9, if !(0x00 < stack[-5]) // Incoming jump from 0x2BE9, if !(stack[-1] < stack[-7]) // Inputs[3] // { // @2BFD stack[-7] // @2BFE stack[-11] // @2C00 stack[-9] // } 2BFA 5B JUMPDEST 2BFB 50 POP 2BFC 50 POP 2BFD 84 DUP5 2BFE 89 DUP10 2BFF 01 ADD 2C00 96 SWAP7 2C01 50 POP // Stack delta = -2 // Outputs[1] { @2C00 stack[-9] = stack[-11] + stack[-7] } // Block continues label_2C02: // Incoming jump from 0x2BD4 // Incoming jump from 0x2C01 // Incoming jump from 0x2BC3 // Inputs[2] // { // @2C0F stack[-7] // @2C10 stack[-11] // } 2C02 5B JUMPDEST 2C03 50 POP 2C04 50 POP 2C05 50 POP 2C06 50 POP 2C07 50 POP 2C08 50 POP 2C09 61 PUSH2 0x2c1b 2C0C 61 PUSH2 0x2c15 2C0F 82 DUP3 2C10 87 DUP8 2C11 61 PUSH2 0x2b58 2C14 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @2C09 stack[-6] = 0x2c1b // @2C0C stack[-5] = 0x2c15 // @2C0F stack[-4] = stack[-7] // @2C10 stack[-3] = stack[-11] // } // Block ends with call to 0x2b58, returns to 0x2C15 label_2C15: // Incoming return from call to 0x2B58 at 0x2C14 // Inputs[1] { @2C16 stack[-6] } 2C15 5B JUMPDEST 2C16 85 DUP6 2C17 61 PUSH2 0x2b58 2C1A 56 *JUMP // Stack delta = +1 // Outputs[1] { @2C16 stack[0] = stack[-6] } // Block ends with unconditional jump to 0x2b58 label_2C1B: // Incoming return from call to 0x2C15 at 0x2C14 // Incoming return from call to 0x2B2C at 0x2C56 // Inputs[3] // { // @2C1C stack[-1] // @2C1C stack[-8] // @2C1D stack[-7] // } 2C1B 5B JUMPDEST 2C1C 96 SWAP7 2C1D 95 SWAP6 2C1E 50 POP 2C1F 50 POP 2C20 50 POP 2C21 50 POP 2C22 50 POP 2C23 50 POP 2C24 56 *JUMP // Stack delta = -7 // Outputs[1] { @2C1C stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_2C25: // Incoming jump from 0x22F4 // Inputs[5] // { // @2C31 stack[-5] // @2C33 stack[-1] // @2C36 stack[-4] // @2C3E stack[-3] // @2C52 stack[-2] // } 2C25 5B JUMPDEST 2C26 60 PUSH1 0x00 2C28 60 PUSH1 0x01 2C2A 60 PUSH1 0x01 2C2C 60 PUSH1 0xa0 2C2E 1B SHL 2C2F 03 SUB 2C30 80 DUP1 2C31 87 DUP8 2C32 16 AND 2C33 83 DUP4 2C34 52 MSTORE 2C35 80 DUP1 2C36 86 DUP7 2C37 16 AND 2C38 60 PUSH1 0x20 2C3A 84 DUP5 2C3B 01 ADD 2C3C 52 MSTORE 2C3D 50 POP 2C3E 83 DUP4 2C3F 60 PUSH1 0x40 2C41 83 DUP4 2C42 01 ADD 2C43 52 MSTORE 2C44 60 PUSH1 0x80 2C46 60 PUSH1 0x60 2C48 83 DUP4 2C49 01 ADD 2C4A 52 MSTORE 2C4B 61 PUSH2 0x2c1b 2C4E 60 PUSH1 0x80 2C50 83 DUP4 2C51 01 ADD 2C52 84 DUP5 2C53 61 PUSH2 0x2b2c 2C56 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @2C26 stack[0] = 0x00 // @2C34 memory[stack[-1]:stack[-1] + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @2C3C memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2C43 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @2C4A memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @2C4B stack[1] = 0x2c1b // @2C51 stack[2] = stack[-1] + 0x80 // @2C52 stack[3] = stack[-2] // } // Block ends with call to 0x2b2c, returns to 0x2C1B label_2C57: // Incoming jump from 0x0316 // Inputs[2] // { // @2C5A stack[-1] // @2C65 stack[-2] // } 2C57 5B JUMPDEST 2C58 60 PUSH1 0x20 2C5A 81 DUP2 2C5B 52 MSTORE 2C5C 60 PUSH1 0x00 2C5E 61 PUSH2 0x28a1 2C61 60 PUSH1 0x20 2C63 83 DUP4 2C64 01 ADD 2C65 84 DUP5 2C66 61 PUSH2 0x2b2c 2C69 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2C5B memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2C5C stack[0] = 0x00 // @2C5E stack[1] = 0x28a1 // @2C64 stack[2] = stack[-1] + 0x20 // @2C65 stack[3] = stack[-2] // } // Block ends with call to 0x2b2c, returns to 0x28A1 label_2C6A: // Incoming call from 0x0E66, returns to 0x0E67 // Incoming call from 0x13D0, returns to 0x0E67 // Incoming call from 0x1309, returns to 0x130A // Incoming call from 0x2693, returns to 0x2694 // Incoming call from 0x1974, returns to 0x0E67 // Incoming call from 0x0DD9, returns to 0x0DDA // Incoming call from 0x18AD, returns to 0x18AE // Incoming call from 0x1E1E, returns to 0x1E1F // Incoming call from 0x206A, returns to 0x206B // Inputs[2] // { // @2C6D stack[-2] // @2C6F stack[-1] // } 2C6A 5B JUMPDEST 2C6B 60 PUSH1 0x00 2C6D 82 DUP3 2C6E 19 NOT 2C6F 82 DUP3 2C70 11 GT 2C71 15 ISZERO 2C72 61 PUSH2 0x2c7d 2C75 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2C6B stack[0] = 0x00 } // Block ends with conditional jump to 0x2c7d, if !(stack[-1] > ~stack[-2]) label_2C76: // Incoming jump from 0x2C75, if not !(stack[-1] > ~stack[-2]) 2C76 61 PUSH2 0x2c7d 2C79 61 PUSH2 0x2d62 2C7C 56 *JUMP // Stack delta = +1 // Outputs[1] { @2C76 stack[0] = 0x2c7d } // Block ends with unconditional jump to 0x2d62 label_2C7D: // Incoming jump from 0x2C75, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @2C7F stack[-3] // @2C7F stack[-2] // @2C80 stack[-4] // } 2C7D 5B JUMPDEST 2C7E 50 POP 2C7F 01 ADD 2C80 90 SWAP1 2C81 56 *JUMP // Stack delta = -3 // Outputs[1] { @2C80 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_2C82: // Incoming call from 0x20B9, returns to 0x20BA // Incoming call from 0x1FF1, returns to 0x1FF2 // Inputs[1] { @2C85 stack[-2] } 2C82 5B JUMPDEST 2C83 60 PUSH1 0x00 2C85 82 DUP3 2C86 61 PUSH2 0x2c91 2C89 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2C83 stack[0] = 0x00 } // Block ends with conditional jump to 0x2c91, if stack[-2] label_2C8A: // Incoming jump from 0x2C89, if not stack[-2] 2C8A 61 PUSH2 0x2c91 2C8D 61 PUSH2 0x2d78 2C90 56 *JUMP // Stack delta = +1 // Outputs[1] { @2C8A stack[0] = 0x2c91 } // Block ends with unconditional jump to 0x2d78 label_2C91: // Incoming jump from 0x2C89, if stack[-2] // Inputs[3] // { // @2C93 stack[-2] // @2C93 stack[-3] // @2C94 stack[-4] // } 2C91 5B JUMPDEST 2C92 50 POP 2C93 04 DIV 2C94 90 SWAP1 2C95 56 *JUMP // Stack delta = -3 // Outputs[1] { @2C94 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_2C96: // Incoming call from 0x1369, returns to 0x136A // Incoming call from 0x190D, returns to 0x190E // Inputs[2] // { // @2C99 stack[-1] // @2C9E stack[-2] // } 2C96 5B JUMPDEST 2C97 60 PUSH1 0x00 2C99 81 DUP2 2C9A 60 PUSH1 0x00 2C9C 19 NOT 2C9D 04 DIV 2C9E 83 DUP4 2C9F 11 GT 2CA0 82 DUP3 2CA1 15 ISZERO 2CA2 15 ISZERO 2CA3 16 AND 2CA4 15 ISZERO 2CA5 61 PUSH2 0x2cb0 2CA8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2C97 stack[0] = 0x00 } // Block ends with conditional jump to 0x2cb0, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_2CA9: // Incoming jump from 0x2CA8, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 2CA9 61 PUSH2 0x2cb0 2CAC 61 PUSH2 0x2d62 2CAF 56 *JUMP // Stack delta = +1 // Outputs[1] { @2CA9 stack[0] = 0x2cb0 } // Block ends with unconditional jump to 0x2d62 label_2CB0: // Incoming jump from 0x2CA8, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @2CB2 stack[-3] // @2CB2 stack[-2] // @2CB3 stack[-4] // } 2CB0 5B JUMPDEST 2CB1 50 POP 2CB2 02 MUL 2CB3 90 SWAP1 2CB4 56 *JUMP // Stack delta = -3 // Outputs[1] { @2CB3 stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_2CB5: // Incoming call from 0x2052, returns to 0x2053 // Incoming call from 0x1DF0, returns to 0x1DF1 // Incoming call from 0x242A, returns to 0x242B // Incoming call from 0x24C2, returns to 0x24C3 // Inputs[2] // { // @2CB8 stack[-2] // @2CB9 stack[-1] // } 2CB5 5B JUMPDEST 2CB6 60 PUSH1 0x00 2CB8 82 DUP3 2CB9 82 DUP3 2CBA 10 LT 2CBB 15 ISZERO 2CBC 61 PUSH2 0x2cc7 2CBF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2CB6 stack[0] = 0x00 } // Block ends with conditional jump to 0x2cc7, if !(stack[-1] < stack[-2]) label_2CC0: // Incoming jump from 0x2CBF, if not !(stack[-1] < stack[-2]) 2CC0 61 PUSH2 0x2cc7 2CC3 61 PUSH2 0x2d62 2CC6 56 *JUMP // Stack delta = +1 // Outputs[1] { @2CC0 stack[0] = 0x2cc7 } // Block ends with unconditional jump to 0x2d62 label_2CC7: // Incoming jump from 0x2CBF, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @2CC9 stack[-2] // @2CC9 stack[-3] // @2CCA stack[-4] // } 2CC7 5B JUMPDEST 2CC8 50 POP 2CC9 03 SUB 2CCA 90 SWAP1 2CCB 56 *JUMP // Stack delta = -3 // Outputs[1] { @2CCA stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_2CCC: // Incoming call from 0x2B43, returns to 0x2B44 // Incoming call from 0x2B69, returns to 0x2B6A // Inputs[1] { @2CD0 stack[-3] } 2CCC 5B JUMPDEST 2CCD 60 PUSH1 0x00 2CCF 5B JUMPDEST 2CD0 83 DUP4 2CD1 81 DUP2 2CD2 10 LT 2CD3 15 ISZERO 2CD4 61 PUSH2 0x2ce7 2CD7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2CCD stack[0] = 0x00 } // Block ends with conditional jump to 0x2ce7, if !(0x00 < stack[-3]) label_2CD8: // Incoming jump from 0x2CD7, if not !(0x00 < stack[-3]) // Incoming jump from 0x2CD7, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2CD8 stack[-2] // @2CD9 stack[-1] // @2CDB memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2CDC stack[-3] // } 2CD8 81 DUP2 2CD9 81 DUP2 2CDA 01 ADD 2CDB 51 MLOAD 2CDC 83 DUP4 2CDD 82 DUP3 2CDE 01 ADD 2CDF 52 MSTORE 2CE0 60 PUSH1 0x20 2CE2 01 ADD 2CE3 61 PUSH2 0x2ccf 2CE6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2CDF memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2CE2 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2ccf label_2CE7: // Incoming jump from 0x2CD7, if !(0x00 < stack[-3]) // Incoming jump from 0x2CD7, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @2CE8 stack[-4] // @2CE9 stack[-1] // } 2CE7 5B JUMPDEST 2CE8 83 DUP4 2CE9 81 DUP2 2CEA 11 GT 2CEB 15 ISZERO 2CEC 61 PUSH2 0x0e94 2CEF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e94, if !(stack[-1] > stack[-4]) label_2CF0: // Incoming jump from 0x2CEF, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @2CF4 stack[-4] // @2CF5 stack[-3] // @2CF7 stack[-5] // } 2CF0 50 POP 2CF1 50 POP 2CF2 60 PUSH1 0x00 2CF4 91 SWAP2 2CF5 01 ADD 2CF6 52 MSTORE 2CF7 56 *JUMP // Stack delta = -5 // Outputs[1] { @2CF6 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_2CF8: // Incoming call from 0x11F2, returns to 0x07E3 // Incoming call from 0x270A, returns to 0x270B // Incoming call from 0x07E2, returns to 0x07E3 // Incoming call from 0x1046, returns to 0x1047 // Incoming call from 0x1072, returns to 0x1073 // Incoming call from 0x080E, returns to 0x080F // Inputs[1] { @2CFB stack[-1] } 2CF8 5B JUMPDEST 2CF9 60 PUSH1 0x01 2CFB 81 DUP2 2CFC 81 DUP2 2CFD 1C SHR 2CFE 90 SWAP1 2CFF 82 DUP3 2D00 16 AND 2D01 80 DUP1 2D02 61 PUSH2 0x2d0c 2D05 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2CFE stack[0] = stack[-1] >> 0x01 // @2D00 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2d0c, if stack[-1] & 0x01 label_2D06: // Incoming jump from 0x2D05, if not stack[-1] & 0x01 // Inputs[2] // { // @2D08 stack[-2] // @2D11 stack[-1] // } 2D06 60 PUSH1 0x7f 2D08 82 DUP3 2D09 16 AND 2D0A 91 SWAP2 2D0B 50 POP 2D0C 5B JUMPDEST 2D0D 60 PUSH1 0x20 2D0F 82 DUP3 2D10 10 LT 2D11 81 DUP2 2D12 14 EQ 2D13 15 ISZERO 2D14 61 PUSH2 0x2d2d 2D17 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2D0A stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x2d2d, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_2D18: // Incoming jump from 0x2D17, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x2D17, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @2D2C memory[0x00:0x24] } 2D18 63 PUSH4 0x4e487b71 2D1D 60 PUSH1 0xe0 2D1F 1B SHL 2D20 60 PUSH1 0x00 2D22 52 MSTORE 2D23 60 PUSH1 0x22 2D25 60 PUSH1 0x04 2D27 52 MSTORE 2D28 60 PUSH1 0x24 2D2A 60 PUSH1 0x00 2D2C FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2D22 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2D27 memory[0x04:0x24] = 0x22 // @2D2C revert(memory[0x00:0x24]); // } // Block terminates label_2D2D: // Incoming jump from 0x2D17, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x2D17, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @2D2F stack[-4] // @2D2F stack[-2] // @2D30 stack[-3] // } 2D2D 5B JUMPDEST 2D2E 50 POP 2D2F 91 SWAP2 2D30 90 SWAP1 2D31 50 POP 2D32 56 *JUMP // Stack delta = -3 // Outputs[1] { @2D2F stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2D33: // Incoming call from 0x13E0, returns to 0x13E1 // Incoming call from 0x1994, returns to 0x1995 // Incoming call from 0x215C, returns to 0x215D // Incoming call from 0x1984, returns to 0x1985 // Incoming call from 0x0E8B, returns to 0x0E8C // Incoming call from 0x0E7B, returns to 0x0E7C // Incoming call from 0x215C, returns to 0x215D // Incoming call from 0x1FE2, returns to 0x1FE3 // Incoming call from 0x13F0, returns to 0x13F1 // Inputs[1] { @2D39 stack[-1] } 2D33 5B JUMPDEST 2D34 60 PUSH1 0x00 2D36 60 PUSH1 0x00 2D38 19 NOT 2D39 82 DUP3 2D3A 14 EQ 2D3B 15 ISZERO 2D3C 61 PUSH2 0x2d47 2D3F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2D34 stack[0] = 0x00 } // Block ends with conditional jump to 0x2d47, if !(stack[-1] == ~0x00) label_2D40: // Incoming jump from 0x2D3F, if not !(stack[-1] == ~0x00) 2D40 61 PUSH2 0x2d47 2D43 61 PUSH2 0x2d62 2D46 56 *JUMP // Stack delta = +1 // Outputs[1] { @2D40 stack[0] = 0x2d47 } // Block ends with unconditional jump to 0x2d62 label_2D47: // Incoming jump from 0x2D3F, if !(stack[-1] == ~0x00) // Inputs[2] // { // @2D4B stack[-2] // @2D4C stack[-3] // } 2D47 5B JUMPDEST 2D48 50 POP 2D49 60 PUSH1 0x01 2D4B 01 ADD 2D4C 90 SWAP1 2D4D 56 *JUMP // Stack delta = -2 // Outputs[1] { @2D4C stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_2D4E: // Incoming call from 0x205F, returns to 0x2060 // Inputs[1] { @2D51 stack[-2] } 2D4E 5B JUMPDEST 2D4F 60 PUSH1 0x00 2D51 82 DUP3 2D52 61 PUSH2 0x2d5d 2D55 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2D4F stack[0] = 0x00 } // Block ends with conditional jump to 0x2d5d, if stack[-2] label_2D56: // Incoming jump from 0x2D55, if not stack[-2] 2D56 61 PUSH2 0x2d5d 2D59 61 PUSH2 0x2d78 2D5C 56 *JUMP // Stack delta = +1 // Outputs[1] { @2D56 stack[0] = 0x2d5d } // Block ends with unconditional jump to 0x2d78 label_2D5D: // Incoming jump from 0x2D55, if stack[-2] // Inputs[3] // { // @2D5F stack[-3] // @2D5F stack[-2] // @2D60 stack[-4] // } 2D5D 5B JUMPDEST 2D5E 50 POP 2D5F 06 MOD 2D60 90 SWAP1 2D61 56 *JUMP // Stack delta = -3 // Outputs[1] { @2D60 stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_2D62: // Incoming jump from 0x2C7C // Incoming jump from 0x2CAF // Incoming jump from 0x2D46 // Incoming jump from 0x2CC6 // Inputs[1] { @2D77 memory[0x00:0x24] } 2D62 5B JUMPDEST 2D63 63 PUSH4 0x4e487b71 2D68 60 PUSH1 0xe0 2D6A 1B SHL 2D6B 60 PUSH1 0x00 2D6D 52 MSTORE 2D6E 60 PUSH1 0x11 2D70 60 PUSH1 0x04 2D72 52 MSTORE 2D73 60 PUSH1 0x24 2D75 60 PUSH1 0x00 2D77 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2D6D memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2D72 memory[0x04:0x24] = 0x11 // @2D77 revert(memory[0x00:0x24]); // } // Block terminates label_2D78: // Incoming jump from 0x2D5C // Incoming jump from 0x2C90 // Inputs[1] { @2D8D memory[0x00:0x24] } 2D78 5B JUMPDEST 2D79 63 PUSH4 0x4e487b71 2D7E 60 PUSH1 0xe0 2D80 1B SHL 2D81 60 PUSH1 0x00 2D83 52 MSTORE 2D84 60 PUSH1 0x12 2D86 60 PUSH1 0x04 2D88 52 MSTORE 2D89 60 PUSH1 0x24 2D8B 60 PUSH1 0x00 2D8D FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2D83 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2D88 memory[0x04:0x24] = 0x12 // @2D8D revert(memory[0x00:0x24]); // } // Block terminates label_2D8E: // Incoming jump from 0x2543 // Inputs[1] { @2DA3 memory[0x00:0x24] } 2D8E 5B JUMPDEST 2D8F 63 PUSH4 0x4e487b71 2D94 60 PUSH1 0xe0 2D96 1B SHL 2D97 60 PUSH1 0x00 2D99 52 MSTORE 2D9A 60 PUSH1 0x31 2D9C 60 PUSH1 0x04 2D9E 52 MSTORE 2D9F 60 PUSH1 0x24 2DA1 60 PUSH1 0x00 2DA3 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2D99 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2D9E memory[0x04:0x24] = 0x31 // @2DA3 revert(memory[0x00:0x24]); // } // Block terminates label_2DA4: // Incoming jump from 0x0F2B // Incoming jump from 0x24EA // Incoming jump from 0x0E47 // Incoming jump from 0x207F // Incoming jump from 0x20E2 // Incoming jump from 0x250B // Inputs[1] { @2DB9 memory[0x00:0x24] } 2DA4 5B JUMPDEST 2DA5 63 PUSH4 0x4e487b71 2DAA 60 PUSH1 0xe0 2DAC 1B SHL 2DAD 60 PUSH1 0x00 2DAF 52 MSTORE 2DB0 60 PUSH1 0x32 2DB2 60 PUSH1 0x04 2DB4 52 MSTORE 2DB5 60 PUSH1 0x24 2DB7 60 PUSH1 0x00 2DB9 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2DAF memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2DB4 memory[0x04:0x24] = 0x32 // @2DB9 revert(memory[0x00:0x24]); // } // Block terminates label_2DBA: // Incoming jump from 0x27DA // Incoming jump from 0x2013 // Incoming jump from 0x27B2 // Inputs[1] { @2DCF memory[0x00:0x24] } 2DBA 5B JUMPDEST 2DBB 63 PUSH4 0x4e487b71 2DC0 60 PUSH1 0xe0 2DC2 1B SHL 2DC3 60 PUSH1 0x00 2DC5 52 MSTORE 2DC6 60 PUSH1 0x41 2DC8 60 PUSH1 0x04 2DCA 52 MSTORE 2DCB 60 PUSH1 0x24 2DCD 60 PUSH1 0x00 2DCF FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2DC5 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2DCA memory[0x04:0x24] = 0x41 // @2DCF revert(memory[0x00:0x24]); // } // Block terminates label_2DD0: // Incoming call from 0x2A60, returns to 0x28A1 // Inputs[1] { @2DDA stack[-1] } 2DD0 5B JUMPDEST 2DD1 60 PUSH1 0x01 2DD3 60 PUSH1 0x01 2DD5 60 PUSH1 0xe0 2DD7 1B SHL 2DD8 03 SUB 2DD9 19 NOT 2DDA 81 DUP2 2DDB 16 AND 2DDC 81 DUP2 2DDD 14 EQ 2DDE 61 PUSH2 0x0d02 2DE1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d02, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_2DE2: // Incoming jump from 0x2DE1, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2DE5 memory[0x00:0x00] } 2DE2 60 PUSH1 0x00 2DE4 80 DUP1 2DE5 FD *REVERT // Stack delta = +0 // Outputs[1] { @2DE5 revert(memory[0x00:0x00]); } // Block terminates 2DE6 FE *ASSERT 2DE7 64 PUSH5 0x3163663932 2DED 34 CALLVALUE 2DEE 36 CALLDATASIZE 2DEF 35 CALLDATALOAD 2DF0 61 PUSH2 0x6363 2DF3 62 PUSH3 0x343735 2DF7 35 CALLDATALOAD 2DF8 38 CODESIZE 2DF9 35 CALLDATALOAD 2DFA 64 PUSH5 0x6363306265 2E00 36 CALLDATASIZE 2E01 33 CALLER 2E02 34 CALLVALUE 2E03 62 PUSH3 0x616163 2E07 35 CALLDATALOAD 2E08 64 PUSH5 0x6137366566 2E0E 37 CALLDATACOPY 2E0F 32 ORIGIN 2E10 37 CALLDATACOPY 2E11 63 PUSH4 0x33383039 2E16 33 CALLER 2E17 61 PUSH2 0x6330 2E1A 37 CALLDATACOPY 2E1B 37 CALLDATACOPY 2E1C 63 PUSH4 0x61323334 2E21 66 PUSH7 0x3930663139a264 2E29 69 PUSH10 0x706673582212206aa0ab 2E34 15 ISZERO 2E35 58 PC 2E36 DA DA 2E37 2B 2B 2E38 1F 1F 2E39 38 CODESIZE 2E3A 53 MSTORE8 2E3B 57 *JUMPI 2E3C 9D SWAP14 2E3D A0 LOG0 2E3E B1 DUP 2E3F 9A SWAP11 2E40 AF AF 2E41 CF CF 2E42 33 CALLER 2E43 64 PUSH5 0xd76f4053b8 2E49 AB AB 2E4A 9B SWAP12 2E4B B6 B6 2E4C 05 SDIV 2E4D 29 29 2E4E A7 A7 2E4F 94 SWAP5 2E50 7E PUSH31 0x64736f6c63430008070033