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 0x025c 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x025c, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x70a08231 0019 11 GT 001A 61 PUSH2 0x0144 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0144, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xb5b1cd7c 0024 11 GT 0025 61 PUSH2 0x00b6 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b6, if 0xb5b1cd7c > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xb5b1cd7c > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xd5abeb01 002F 11 GT 0030 61 PUSH2 0x007a 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007a, if 0xd5abeb01 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xd5abeb01 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xd5abeb01 003A 14 EQ 003B 61 PUSH2 0x06d8 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06d8, if 0xd5abeb01 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xd5abeb01 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xdb4bec44 0045 14 EQ 0046 61 PUSH2 0x06ee 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06ee, if 0xdb4bec44 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xdb4bec44 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe0a80853 0050 14 EQ 0051 61 PUSH2 0x071e 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x071e, if 0xe0a80853 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe0a80853 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xe985e9c5 005B 14 EQ 005C 61 PUSH2 0x073e 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x073e, if 0xe985e9c5 == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xefbd73f4 0066 14 EQ 0067 61 PUSH2 0x0787 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0787, if 0xefbd73f4 == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xefbd73f4 == stack[-1] // Inputs[1] { @006B stack[-1] } 006B 80 DUP1 006C 63 PUSH4 0xf2fde38b 0071 14 EQ 0072 61 PUSH2 0x07a7 0075 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07a7, if 0xf2fde38b == stack[-1] label_0076: // Incoming jump from 0x0075, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0079 memory[0x00:0x00] } 0076 60 PUSH1 0x00 0078 80 DUP1 0079 FD *REVERT // Stack delta = +0 // Outputs[1] { @0079 revert(memory[0x00:0x00]); } // Block terminates label_007A: // Incoming jump from 0x0033, if 0xd5abeb01 > stack[-1] // Inputs[1] { @007B stack[-1] } 007A 5B JUMPDEST 007B 80 DUP1 007C 63 PUSH4 0xb5b1cd7c 0081 14 EQ 0082 61 PUSH2 0x0635 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0635, if 0xb5b1cd7c == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xb5b1cd7c == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xb767a098 008C 14 EQ 008D 61 PUSH2 0x0665 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0665, if 0xb767a098 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xb767a098 == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xb88d4fde 0097 14 EQ 0098 61 PUSH2 0x0685 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0685, if 0xb88d4fde == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xb88d4fde == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0xc87b56dd 00A2 14 EQ 00A3 61 PUSH2 0x06a5 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06a5, if 0xc87b56dd == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xc87b56dd == stack[-1] // Inputs[1] { @00A7 stack[-1] } 00A7 80 DUP1 00A8 63 PUSH4 0xd2cab056 00AD 14 EQ 00AE 61 PUSH2 0x06c5 00B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06c5, if 0xd2cab056 == stack[-1] label_00B2: // Incoming jump from 0x00B1, if not 0xd2cab056 == stack[-1] // Inputs[1] { @00B5 memory[0x00:0x00] } 00B2 60 PUSH1 0x00 00B4 80 DUP1 00B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @00B5 revert(memory[0x00:0x00]); } // Block terminates label_00B6: // Incoming jump from 0x0028, if 0xb5b1cd7c > stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B6 5B JUMPDEST 00B7 80 DUP1 00B8 63 PUSH4 0x94354fd0 00BD 11 GT 00BE 61 PUSH2 0x0108 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0108, if 0x94354fd0 > stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x94354fd0 > stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x94354fd0 00C8 14 EQ 00C9 61 PUSH2 0x05a2 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a2, if 0x94354fd0 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x94354fd0 == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0x95d89b41 00D3 14 EQ 00D4 61 PUSH2 0x05b8 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b8, if 0x95d89b41 == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0xa0712d68 00DE 14 EQ 00DF 61 PUSH2 0x05cd 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05cd, if 0xa0712d68 == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0xa0712d68 == stack[-1] // Inputs[1] { @00E3 stack[-1] } 00E3 80 DUP1 00E4 63 PUSH4 0xa22cb465 00E9 14 EQ 00EA 61 PUSH2 0x05e0 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05e0, if 0xa22cb465 == stack[-1] label_00EE: // Incoming jump from 0x00ED, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00EE stack[-1] } 00EE 80 DUP1 00EF 63 PUSH4 0xa45ba8e7 00F4 14 EQ 00F5 61 PUSH2 0x0600 00F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0600, if 0xa45ba8e7 == stack[-1] label_00F9: // Incoming jump from 0x00F8, if not 0xa45ba8e7 == stack[-1] // Inputs[1] { @00F9 stack[-1] } 00F9 80 DUP1 00FA 63 PUSH4 0xb071401b 00FF 14 EQ 0100 61 PUSH2 0x0615 0103 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0615, if 0xb071401b == stack[-1] label_0104: // Incoming jump from 0x0103, if not 0xb071401b == stack[-1] // Inputs[1] { @0107 memory[0x00:0x00] } 0104 60 PUSH1 0x00 0106 80 DUP1 0107 FD *REVERT // Stack delta = +0 // Outputs[1] { @0107 revert(memory[0x00:0x00]); } // Block terminates label_0108: // Incoming jump from 0x00C1, if 0x94354fd0 > stack[-1] // Inputs[1] { @0109 stack[-1] } 0108 5B JUMPDEST 0109 80 DUP1 010A 63 PUSH4 0x70a08231 010F 14 EQ 0110 61 PUSH2 0x050f 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x050f, if 0x70a08231 == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x70a08231 == stack[-1] // Inputs[1] { @0114 stack[-1] } 0114 80 DUP1 0115 63 PUSH4 0x715018a6 011A 14 EQ 011B 61 PUSH2 0x052f 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x052f, if 0x715018a6 == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x715018a6 == stack[-1] // Inputs[1] { @011F stack[-1] } 011F 80 DUP1 0120 63 PUSH4 0x7cb64759 0125 14 EQ 0126 61 PUSH2 0x0544 0129 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0544, if 0x7cb64759 == stack[-1] label_012A: // Incoming jump from 0x0129, if not 0x7cb64759 == stack[-1] // Inputs[1] { @012A stack[-1] } 012A 80 DUP1 012B 63 PUSH4 0x7ec4a659 0130 14 EQ 0131 61 PUSH2 0x0564 0134 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0564, if 0x7ec4a659 == stack[-1] label_0135: // Incoming jump from 0x0134, if not 0x7ec4a659 == stack[-1] // Inputs[1] { @0135 stack[-1] } 0135 80 DUP1 0136 63 PUSH4 0x8da5cb5b 013B 14 EQ 013C 61 PUSH2 0x0584 013F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0584, if 0x8da5cb5b == stack[-1] label_0140: // Incoming jump from 0x013F, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0143 memory[0x00:0x00] } 0140 60 PUSH1 0x00 0142 80 DUP1 0143 FD *REVERT // Stack delta = +0 // Outputs[1] { @0143 revert(memory[0x00:0x00]); } // Block terminates label_0144: // Incoming jump from 0x001D, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0145 stack[-1] } 0144 5B JUMPDEST 0145 80 DUP1 0146 63 PUSH4 0x3ccfd60b 014B 11 GT 014C 61 PUSH2 0x01dd 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01dd, if 0x3ccfd60b > stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x3ccfd60b > stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x51830227 0156 11 GT 0157 61 PUSH2 0x01a1 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a1, if 0x51830227 > stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x51830227 > stack[-1] // Inputs[1] { @015B stack[-1] } 015B 80 DUP1 015C 63 PUSH4 0x51830227 0161 14 EQ 0162 61 PUSH2 0x046c 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x046c, if 0x51830227 == stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x51830227 == stack[-1] // Inputs[1] { @0166 stack[-1] } 0166 80 DUP1 0167 63 PUSH4 0x5503a0e8 016C 14 EQ 016D 61 PUSH2 0x048c 0170 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048c, if 0x5503a0e8 == stack[-1] label_0171: // Incoming jump from 0x0170, if not 0x5503a0e8 == stack[-1] // Inputs[1] { @0171 stack[-1] } 0171 80 DUP1 0172 63 PUSH4 0x5c975abb 0177 14 EQ 0178 61 PUSH2 0x04a1 017B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a1, if 0x5c975abb == stack[-1] label_017C: // Incoming jump from 0x017B, if not 0x5c975abb == stack[-1] // Inputs[1] { @017C stack[-1] } 017C 80 DUP1 017D 63 PUSH4 0x62b99ad4 0182 14 EQ 0183 61 PUSH2 0x04bb 0186 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04bb, if 0x62b99ad4 == stack[-1] label_0187: // Incoming jump from 0x0186, if not 0x62b99ad4 == stack[-1] // Inputs[1] { @0187 stack[-1] } 0187 80 DUP1 0188 63 PUSH4 0x6352211e 018D 14 EQ 018E 61 PUSH2 0x04d0 0191 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d0, if 0x6352211e == stack[-1] label_0192: // Incoming jump from 0x0191, if not 0x6352211e == stack[-1] // Inputs[1] { @0192 stack[-1] } 0192 80 DUP1 0193 63 PUSH4 0x6caede3d 0198 14 EQ 0199 61 PUSH2 0x04f0 019C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f0, if 0x6caede3d == stack[-1] label_019D: // Incoming jump from 0x019C, if not 0x6caede3d == stack[-1] // Inputs[1] { @01A0 memory[0x00:0x00] } 019D 60 PUSH1 0x00 019F 80 DUP1 01A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @01A0 revert(memory[0x00:0x00]); } // Block terminates label_01A1: // Incoming jump from 0x015A, if 0x51830227 > stack[-1] // Inputs[1] { @01A2 stack[-1] } 01A1 5B JUMPDEST 01A2 80 DUP1 01A3 63 PUSH4 0x3ccfd60b 01A8 14 EQ 01A9 61 PUSH2 0x03ca 01AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ca, if 0x3ccfd60b == stack[-1] label_01AD: // Incoming jump from 0x01AC, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @01AD stack[-1] } 01AD 80 DUP1 01AE 63 PUSH4 0x42842e0e 01B3 14 EQ 01B4 61 PUSH2 0x03df 01B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03df, if 0x42842e0e == stack[-1] label_01B8: // Incoming jump from 0x01B7, if not 0x42842e0e == stack[-1] // Inputs[1] { @01B8 stack[-1] } 01B8 80 DUP1 01B9 63 PUSH4 0x438b6300 01BE 14 EQ 01BF 61 PUSH2 0x03ff 01C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ff, if 0x438b6300 == stack[-1] label_01C3: // Incoming jump from 0x01C2, if not 0x438b6300 == stack[-1] // Inputs[1] { @01C3 stack[-1] } 01C3 80 DUP1 01C4 63 PUSH4 0x44a0d68a 01C9 14 EQ 01CA 61 PUSH2 0x042c 01CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x042c, if 0x44a0d68a == stack[-1] label_01CE: // Incoming jump from 0x01CD, if not 0x44a0d68a == stack[-1] // Inputs[1] { @01CE stack[-1] } 01CE 80 DUP1 01CF 63 PUSH4 0x4fdd43cb 01D4 14 EQ 01D5 61 PUSH2 0x044c 01D8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x044c, if 0x4fdd43cb == stack[-1] label_01D9: // Incoming jump from 0x01D8, if not 0x4fdd43cb == stack[-1] // Inputs[1] { @01DC memory[0x00:0x00] } 01D9 60 PUSH1 0x00 01DB 80 DUP1 01DC FD *REVERT // Stack delta = +0 // Outputs[1] { @01DC revert(memory[0x00:0x00]); } // Block terminates label_01DD: // Incoming jump from 0x014F, if 0x3ccfd60b > stack[-1] // Inputs[1] { @01DE stack[-1] } 01DD 5B JUMPDEST 01DE 80 DUP1 01DF 63 PUSH4 0x16ba10e0 01E4 11 GT 01E5 61 PUSH2 0x0224 01E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0224, if 0x16ba10e0 > stack[-1] label_01E9: // Incoming jump from 0x01E8, if not 0x16ba10e0 > stack[-1] // Inputs[1] { @01E9 stack[-1] } 01E9 80 DUP1 01EA 63 PUSH4 0x16ba10e0 01EF 14 EQ 01F0 61 PUSH2 0x0336 01F3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0336, if 0x16ba10e0 == stack[-1] label_01F4: // Incoming jump from 0x01F3, if not 0x16ba10e0 == stack[-1] // Inputs[1] { @01F4 stack[-1] } 01F4 80 DUP1 01F5 63 PUSH4 0x16c38b3c 01FA 14 EQ 01FB 61 PUSH2 0x0356 01FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0356, if 0x16c38b3c == stack[-1] label_01FF: // Incoming jump from 0x01FE, if not 0x16c38b3c == stack[-1] // Inputs[1] { @01FF stack[-1] } 01FF 80 DUP1 0200 63 PUSH4 0x18160ddd 0205 14 EQ 0206 61 PUSH2 0x0376 0209 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0376, if 0x18160ddd == stack[-1] label_020A: // Incoming jump from 0x0209, if not 0x18160ddd == stack[-1] // Inputs[1] { @020A stack[-1] } 020A 80 DUP1 020B 63 PUSH4 0x23b872dd 0210 14 EQ 0211 61 PUSH2 0x0394 0214 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0394, if 0x23b872dd == stack[-1] label_0215: // Incoming jump from 0x0214, if not 0x23b872dd == stack[-1] // Inputs[1] { @0215 stack[-1] } 0215 80 DUP1 0216 63 PUSH4 0x2eb4a7ab 021B 14 EQ 021C 61 PUSH2 0x03b4 021F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b4, if 0x2eb4a7ab == stack[-1] label_0220: // Incoming jump from 0x021F, if not 0x2eb4a7ab == stack[-1] // Inputs[1] { @0223 memory[0x00:0x00] } 0220 60 PUSH1 0x00 0222 80 DUP1 0223 FD *REVERT // Stack delta = +0 // Outputs[1] { @0223 revert(memory[0x00:0x00]); } // Block terminates label_0224: // Incoming jump from 0x01E8, if 0x16ba10e0 > stack[-1] // Inputs[1] { @0225 stack[-1] } 0224 5B JUMPDEST 0225 80 DUP1 0226 63 PUSH4 0x01ffc9a7 022B 14 EQ 022C 61 PUSH2 0x0261 022F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0261, if 0x01ffc9a7 == stack[-1] label_0230: // Incoming jump from 0x022F, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0230 stack[-1] } 0230 80 DUP1 0231 63 PUSH4 0x06fdde03 0236 14 EQ 0237 61 PUSH2 0x0296 023A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0296, if 0x06fdde03 == stack[-1] label_023B: // Incoming jump from 0x023A, if not 0x06fdde03 == stack[-1] // Inputs[1] { @023B stack[-1] } 023B 80 DUP1 023C 63 PUSH4 0x081812fc 0241 14 EQ 0242 61 PUSH2 0x02b8 0245 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b8, if 0x081812fc == stack[-1] label_0246: // Incoming jump from 0x0245, if not 0x081812fc == stack[-1] // Inputs[1] { @0246 stack[-1] } 0246 80 DUP1 0247 63 PUSH4 0x095ea7b3 024C 14 EQ 024D 61 PUSH2 0x02f0 0250 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f0, if 0x095ea7b3 == stack[-1] label_0251: // Incoming jump from 0x0250, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0251 stack[-1] } 0251 80 DUP1 0252 63 PUSH4 0x13faede6 0257 14 EQ 0258 61 PUSH2 0x0312 025B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0312, if 0x13faede6 == stack[-1] label_025C: // Incoming jump from 0x025B, if not 0x13faede6 == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @0260 memory[0x00:0x00] } 025C 5B JUMPDEST 025D 60 PUSH1 0x00 025F 80 DUP1 0260 FD *REVERT // Stack delta = +0 // Outputs[1] { @0260 revert(memory[0x00:0x00]); } // Block terminates label_0261: // Incoming jump from 0x022F, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0262 msg.value } 0261 5B JUMPDEST 0262 34 CALLVALUE 0263 80 DUP1 0264 15 ISZERO 0265 61 PUSH2 0x026d 0268 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0262 stack[0] = msg.value } // Block ends with conditional jump to 0x026d, if !msg.value label_0269: // Incoming jump from 0x0268, if not !msg.value // Inputs[1] { @026C memory[0x00:0x00] } 0269 60 PUSH1 0x00 026B 80 DUP1 026C FD *REVERT // Stack delta = +0 // Outputs[1] { @026C revert(memory[0x00:0x00]); } // Block terminates label_026D: // Incoming jump from 0x0268, if !msg.value // Inputs[1] { @0275 msg.data.length } 026D 5B JUMPDEST 026E 50 POP 026F 61 PUSH2 0x0281 0272 61 PUSH2 0x027c 0275 36 CALLDATASIZE 0276 60 PUSH1 0x04 0278 61 PUSH2 0x203a 027B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @026F stack[-1] = 0x0281 // @0272 stack[0] = 0x027c // @0275 stack[1] = msg.data.length // @0276 stack[2] = 0x04 // } // Block ends with call to 0x203a, returns to 0x027C label_027C: // Incoming return from call to 0x203A at 0x027B 027C 5B JUMPDEST 027D 61 PUSH2 0x07c7 0280 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07c7 label_0281: // Incoming jump from 0x04BA // Incoming return from call to 0x027C at 0x027B // Incoming jump from 0x048B // Incoming return from call to 0x0650 at 0x064F // Incoming jump from 0x050E // Incoming return from call to 0x0709 at 0x0708 // Inputs[2] // { // @0284 memory[0x40:0x60] // @0285 stack[-1] // } 0281 5B JUMPDEST 0282 60 PUSH1 0x40 0284 51 MLOAD 0285 90 SWAP1 0286 15 ISZERO 0287 15 ISZERO 0288 81 DUP2 0289 52 MSTORE 028A 60 PUSH1 0x20 028C 01 ADD // Stack delta = +0 // Outputs[2] // { // @0289 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @028C stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_028D: // Incoming jump from 0x0335 // Incoming return from call to 0x2276 at 0x042B // Incoming jump from 0x02EF // Incoming jump from 0x028C // Inputs[3] // { // @0290 memory[0x40:0x60] // @0292 stack[-1] // @0295 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 028D 5B JUMPDEST 028E 60 PUSH1 0x40 0290 51 MLOAD 0291 80 DUP1 0292 91 SWAP2 0293 03 SUB 0294 90 SWAP1 0295 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0295 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0296: // Incoming jump from 0x023A, if 0x06fdde03 == stack[-1] // Inputs[1] { @0297 msg.value } 0296 5B JUMPDEST 0297 34 CALLVALUE 0298 80 DUP1 0299 15 ISZERO 029A 61 PUSH2 0x02a2 029D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0297 stack[0] = msg.value } // Block ends with conditional jump to 0x02a2, if !msg.value label_029E: // Incoming jump from 0x029D, if not !msg.value // Inputs[1] { @02A1 memory[0x00:0x00] } 029E 60 PUSH1 0x00 02A0 80 DUP1 02A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @02A1 revert(memory[0x00:0x00]); } // Block terminates label_02A2: // Incoming jump from 0x029D, if !msg.value 02A2 5B JUMPDEST 02A3 50 POP 02A4 61 PUSH2 0x02ab 02A7 61 PUSH2 0x0819 02AA 56 *JUMP // Stack delta = +0 // Outputs[1] { @02A4 stack[-1] = 0x02ab } // Block ends with call to 0x0819, returns to 0x02AB label_02AB: // Incoming return from call to 0x0819 at 0x02AA // Incoming return from call to 0x0E75 at 0x05CC // Incoming return from call to 0x06C0 at 0x06BF // Incoming return from call to 0x10BD at 0x0614 // Incoming return from call to 0x0CD8 at 0x04A0 // Incoming return from call to 0x0D66 at 0x04CF // Inputs[2] // { // @02AE memory[0x40:0x60] // @02B2 stack[-1] // } 02AB 5B JUMPDEST 02AC 60 PUSH1 0x40 02AE 51 MLOAD 02AF 61 PUSH2 0x028d 02B2 91 SWAP2 02B3 90 SWAP1 02B4 61 PUSH2 0x20af 02B7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02B2 stack[-1] = 0x028d // @02B3 stack[1] = memory[0x40:0x60] // @02B3 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x20af label_02B8: // Incoming jump from 0x0245, if 0x081812fc == stack[-1] // Inputs[1] { @02B9 msg.value } 02B8 5B JUMPDEST 02B9 34 CALLVALUE 02BA 80 DUP1 02BB 15 ISZERO 02BC 61 PUSH2 0x02c4 02BF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02B9 stack[0] = msg.value } // Block ends with conditional jump to 0x02c4, if !msg.value label_02C0: // Incoming jump from 0x02BF, if not !msg.value // Inputs[1] { @02C3 memory[0x00:0x00] } 02C0 60 PUSH1 0x00 02C2 80 DUP1 02C3 FD *REVERT // Stack delta = +0 // Outputs[1] { @02C3 revert(memory[0x00:0x00]); } // Block terminates label_02C4: // Incoming jump from 0x02BF, if !msg.value // Inputs[1] { @02CC msg.data.length } 02C4 5B JUMPDEST 02C5 50 POP 02C6 61 PUSH2 0x02d8 02C9 61 PUSH2 0x02d3 02CC 36 CALLDATASIZE 02CD 60 PUSH1 0x04 02CF 61 PUSH2 0x20c2 02D2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02C6 stack[-1] = 0x02d8 // @02C9 stack[0] = 0x02d3 // @02CC stack[1] = msg.data.length // @02CD stack[2] = 0x04 // } // Block ends with call to 0x20c2, returns to 0x02D3 label_02D3: // Incoming return from call to 0x20C2 at 0x02D2 02D3 5B JUMPDEST 02D4 61 PUSH2 0x08ab 02D7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08ab label_02D8: // Incoming return from call to 0x02D3 at 0x02D2 // Incoming return from call to 0x04EB at 0x04EA // Incoming jump from 0x05A1 // Inputs[2] // { // @02DB memory[0x40:0x60] // @02E5 stack[-1] // } 02D8 5B JUMPDEST 02D9 60 PUSH1 0x40 02DB 51 MLOAD 02DC 60 PUSH1 0x01 02DE 60 PUSH1 0x01 02E0 60 PUSH1 0xa0 02E2 1B SHL 02E3 03 SUB 02E4 90 SWAP1 02E5 91 SWAP2 02E6 16 AND 02E7 81 DUP2 02E8 52 MSTORE 02E9 60 PUSH1 0x20 02EB 01 ADD 02EC 61 PUSH2 0x028d 02EF 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @02EB stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x028d label_02F0: // Incoming jump from 0x0250, if 0x095ea7b3 == stack[-1] // Inputs[1] { @02F1 msg.value } 02F0 5B JUMPDEST 02F1 34 CALLVALUE 02F2 80 DUP1 02F3 15 ISZERO 02F4 61 PUSH2 0x02fc 02F7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F1 stack[0] = msg.value } // Block ends with conditional jump to 0x02fc, if !msg.value label_02F8: // Incoming jump from 0x02F7, if not !msg.value // Inputs[1] { @02FB memory[0x00:0x00] } 02F8 60 PUSH1 0x00 02FA 80 DUP1 02FB FD *REVERT // Stack delta = +0 // Outputs[1] { @02FB revert(memory[0x00:0x00]); } // Block terminates label_02FC: // Incoming jump from 0x02F7, if !msg.value // Inputs[1] { @0304 msg.data.length } 02FC 5B JUMPDEST 02FD 50 POP 02FE 61 PUSH2 0x0310 0301 61 PUSH2 0x030b 0304 36 CALLDATASIZE 0305 60 PUSH1 0x04 0307 61 PUSH2 0x20f7 030A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02FE stack[-1] = 0x0310 // @0301 stack[0] = 0x030b // @0304 stack[1] = msg.data.length // @0305 stack[2] = 0x04 // } // Block ends with call to 0x20f7, returns to 0x030B label_030B: // Incoming return from call to 0x20F7 at 0x030A 030B 5B JUMPDEST 030C 61 PUSH2 0x08ef 030F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08ef label_0310: // Incoming return from call to 0x055F at 0x055E // Incoming return from call to 0x0371 at 0x0370 // Incoming return from call to 0x030B at 0x030A // Incoming return from call to 0x0A0F at 0x03DE // Incoming return from call to 0x06D3 at 0x06D2 // Incoming return from call to 0x0680 at 0x067F // Incoming return from call to 0x0739 at 0x0738 // Incoming return from call to 0x0447 at 0x0446 // Incoming return from call to 0x0DD3 at 0x0543 // Incoming return from call to 0x0630 at 0x062F 0310 5B JUMPDEST 0311 00 *STOP // Stack delta = +0 // Outputs[1] { @0311 stop(); } // Block terminates label_0312: // Incoming jump from 0x025B, if 0x13faede6 == stack[-1] // Inputs[1] { @0313 msg.value } 0312 5B JUMPDEST 0313 34 CALLVALUE 0314 80 DUP1 0315 15 ISZERO 0316 61 PUSH2 0x031e 0319 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0313 stack[0] = msg.value } // Block ends with conditional jump to 0x031e, if !msg.value label_031A: // Incoming jump from 0x0319, if not !msg.value // Inputs[1] { @031D memory[0x00:0x00] } 031A 60 PUSH1 0x00 031C 80 DUP1 031D FD *REVERT // Stack delta = +0 // Outputs[1] { @031D revert(memory[0x00:0x00]); } // Block terminates label_031E: // Incoming jump from 0x0319, if !msg.value // Inputs[1] { @0325 storage[0x10] } 031E 5B JUMPDEST 031F 50 POP 0320 61 PUSH2 0x0328 0323 60 PUSH1 0x10 0325 54 SLOAD 0326 81 DUP2 0327 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0320 stack[-1] = 0x0328 // @0325 stack[0] = storage[0x10] // } // Block ends with unconditional jump to 0x0328 label_0328: // Incoming jump from 0x0393 // Incoming jump from 0x05B7 // Incoming jump from 0x03C9 // Incoming return from call to 0x052A at 0x0529 // Incoming jump from 0x0327 // Incoming jump from 0x06ED // Inputs[2] // { // @032B memory[0x40:0x60] // @032C stack[-1] // } 0328 5B JUMPDEST 0329 60 PUSH1 0x40 032B 51 MLOAD 032C 90 SWAP1 032D 81 DUP2 032E 52 MSTORE 032F 60 PUSH1 0x20 0331 01 ADD 0332 61 PUSH2 0x028d 0335 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @032E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0331 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x028d label_0336: // Incoming jump from 0x01F3, if 0x16ba10e0 == stack[-1] // Inputs[1] { @0337 msg.value } 0336 5B JUMPDEST 0337 34 CALLVALUE 0338 80 DUP1 0339 15 ISZERO 033A 61 PUSH2 0x0342 033D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0337 stack[0] = msg.value } // Block ends with conditional jump to 0x0342, if !msg.value label_033E: // Incoming jump from 0x033D, if not !msg.value // Inputs[1] { @0341 memory[0x00:0x00] } 033E 60 PUSH1 0x00 0340 80 DUP1 0341 FD *REVERT // Stack delta = +0 // Outputs[1] { @0341 revert(memory[0x00:0x00]); } // Block terminates label_0342: // Incoming jump from 0x033D, if !msg.value // Inputs[1] { @034A msg.data.length } 0342 5B JUMPDEST 0343 50 POP 0344 61 PUSH2 0x0310 0347 61 PUSH2 0x0351 034A 36 CALLDATASIZE 034B 60 PUSH1 0x04 034D 61 PUSH2 0x21ac 0350 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0344 stack[-1] = 0x0310 // @0347 stack[0] = 0x0351 // @034A stack[1] = msg.data.length // @034B stack[2] = 0x04 // } // Block ends with call to 0x21ac, returns to 0x0351 label_0351: // Incoming return from call to 0x21AC at 0x0350 0351 5B JUMPDEST 0352 61 PUSH2 0x097d 0355 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x097d label_0356: // Incoming jump from 0x01FE, if 0x16c38b3c == stack[-1] // Inputs[1] { @0357 msg.value } 0356 5B JUMPDEST 0357 34 CALLVALUE 0358 80 DUP1 0359 15 ISZERO 035A 61 PUSH2 0x0362 035D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0357 stack[0] = msg.value } // Block ends with conditional jump to 0x0362, if !msg.value label_035E: // Incoming jump from 0x035D, if not !msg.value // Inputs[1] { @0361 memory[0x00:0x00] } 035E 60 PUSH1 0x00 0360 80 DUP1 0361 FD *REVERT // Stack delta = +0 // Outputs[1] { @0361 revert(memory[0x00:0x00]); } // Block terminates label_0362: // Incoming jump from 0x035D, if !msg.value // Inputs[1] { @036A msg.data.length } 0362 5B JUMPDEST 0363 50 POP 0364 61 PUSH2 0x0310 0367 61 PUSH2 0x0371 036A 36 CALLDATASIZE 036B 60 PUSH1 0x04 036D 61 PUSH2 0x2204 0370 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0364 stack[-1] = 0x0310 // @0367 stack[0] = 0x0371 // @036A stack[1] = msg.data.length // @036B stack[2] = 0x04 // } // Block ends with call to 0x2204, returns to 0x0371 label_0371: // Incoming return from call to 0x2204 at 0x0370 0371 5B JUMPDEST 0372 61 PUSH2 0x09c7 0375 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09c7 label_0376: // Incoming jump from 0x0209, if 0x18160ddd == stack[-1] // Inputs[1] { @0377 msg.value } 0376 5B JUMPDEST 0377 34 CALLVALUE 0378 80 DUP1 0379 15 ISZERO 037A 61 PUSH2 0x0382 037D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0377 stack[0] = msg.value } // Block ends with conditional jump to 0x0382, if !msg.value label_037E: // Incoming jump from 0x037D, if not !msg.value // Inputs[1] { @0381 memory[0x00:0x00] } 037E 60 PUSH1 0x00 0380 80 DUP1 0381 FD *REVERT // Stack delta = +0 // Outputs[1] { @0381 revert(memory[0x00:0x00]); } // Block terminates label_0382: // Incoming jump from 0x037D, if !msg.value // Inputs[2] // { // @0389 storage[0x01] // @038C storage[0x00] // } 0382 5B JUMPDEST 0383 50 POP 0384 61 PUSH2 0x0328 0387 60 PUSH1 0x01 0389 54 SLOAD 038A 60 PUSH1 0x00 038C 54 SLOAD 038D 03 SUB 038E 60 PUSH1 0x00 0390 19 NOT 0391 01 ADD 0392 90 SWAP1 0393 56 *JUMP // Stack delta = +0 // Outputs[1] { @0392 stack[-1] = ~0x00 + (storage[0x00] - storage[0x01]) } // Block ends with unconditional jump to 0x0328 label_0394: // Incoming jump from 0x0214, if 0x23b872dd == stack[-1] // Inputs[1] { @0395 msg.value } 0394 5B JUMPDEST 0395 34 CALLVALUE 0396 80 DUP1 0397 15 ISZERO 0398 61 PUSH2 0x03a0 039B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0395 stack[0] = msg.value } // Block ends with conditional jump to 0x03a0, if !msg.value label_039C: // Incoming jump from 0x039B, if not !msg.value // Inputs[1] { @039F memory[0x00:0x00] } 039C 60 PUSH1 0x00 039E 80 DUP1 039F FD *REVERT // Stack delta = +0 // Outputs[1] { @039F revert(memory[0x00:0x00]); } // Block terminates label_03A0: // Incoming jump from 0x039B, if !msg.value // Inputs[1] { @03A8 msg.data.length } 03A0 5B JUMPDEST 03A1 50 POP 03A2 61 PUSH2 0x0310 03A5 61 PUSH2 0x03af 03A8 36 CALLDATASIZE 03A9 60 PUSH1 0x04 03AB 61 PUSH2 0x221f 03AE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03A2 stack[-1] = 0x0310 // @03A5 stack[0] = 0x03af // @03A8 stack[1] = msg.data.length // @03A9 stack[2] = 0x04 // } // Block ends with call to 0x221f, returns to 0x03AF label_03AF: // Incoming return from call to 0x221F at 0x03AE 03AF 5B JUMPDEST 03B0 61 PUSH2 0x0a04 03B3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a04 label_03B4: // Incoming jump from 0x021F, if 0x2eb4a7ab == stack[-1] // Inputs[1] { @03B5 msg.value } 03B4 5B JUMPDEST 03B5 34 CALLVALUE 03B6 80 DUP1 03B7 15 ISZERO 03B8 61 PUSH2 0x03c0 03BB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03B5 stack[0] = msg.value } // Block ends with conditional jump to 0x03c0, if !msg.value label_03BC: // Incoming jump from 0x03BB, if not !msg.value // Inputs[1] { @03BF memory[0x00:0x00] } 03BC 60 PUSH1 0x00 03BE 80 DUP1 03BF FD *REVERT // Stack delta = +0 // Outputs[1] { @03BF revert(memory[0x00:0x00]); } // Block terminates label_03C0: // Incoming jump from 0x03BB, if !msg.value // Inputs[1] { @03C7 storage[0x0a] } 03C0 5B JUMPDEST 03C1 50 POP 03C2 61 PUSH2 0x0328 03C5 60 PUSH1 0x0a 03C7 54 SLOAD 03C8 81 DUP2 03C9 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03C2 stack[-1] = 0x0328 // @03C7 stack[0] = storage[0x0a] // } // Block ends with unconditional jump to 0x0328 label_03CA: // Incoming jump from 0x01AC, if 0x3ccfd60b == stack[-1] // Inputs[1] { @03CB msg.value } 03CA 5B JUMPDEST 03CB 34 CALLVALUE 03CC 80 DUP1 03CD 15 ISZERO 03CE 61 PUSH2 0x03d6 03D1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03CB stack[0] = msg.value } // Block ends with conditional jump to 0x03d6, if !msg.value label_03D2: // Incoming jump from 0x03D1, if not !msg.value // Inputs[1] { @03D5 memory[0x00:0x00] } 03D2 60 PUSH1 0x00 03D4 80 DUP1 03D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D5 revert(memory[0x00:0x00]); } // Block terminates label_03D6: // Incoming jump from 0x03D1, if !msg.value 03D6 5B JUMPDEST 03D7 50 POP 03D8 61 PUSH2 0x0310 03DB 61 PUSH2 0x0a0f 03DE 56 *JUMP // Stack delta = +0 // Outputs[1] { @03D8 stack[-1] = 0x0310 } // Block ends with call to 0x0a0f, returns to 0x0310 label_03DF: // Incoming jump from 0x01B7, if 0x42842e0e == stack[-1] // Inputs[1] { @03E0 msg.value } 03DF 5B JUMPDEST 03E0 34 CALLVALUE 03E1 80 DUP1 03E2 15 ISZERO 03E3 61 PUSH2 0x03eb 03E6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E0 stack[0] = msg.value } // Block ends with conditional jump to 0x03eb, if !msg.value label_03E7: // Incoming jump from 0x03E6, if not !msg.value // Inputs[1] { @03EA memory[0x00:0x00] } 03E7 60 PUSH1 0x00 03E9 80 DUP1 03EA FD *REVERT // Stack delta = +0 // Outputs[1] { @03EA revert(memory[0x00:0x00]); } // Block terminates label_03EB: // Incoming jump from 0x03E6, if !msg.value // Inputs[1] { @03F3 msg.data.length } 03EB 5B JUMPDEST 03EC 50 POP 03ED 61 PUSH2 0x0310 03F0 61 PUSH2 0x03fa 03F3 36 CALLDATASIZE 03F4 60 PUSH1 0x04 03F6 61 PUSH2 0x221f 03F9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03ED stack[-1] = 0x0310 // @03F0 stack[0] = 0x03fa // @03F3 stack[1] = msg.data.length // @03F4 stack[2] = 0x04 // } // Block ends with call to 0x221f, returns to 0x03FA label_03FA: // Incoming return from call to 0x221F at 0x03F9 03FA 5B JUMPDEST 03FB 61 PUSH2 0x0b0a 03FE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b0a label_03FF: // Incoming jump from 0x01C2, if 0x438b6300 == stack[-1] // Inputs[1] { @0400 msg.value } 03FF 5B JUMPDEST 0400 34 CALLVALUE 0401 80 DUP1 0402 15 ISZERO 0403 61 PUSH2 0x040b 0406 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0400 stack[0] = msg.value } // Block ends with conditional jump to 0x040b, if !msg.value label_0407: // Incoming jump from 0x0406, if not !msg.value // Inputs[1] { @040A memory[0x00:0x00] } 0407 60 PUSH1 0x00 0409 80 DUP1 040A FD *REVERT // Stack delta = +0 // Outputs[1] { @040A revert(memory[0x00:0x00]); } // Block terminates label_040B: // Incoming jump from 0x0406, if !msg.value // Inputs[1] { @0413 msg.data.length } 040B 5B JUMPDEST 040C 50 POP 040D 61 PUSH2 0x041f 0410 61 PUSH2 0x041a 0413 36 CALLDATASIZE 0414 60 PUSH1 0x04 0416 61 PUSH2 0x225b 0419 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @040D stack[-1] = 0x041f // @0410 stack[0] = 0x041a // @0413 stack[1] = msg.data.length // @0414 stack[2] = 0x04 // } // Block ends with call to 0x225b, returns to 0x041A label_041A: // Incoming return from call to 0x225B at 0x0419 041A 5B JUMPDEST 041B 61 PUSH2 0x0b25 041E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b25 label_041F: // Incoming return from call to 0x041A at 0x0419 // Inputs[2] // { // @0422 memory[0x40:0x60] // @0426 stack[-1] // } 041F 5B JUMPDEST 0420 60 PUSH1 0x40 0422 51 MLOAD 0423 61 PUSH2 0x028d 0426 91 SWAP2 0427 90 SWAP1 0428 61 PUSH2 0x2276 042B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0426 stack[-1] = 0x028d // @0427 stack[1] = memory[0x40:0x60] // @0427 stack[0] = stack[-1] // } // Block ends with call to 0x2276, returns to 0x028D label_042C: // Incoming jump from 0x01CD, if 0x44a0d68a == stack[-1] // Inputs[1] { @042D msg.value } 042C 5B JUMPDEST 042D 34 CALLVALUE 042E 80 DUP1 042F 15 ISZERO 0430 61 PUSH2 0x0438 0433 57 *JUMPI // Stack delta = +1 // Outputs[1] { @042D stack[0] = msg.value } // Block ends with conditional jump to 0x0438, if !msg.value label_0434: // Incoming jump from 0x0433, if not !msg.value // Inputs[1] { @0437 memory[0x00:0x00] } 0434 60 PUSH1 0x00 0436 80 DUP1 0437 FD *REVERT // Stack delta = +0 // Outputs[1] { @0437 revert(memory[0x00:0x00]); } // Block terminates label_0438: // Incoming jump from 0x0433, if !msg.value // Inputs[1] { @0440 msg.data.length } 0438 5B JUMPDEST 0439 50 POP 043A 61 PUSH2 0x0310 043D 61 PUSH2 0x0447 0440 36 CALLDATASIZE 0441 60 PUSH1 0x04 0443 61 PUSH2 0x20c2 0446 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @043A stack[-1] = 0x0310 // @043D stack[0] = 0x0447 // @0440 stack[1] = msg.data.length // @0441 stack[2] = 0x04 // } // Block ends with call to 0x20c2, returns to 0x0447 label_0447: // Incoming return from call to 0x20C2 at 0x0446 0447 5B JUMPDEST 0448 61 PUSH2 0x0c6c 044B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c6c label_044C: // Incoming jump from 0x01D8, if 0x4fdd43cb == stack[-1] // Inputs[1] { @044D msg.value } 044C 5B JUMPDEST 044D 34 CALLVALUE 044E 80 DUP1 044F 15 ISZERO 0450 61 PUSH2 0x0458 0453 57 *JUMPI // Stack delta = +1 // Outputs[1] { @044D stack[0] = msg.value } // Block ends with conditional jump to 0x0458, if !msg.value label_0454: // Incoming jump from 0x0453, if not !msg.value // Inputs[1] { @0457 memory[0x00:0x00] } 0454 60 PUSH1 0x00 0456 80 DUP1 0457 FD *REVERT // Stack delta = +0 // Outputs[1] { @0457 revert(memory[0x00:0x00]); } // Block terminates label_0458: // Incoming jump from 0x0453, if !msg.value // Inputs[1] { @0460 msg.data.length } 0458 5B JUMPDEST 0459 50 POP 045A 61 PUSH2 0x0310 045D 61 PUSH2 0x0467 0460 36 CALLDATASIZE 0461 60 PUSH1 0x04 0463 61 PUSH2 0x21ac 0466 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @045A stack[-1] = 0x0310 // @045D stack[0] = 0x0467 // @0460 stack[1] = msg.data.length // @0461 stack[2] = 0x04 // } // Block ends with call to 0x21ac, returns to 0x0467 label_0467: // Incoming return from call to 0x21AC at 0x0466 0467 5B JUMPDEST 0468 61 PUSH2 0x0c9b 046B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c9b label_046C: // Incoming jump from 0x0165, if 0x51830227 == stack[-1] // Inputs[1] { @046D msg.value } 046C 5B JUMPDEST 046D 34 CALLVALUE 046E 80 DUP1 046F 15 ISZERO 0470 61 PUSH2 0x0478 0473 57 *JUMPI // Stack delta = +1 // Outputs[1] { @046D stack[0] = msg.value } // Block ends with conditional jump to 0x0478, if !msg.value label_0474: // Incoming jump from 0x0473, if not !msg.value // Inputs[1] { @0477 memory[0x00:0x00] } 0474 60 PUSH1 0x00 0476 80 DUP1 0477 FD *REVERT // Stack delta = +0 // Outputs[1] { @0477 revert(memory[0x00:0x00]); } // Block terminates label_0478: // Incoming jump from 0x0473, if !msg.value // Inputs[1] { @047C storage[0x13] } 0478 5B JUMPDEST 0479 50 POP 047A 60 PUSH1 0x13 047C 54 SLOAD 047D 61 PUSH2 0x0281 0480 90 SWAP1 0481 62 PUSH3 0x010000 0485 90 SWAP1 0486 04 DIV 0487 60 PUSH1 0xff 0489 16 AND 048A 81 DUP2 048B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0480 stack[-1] = 0x0281 // @0489 stack[0] = 0xff & storage[0x13] / 0x010000 // } // Block ends with unconditional jump to 0x0281 label_048C: // Incoming jump from 0x0170, if 0x5503a0e8 == stack[-1] // Inputs[1] { @048D msg.value } 048C 5B JUMPDEST 048D 34 CALLVALUE 048E 80 DUP1 048F 15 ISZERO 0490 61 PUSH2 0x0498 0493 57 *JUMPI // Stack delta = +1 // Outputs[1] { @048D stack[0] = msg.value } // Block ends with conditional jump to 0x0498, if !msg.value label_0494: // Incoming jump from 0x0493, if not !msg.value // Inputs[1] { @0497 memory[0x00:0x00] } 0494 60 PUSH1 0x00 0496 80 DUP1 0497 FD *REVERT // Stack delta = +0 // Outputs[1] { @0497 revert(memory[0x00:0x00]); } // Block terminates label_0498: // Incoming jump from 0x0493, if !msg.value 0498 5B JUMPDEST 0499 50 POP 049A 61 PUSH2 0x02ab 049D 61 PUSH2 0x0cd8 04A0 56 *JUMP // Stack delta = +0 // Outputs[1] { @049A stack[-1] = 0x02ab } // Block ends with call to 0x0cd8, returns to 0x02AB label_04A1: // Incoming jump from 0x017B, if 0x5c975abb == stack[-1] // Inputs[1] { @04A2 msg.value } 04A1 5B JUMPDEST 04A2 34 CALLVALUE 04A3 80 DUP1 04A4 15 ISZERO 04A5 61 PUSH2 0x04ad 04A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04A2 stack[0] = msg.value } // Block ends with conditional jump to 0x04ad, if !msg.value label_04A9: // Incoming jump from 0x04A8, if not !msg.value // Inputs[1] { @04AC memory[0x00:0x00] } 04A9 60 PUSH1 0x00 04AB 80 DUP1 04AC FD *REVERT // Stack delta = +0 // Outputs[1] { @04AC revert(memory[0x00:0x00]); } // Block terminates label_04AD: // Incoming jump from 0x04A8, if !msg.value // Inputs[1] { @04B1 storage[0x13] } 04AD 5B JUMPDEST 04AE 50 POP 04AF 60 PUSH1 0x13 04B1 54 SLOAD 04B2 61 PUSH2 0x0281 04B5 90 SWAP1 04B6 60 PUSH1 0xff 04B8 16 AND 04B9 81 DUP2 04BA 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04B5 stack[-1] = 0x0281 // @04B8 stack[0] = 0xff & storage[0x13] // } // Block ends with unconditional jump to 0x0281 label_04BB: // Incoming jump from 0x0186, if 0x62b99ad4 == stack[-1] // Inputs[1] { @04BC msg.value } 04BB 5B JUMPDEST 04BC 34 CALLVALUE 04BD 80 DUP1 04BE 15 ISZERO 04BF 61 PUSH2 0x04c7 04C2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04BC stack[0] = msg.value } // Block ends with conditional jump to 0x04c7, if !msg.value label_04C3: // Incoming jump from 0x04C2, if not !msg.value // Inputs[1] { @04C6 memory[0x00:0x00] } 04C3 60 PUSH1 0x00 04C5 80 DUP1 04C6 FD *REVERT // Stack delta = +0 // Outputs[1] { @04C6 revert(memory[0x00:0x00]); } // Block terminates label_04C7: // Incoming jump from 0x04C2, if !msg.value 04C7 5B JUMPDEST 04C8 50 POP 04C9 61 PUSH2 0x02ab 04CC 61 PUSH2 0x0d66 04CF 56 *JUMP // Stack delta = +0 // Outputs[1] { @04C9 stack[-1] = 0x02ab } // Block ends with call to 0x0d66, returns to 0x02AB label_04D0: // Incoming jump from 0x0191, if 0x6352211e == stack[-1] // Inputs[1] { @04D1 msg.value } 04D0 5B JUMPDEST 04D1 34 CALLVALUE 04D2 80 DUP1 04D3 15 ISZERO 04D4 61 PUSH2 0x04dc 04D7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D1 stack[0] = msg.value } // Block ends with conditional jump to 0x04dc, if !msg.value label_04D8: // Incoming jump from 0x04D7, if not !msg.value // Inputs[1] { @04DB memory[0x00:0x00] } 04D8 60 PUSH1 0x00 04DA 80 DUP1 04DB FD *REVERT // Stack delta = +0 // Outputs[1] { @04DB revert(memory[0x00:0x00]); } // Block terminates label_04DC: // Incoming jump from 0x04D7, if !msg.value // Inputs[1] { @04E4 msg.data.length } 04DC 5B JUMPDEST 04DD 50 POP 04DE 61 PUSH2 0x02d8 04E1 61 PUSH2 0x04eb 04E4 36 CALLDATASIZE 04E5 60 PUSH1 0x04 04E7 61 PUSH2 0x20c2 04EA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04DE stack[-1] = 0x02d8 // @04E1 stack[0] = 0x04eb // @04E4 stack[1] = msg.data.length // @04E5 stack[2] = 0x04 // } // Block ends with call to 0x20c2, returns to 0x04EB label_04EB: // Incoming return from call to 0x20C2 at 0x04EA 04EB 5B JUMPDEST 04EC 61 PUSH2 0x0d73 04EF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d73 label_04F0: // Incoming jump from 0x019C, if 0x6caede3d == stack[-1] // Inputs[1] { @04F1 msg.value } 04F0 5B JUMPDEST 04F1 34 CALLVALUE 04F2 80 DUP1 04F3 15 ISZERO 04F4 61 PUSH2 0x04fc 04F7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04F1 stack[0] = msg.value } // Block ends with conditional jump to 0x04fc, if !msg.value label_04F8: // Incoming jump from 0x04F7, if not !msg.value // Inputs[1] { @04FB memory[0x00:0x00] } 04F8 60 PUSH1 0x00 04FA 80 DUP1 04FB FD *REVERT // Stack delta = +0 // Outputs[1] { @04FB revert(memory[0x00:0x00]); } // Block terminates label_04FC: // Incoming jump from 0x04F7, if !msg.value // Inputs[1] { @0500 storage[0x13] } 04FC 5B JUMPDEST 04FD 50 POP 04FE 60 PUSH1 0x13 0500 54 SLOAD 0501 61 PUSH2 0x0281 0504 90 SWAP1 0505 61 PUSH2 0x0100 0508 90 SWAP1 0509 04 DIV 050A 60 PUSH1 0xff 050C 16 AND 050D 81 DUP2 050E 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0504 stack[-1] = 0x0281 // @050C stack[0] = 0xff & storage[0x13] / 0x0100 // } // Block ends with unconditional jump to 0x0281 label_050F: // Incoming jump from 0x0113, if 0x70a08231 == stack[-1] // Inputs[1] { @0510 msg.value } 050F 5B JUMPDEST 0510 34 CALLVALUE 0511 80 DUP1 0512 15 ISZERO 0513 61 PUSH2 0x051b 0516 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0510 stack[0] = msg.value } // Block ends with conditional jump to 0x051b, if !msg.value label_0517: // Incoming jump from 0x0516, if not !msg.value // Inputs[1] { @051A memory[0x00:0x00] } 0517 60 PUSH1 0x00 0519 80 DUP1 051A FD *REVERT // Stack delta = +0 // Outputs[1] { @051A revert(memory[0x00:0x00]); } // Block terminates label_051B: // Incoming jump from 0x0516, if !msg.value // Inputs[1] { @0523 msg.data.length } 051B 5B JUMPDEST 051C 50 POP 051D 61 PUSH2 0x0328 0520 61 PUSH2 0x052a 0523 36 CALLDATASIZE 0524 60 PUSH1 0x04 0526 61 PUSH2 0x225b 0529 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @051D stack[-1] = 0x0328 // @0520 stack[0] = 0x052a // @0523 stack[1] = msg.data.length // @0524 stack[2] = 0x04 // } // Block ends with call to 0x225b, returns to 0x052A label_052A: // Incoming return from call to 0x225B at 0x0529 052A 5B JUMPDEST 052B 61 PUSH2 0x0d85 052E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d85 label_052F: // Incoming jump from 0x011E, if 0x715018a6 == stack[-1] // Inputs[1] { @0530 msg.value } 052F 5B JUMPDEST 0530 34 CALLVALUE 0531 80 DUP1 0532 15 ISZERO 0533 61 PUSH2 0x053b 0536 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0530 stack[0] = msg.value } // Block ends with conditional jump to 0x053b, if !msg.value label_0537: // Incoming jump from 0x0536, if not !msg.value // Inputs[1] { @053A memory[0x00:0x00] } 0537 60 PUSH1 0x00 0539 80 DUP1 053A FD *REVERT // Stack delta = +0 // Outputs[1] { @053A revert(memory[0x00:0x00]); } // Block terminates label_053B: // Incoming jump from 0x0536, if !msg.value 053B 5B JUMPDEST 053C 50 POP 053D 61 PUSH2 0x0310 0540 61 PUSH2 0x0dd3 0543 56 *JUMP // Stack delta = +0 // Outputs[1] { @053D stack[-1] = 0x0310 } // Block ends with call to 0x0dd3, returns to 0x0310 label_0544: // Incoming jump from 0x0129, if 0x7cb64759 == stack[-1] // Inputs[1] { @0545 msg.value } 0544 5B JUMPDEST 0545 34 CALLVALUE 0546 80 DUP1 0547 15 ISZERO 0548 61 PUSH2 0x0550 054B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0545 stack[0] = msg.value } // Block ends with conditional jump to 0x0550, if !msg.value label_054C: // Incoming jump from 0x054B, if not !msg.value // Inputs[1] { @054F memory[0x00:0x00] } 054C 60 PUSH1 0x00 054E 80 DUP1 054F FD *REVERT // Stack delta = +0 // Outputs[1] { @054F revert(memory[0x00:0x00]); } // Block terminates label_0550: // Incoming jump from 0x054B, if !msg.value // Inputs[1] { @0558 msg.data.length } 0550 5B JUMPDEST 0551 50 POP 0552 61 PUSH2 0x0310 0555 61 PUSH2 0x055f 0558 36 CALLDATASIZE 0559 60 PUSH1 0x04 055B 61 PUSH2 0x20c2 055E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0552 stack[-1] = 0x0310 // @0555 stack[0] = 0x055f // @0558 stack[1] = msg.data.length // @0559 stack[2] = 0x04 // } // Block ends with call to 0x20c2, returns to 0x055F label_055F: // Incoming return from call to 0x20C2 at 0x055E 055F 5B JUMPDEST 0560 61 PUSH2 0x0e09 0563 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e09 label_0564: // Incoming jump from 0x0134, if 0x7ec4a659 == stack[-1] // Inputs[1] { @0565 msg.value } 0564 5B JUMPDEST 0565 34 CALLVALUE 0566 80 DUP1 0567 15 ISZERO 0568 61 PUSH2 0x0570 056B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0565 stack[0] = msg.value } // Block ends with conditional jump to 0x0570, if !msg.value label_056C: // Incoming jump from 0x056B, if not !msg.value // Inputs[1] { @056F memory[0x00:0x00] } 056C 60 PUSH1 0x00 056E 80 DUP1 056F FD *REVERT // Stack delta = +0 // Outputs[1] { @056F revert(memory[0x00:0x00]); } // Block terminates label_0570: // Incoming jump from 0x056B, if !msg.value // Inputs[1] { @0578 msg.data.length } 0570 5B JUMPDEST 0571 50 POP 0572 61 PUSH2 0x0310 0575 61 PUSH2 0x057f 0578 36 CALLDATASIZE 0579 60 PUSH1 0x04 057B 61 PUSH2 0x21ac 057E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0572 stack[-1] = 0x0310 // @0575 stack[0] = 0x057f // @0578 stack[1] = msg.data.length // @0579 stack[2] = 0x04 // } // Block ends with call to 0x21ac, returns to 0x057F label_057F: // Incoming return from call to 0x21AC at 0x057E 057F 5B JUMPDEST 0580 61 PUSH2 0x0e38 0583 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e38 label_0584: // Incoming jump from 0x013F, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0585 msg.value } 0584 5B JUMPDEST 0585 34 CALLVALUE 0586 80 DUP1 0587 15 ISZERO 0588 61 PUSH2 0x0590 058B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0585 stack[0] = msg.value } // Block ends with conditional jump to 0x0590, if !msg.value label_058C: // Incoming jump from 0x058B, if not !msg.value // Inputs[1] { @058F memory[0x00:0x00] } 058C 60 PUSH1 0x00 058E 80 DUP1 058F FD *REVERT // Stack delta = +0 // Outputs[1] { @058F revert(memory[0x00:0x00]); } // Block terminates label_0590: // Incoming jump from 0x058B, if !msg.value // Inputs[1] { @0594 storage[0x08] } 0590 5B JUMPDEST 0591 50 POP 0592 60 PUSH1 0x08 0594 54 SLOAD 0595 60 PUSH1 0x01 0597 60 PUSH1 0x01 0599 60 PUSH1 0xa0 059B 1B SHL 059C 03 SUB 059D 16 AND 059E 61 PUSH2 0x02d8 05A1 56 *JUMP // Stack delta = +0 // Outputs[1] { @059D stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x08] } // Block ends with unconditional jump to 0x02d8 label_05A2: // Incoming jump from 0x00CC, if 0x94354fd0 == stack[-1] // Inputs[1] { @05A3 msg.value } 05A2 5B JUMPDEST 05A3 34 CALLVALUE 05A4 80 DUP1 05A5 15 ISZERO 05A6 61 PUSH2 0x05ae 05A9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05A3 stack[0] = msg.value } // Block ends with conditional jump to 0x05ae, if !msg.value label_05AA: // Incoming jump from 0x05A9, if not !msg.value // Inputs[1] { @05AD memory[0x00:0x00] } 05AA 60 PUSH1 0x00 05AC 80 DUP1 05AD FD *REVERT // Stack delta = +0 // Outputs[1] { @05AD revert(memory[0x00:0x00]); } // Block terminates label_05AE: // Incoming jump from 0x05A9, if !msg.value // Inputs[1] { @05B5 storage[0x12] } 05AE 5B JUMPDEST 05AF 50 POP 05B0 61 PUSH2 0x0328 05B3 60 PUSH1 0x12 05B5 54 SLOAD 05B6 81 DUP2 05B7 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @05B0 stack[-1] = 0x0328 // @05B5 stack[0] = storage[0x12] // } // Block ends with unconditional jump to 0x0328 label_05B8: // Incoming jump from 0x00D7, if 0x95d89b41 == stack[-1] // Inputs[1] { @05B9 msg.value } 05B8 5B JUMPDEST 05B9 34 CALLVALUE 05BA 80 DUP1 05BB 15 ISZERO 05BC 61 PUSH2 0x05c4 05BF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05B9 stack[0] = msg.value } // Block ends with conditional jump to 0x05c4, if !msg.value label_05C0: // Incoming jump from 0x05BF, if not !msg.value // Inputs[1] { @05C3 memory[0x00:0x00] } 05C0 60 PUSH1 0x00 05C2 80 DUP1 05C3 FD *REVERT // Stack delta = +0 // Outputs[1] { @05C3 revert(memory[0x00:0x00]); } // Block terminates label_05C4: // Incoming jump from 0x05BF, if !msg.value 05C4 5B JUMPDEST 05C5 50 POP 05C6 61 PUSH2 0x02ab 05C9 61 PUSH2 0x0e75 05CC 56 *JUMP // Stack delta = +0 // Outputs[1] { @05C6 stack[-1] = 0x02ab } // Block ends with call to 0x0e75, returns to 0x02AB label_05CD: // Incoming jump from 0x00E2, if 0xa0712d68 == stack[-1] // Inputs[1] { @05D4 msg.data.length } 05CD 5B JUMPDEST 05CE 61 PUSH2 0x0310 05D1 61 PUSH2 0x05db 05D4 36 CALLDATASIZE 05D5 60 PUSH1 0x04 05D7 61 PUSH2 0x20c2 05DA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05CE stack[0] = 0x0310 // @05D1 stack[1] = 0x05db // @05D4 stack[2] = msg.data.length // @05D5 stack[3] = 0x04 // } // Block ends with call to 0x20c2, returns to 0x05DB label_05DB: // Incoming return from call to 0x20C2 at 0x05DA 05DB 5B JUMPDEST 05DC 61 PUSH2 0x0e84 05DF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e84 label_05E0: // Incoming jump from 0x00ED, if 0xa22cb465 == stack[-1] // Inputs[1] { @05E1 msg.value } 05E0 5B JUMPDEST 05E1 34 CALLVALUE 05E2 80 DUP1 05E3 15 ISZERO 05E4 61 PUSH2 0x05ec 05E7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05E1 stack[0] = msg.value } // Block ends with conditional jump to 0x05ec, if !msg.value label_05E8: // Incoming jump from 0x05E7, if not !msg.value // Inputs[1] { @05EB memory[0x00:0x00] } 05E8 60 PUSH1 0x00 05EA 80 DUP1 05EB FD *REVERT // Stack delta = +0 // Outputs[1] { @05EB revert(memory[0x00:0x00]); } // Block terminates label_05EC: // Incoming jump from 0x05E7, if !msg.value // Inputs[1] { @05F4 msg.data.length } 05EC 5B JUMPDEST 05ED 50 POP 05EE 61 PUSH2 0x0310 05F1 61 PUSH2 0x05fb 05F4 36 CALLDATASIZE 05F5 60 PUSH1 0x04 05F7 61 PUSH2 0x22ba 05FA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05EE stack[-1] = 0x0310 // @05F1 stack[0] = 0x05fb // @05F4 stack[1] = msg.data.length // @05F5 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x22ba 05FB 5B JUMPDEST 05FC 61 PUSH2 0x1027 05FF 56 *JUMP label_0600: // Incoming jump from 0x00F8, if 0xa45ba8e7 == stack[-1] // Inputs[1] { @0601 msg.value } 0600 5B JUMPDEST 0601 34 CALLVALUE 0602 80 DUP1 0603 15 ISZERO 0604 61 PUSH2 0x060c 0607 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0601 stack[0] = msg.value } // Block ends with conditional jump to 0x060c, if !msg.value label_0608: // Incoming jump from 0x0607, if not !msg.value // Inputs[1] { @060B memory[0x00:0x00] } 0608 60 PUSH1 0x00 060A 80 DUP1 060B FD *REVERT // Stack delta = +0 // Outputs[1] { @060B revert(memory[0x00:0x00]); } // Block terminates label_060C: // Incoming jump from 0x0607, if !msg.value 060C 5B JUMPDEST 060D 50 POP 060E 61 PUSH2 0x02ab 0611 61 PUSH2 0x10bd 0614 56 *JUMP // Stack delta = +0 // Outputs[1] { @060E stack[-1] = 0x02ab } // Block ends with call to 0x10bd, returns to 0x02AB label_0615: // Incoming jump from 0x0103, if 0xb071401b == stack[-1] // Inputs[1] { @0616 msg.value } 0615 5B JUMPDEST 0616 34 CALLVALUE 0617 80 DUP1 0618 15 ISZERO 0619 61 PUSH2 0x0621 061C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0616 stack[0] = msg.value } // Block ends with conditional jump to 0x0621, if !msg.value label_061D: // Incoming jump from 0x061C, if not !msg.value // Inputs[1] { @0620 memory[0x00:0x00] } 061D 60 PUSH1 0x00 061F 80 DUP1 0620 FD *REVERT // Stack delta = +0 // Outputs[1] { @0620 revert(memory[0x00:0x00]); } // Block terminates label_0621: // Incoming jump from 0x061C, if !msg.value // Inputs[1] { @0629 msg.data.length } 0621 5B JUMPDEST 0622 50 POP 0623 61 PUSH2 0x0310 0626 61 PUSH2 0x0630 0629 36 CALLDATASIZE 062A 60 PUSH1 0x04 062C 61 PUSH2 0x20c2 062F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0623 stack[-1] = 0x0310 // @0626 stack[0] = 0x0630 // @0629 stack[1] = msg.data.length // @062A stack[2] = 0x04 // } // Block ends with call to 0x20c2, returns to 0x0630 label_0630: // Incoming return from call to 0x20C2 at 0x062F 0630 5B JUMPDEST 0631 61 PUSH2 0x10ca 0634 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10ca label_0635: // Incoming jump from 0x0085, if 0xb5b1cd7c == stack[-1] // Inputs[1] { @0636 msg.value } 0635 5B JUMPDEST 0636 34 CALLVALUE 0637 80 DUP1 0638 15 ISZERO 0639 61 PUSH2 0x0641 063C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0636 stack[0] = msg.value } // Block ends with conditional jump to 0x0641, if !msg.value label_063D: // Incoming jump from 0x063C, if not !msg.value // Inputs[1] { @0640 memory[0x00:0x00] } 063D 60 PUSH1 0x00 063F 80 DUP1 0640 FD *REVERT // Stack delta = +0 // Outputs[1] { @0640 revert(memory[0x00:0x00]); } // Block terminates label_0641: // Incoming jump from 0x063C, if !msg.value // Inputs[1] { @0649 msg.data.length } 0641 5B JUMPDEST 0642 50 POP 0643 61 PUSH2 0x0281 0646 61 PUSH2 0x0650 0649 36 CALLDATASIZE 064A 60 PUSH1 0x04 064C 61 PUSH2 0x225b 064F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0643 stack[-1] = 0x0281 // @0646 stack[0] = 0x0650 // @0649 stack[1] = msg.data.length // @064A stack[2] = 0x04 // } // Block ends with call to 0x225b, returns to 0x0650 label_0650: // Incoming return from call to 0x225B at 0x064F // Inputs[4] // { // @0658 stack[-1] // @065E memory[0x00:0x40] // @065F storage[keccak256(memory[0x00:0x40])] // @0663 stack[-2] // } 0650 5B JUMPDEST 0651 60 PUSH1 0x0c 0653 60 PUSH1 0x20 0655 52 MSTORE 0656 60 PUSH1 0x00 0658 90 SWAP1 0659 81 DUP2 065A 52 MSTORE 065B 60 PUSH1 0x40 065D 90 SWAP1 065E 20 SHA3 065F 54 SLOAD 0660 60 PUSH1 0xff 0662 16 AND 0663 81 DUP2 0664 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0655 memory[0x20:0x40] = 0x0c // @065A memory[0x00:0x20] = stack[-1] // @0662 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0665: // Incoming jump from 0x0090, if 0xb767a098 == stack[-1] // Inputs[1] { @0666 msg.value } 0665 5B JUMPDEST 0666 34 CALLVALUE 0667 80 DUP1 0668 15 ISZERO 0669 61 PUSH2 0x0671 066C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0666 stack[0] = msg.value } // Block ends with conditional jump to 0x0671, if !msg.value label_066D: // Incoming jump from 0x066C, if not !msg.value // Inputs[1] { @0670 memory[0x00:0x00] } 066D 60 PUSH1 0x00 066F 80 DUP1 0670 FD *REVERT // Stack delta = +0 // Outputs[1] { @0670 revert(memory[0x00:0x00]); } // Block terminates label_0671: // Incoming jump from 0x066C, if !msg.value // Inputs[1] { @0679 msg.data.length } 0671 5B JUMPDEST 0672 50 POP 0673 61 PUSH2 0x0310 0676 61 PUSH2 0x0680 0679 36 CALLDATASIZE 067A 60 PUSH1 0x04 067C 61 PUSH2 0x2204 067F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0673 stack[-1] = 0x0310 // @0676 stack[0] = 0x0680 // @0679 stack[1] = msg.data.length // @067A stack[2] = 0x04 // } // Block ends with call to 0x2204, returns to 0x0680 label_0680: // Incoming return from call to 0x2204 at 0x067F 0680 5B JUMPDEST 0681 61 PUSH2 0x10f9 0684 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10f9 label_0685: // Incoming jump from 0x009B, if 0xb88d4fde == stack[-1] // Inputs[1] { @0686 msg.value } 0685 5B JUMPDEST 0686 34 CALLVALUE 0687 80 DUP1 0688 15 ISZERO 0689 61 PUSH2 0x0691 068C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0686 stack[0] = msg.value } // Block ends with conditional jump to 0x0691, if !msg.value label_068D: // Incoming jump from 0x068C, if not !msg.value // Inputs[1] { @0690 memory[0x00:0x00] } 068D 60 PUSH1 0x00 068F 80 DUP1 0690 FD *REVERT // Stack delta = +0 // Outputs[1] { @0690 revert(memory[0x00:0x00]); } // Block terminates label_0691: // Incoming jump from 0x068C, if !msg.value // Inputs[1] { @0699 msg.data.length } 0691 5B JUMPDEST 0692 50 POP 0693 61 PUSH2 0x0310 0696 61 PUSH2 0x06a0 0699 36 CALLDATASIZE 069A 60 PUSH1 0x04 069C 61 PUSH2 0x22ed 069F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0693 stack[-1] = 0x0310 // @0696 stack[0] = 0x06a0 // @0699 stack[1] = msg.data.length // @069A stack[2] = 0x04 // } // Block ends with call to 0x22ed, returns to 0x06A0 label_06A0: // Incoming return from call to 0x22ED at 0x069F 06A0 5B JUMPDEST 06A1 61 PUSH2 0x113d 06A4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x113d label_06A5: // Incoming jump from 0x00A6, if 0xc87b56dd == stack[-1] // Inputs[1] { @06A6 msg.value } 06A5 5B JUMPDEST 06A6 34 CALLVALUE 06A7 80 DUP1 06A8 15 ISZERO 06A9 61 PUSH2 0x06b1 06AC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06A6 stack[0] = msg.value } // Block ends with conditional jump to 0x06b1, if !msg.value label_06AD: // Incoming jump from 0x06AC, if not !msg.value // Inputs[1] { @06B0 memory[0x00:0x00] } 06AD 60 PUSH1 0x00 06AF 80 DUP1 06B0 FD *REVERT // Stack delta = +0 // Outputs[1] { @06B0 revert(memory[0x00:0x00]); } // Block terminates label_06B1: // Incoming jump from 0x06AC, if !msg.value // Inputs[1] { @06B9 msg.data.length } 06B1 5B JUMPDEST 06B2 50 POP 06B3 61 PUSH2 0x02ab 06B6 61 PUSH2 0x06c0 06B9 36 CALLDATASIZE 06BA 60 PUSH1 0x04 06BC 61 PUSH2 0x20c2 06BF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06B3 stack[-1] = 0x02ab // @06B6 stack[0] = 0x06c0 // @06B9 stack[1] = msg.data.length // @06BA stack[2] = 0x04 // } // Block ends with call to 0x20c2, returns to 0x06C0 label_06C0: // Incoming return from call to 0x20C2 at 0x06BF 06C0 5B JUMPDEST 06C1 61 PUSH2 0x118e 06C4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x118e label_06C5: // Incoming jump from 0x00B1, if 0xd2cab056 == stack[-1] // Inputs[1] { @06CC msg.data.length } 06C5 5B JUMPDEST 06C6 61 PUSH2 0x0310 06C9 61 PUSH2 0x06d3 06CC 36 CALLDATASIZE 06CD 60 PUSH1 0x04 06CF 61 PUSH2 0x2368 06D2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06C6 stack[0] = 0x0310 // @06C9 stack[1] = 0x06d3 // @06CC stack[2] = msg.data.length // @06CD stack[3] = 0x04 // } // Block ends with call to 0x2368, returns to 0x06D3 label_06D3: // Incoming return from call to 0x2368 at 0x06D2 06D3 5B JUMPDEST 06D4 61 PUSH2 0x12fe 06D7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x12fe label_06D8: // Incoming jump from 0x003E, if 0xd5abeb01 == stack[-1] // Inputs[1] { @06D9 msg.value } 06D8 5B JUMPDEST 06D9 34 CALLVALUE 06DA 80 DUP1 06DB 15 ISZERO 06DC 61 PUSH2 0x06e4 06DF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06D9 stack[0] = msg.value } // Block ends with conditional jump to 0x06e4, if !msg.value label_06E0: // Incoming jump from 0x06DF, if not !msg.value // Inputs[1] { @06E3 memory[0x00:0x00] } 06E0 60 PUSH1 0x00 06E2 80 DUP1 06E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @06E3 revert(memory[0x00:0x00]); } // Block terminates label_06E4: // Incoming jump from 0x06DF, if !msg.value // Inputs[1] { @06EB storage[0x11] } 06E4 5B JUMPDEST 06E5 50 POP 06E6 61 PUSH2 0x0328 06E9 60 PUSH1 0x11 06EB 54 SLOAD 06EC 81 DUP2 06ED 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @06E6 stack[-1] = 0x0328 // @06EB stack[0] = storage[0x11] // } // Block ends with unconditional jump to 0x0328 label_06EE: // Incoming jump from 0x0049, if 0xdb4bec44 == stack[-1] // Inputs[1] { @06EF msg.value } 06EE 5B JUMPDEST 06EF 34 CALLVALUE 06F0 80 DUP1 06F1 15 ISZERO 06F2 61 PUSH2 0x06fa 06F5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06EF stack[0] = msg.value } // Block ends with conditional jump to 0x06fa, if !msg.value label_06F6: // Incoming jump from 0x06F5, if not !msg.value // Inputs[1] { @06F9 memory[0x00:0x00] } 06F6 60 PUSH1 0x00 06F8 80 DUP1 06F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @06F9 revert(memory[0x00:0x00]); } // Block terminates label_06FA: // Incoming jump from 0x06F5, if !msg.value // Inputs[1] { @0702 msg.data.length } 06FA 5B JUMPDEST 06FB 50 POP 06FC 61 PUSH2 0x0281 06FF 61 PUSH2 0x0709 0702 36 CALLDATASIZE 0703 60 PUSH1 0x04 0705 61 PUSH2 0x225b 0708 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06FC stack[-1] = 0x0281 // @06FF stack[0] = 0x0709 // @0702 stack[1] = msg.data.length // @0703 stack[2] = 0x04 // } // Block ends with call to 0x225b, returns to 0x0709 label_0709: // Incoming return from call to 0x225B at 0x0708 // Inputs[4] // { // @0711 stack[-1] // @0717 memory[0x00:0x40] // @0718 storage[keccak256(memory[0x00:0x40])] // @071C stack[-2] // } 0709 5B JUMPDEST 070A 60 PUSH1 0x0b 070C 60 PUSH1 0x20 070E 52 MSTORE 070F 60 PUSH1 0x00 0711 90 SWAP1 0712 81 DUP2 0713 52 MSTORE 0714 60 PUSH1 0x40 0716 90 SWAP1 0717 20 SHA3 0718 54 SLOAD 0719 60 PUSH1 0xff 071B 16 AND 071C 81 DUP2 071D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @070E memory[0x20:0x40] = 0x0b // @0713 memory[0x00:0x20] = stack[-1] // @071B stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_071E: // Incoming jump from 0x0054, if 0xe0a80853 == stack[-1] // Inputs[1] { @071F msg.value } 071E 5B JUMPDEST 071F 34 CALLVALUE 0720 80 DUP1 0721 15 ISZERO 0722 61 PUSH2 0x072a 0725 57 *JUMPI // Stack delta = +1 // Outputs[1] { @071F stack[0] = msg.value } // Block ends with conditional jump to 0x072a, if !msg.value label_0726: // Incoming jump from 0x0725, if not !msg.value // Inputs[1] { @0729 memory[0x00:0x00] } 0726 60 PUSH1 0x00 0728 80 DUP1 0729 FD *REVERT // Stack delta = +0 // Outputs[1] { @0729 revert(memory[0x00:0x00]); } // Block terminates label_072A: // Incoming jump from 0x0725, if !msg.value // Inputs[1] { @0732 msg.data.length } 072A 5B JUMPDEST 072B 50 POP 072C 61 PUSH2 0x0310 072F 61 PUSH2 0x0739 0732 36 CALLDATASIZE 0733 60 PUSH1 0x04 0735 61 PUSH2 0x2204 0738 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @072C stack[-1] = 0x0310 // @072F stack[0] = 0x0739 // @0732 stack[1] = msg.data.length // @0733 stack[2] = 0x04 // } // Block ends with call to 0x2204, returns to 0x0739 label_0739: // Incoming return from call to 0x2204 at 0x0738 0739 5B JUMPDEST 073A 61 PUSH2 0x1563 073D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1563 label_073E: // Incoming jump from 0x005F, if 0xe985e9c5 == stack[-1] // Inputs[1] { @073F msg.value } 073E 5B JUMPDEST 073F 34 CALLVALUE 0740 80 DUP1 0741 15 ISZERO 0742 61 PUSH2 0x074a 0745 57 *JUMPI // Stack delta = +1 // Outputs[1] { @073F stack[0] = msg.value } // Block ends with conditional jump to 0x074a, if !msg.value label_0746: // Incoming jump from 0x0745, if not !msg.value // Inputs[1] { @0749 memory[0x00:0x00] } 0746 60 PUSH1 0x00 0748 80 DUP1 0749 FD *REVERT // Stack delta = +0 // Outputs[1] { @0749 revert(memory[0x00:0x00]); } // Block terminates label_074A: // Incoming jump from 0x0745, if !msg.value // Inputs[1] { @0752 msg.data.length } 074A 5B JUMPDEST 074B 50 POP 074C 61 PUSH2 0x0281 074F 61 PUSH2 0x0759 0752 36 CALLDATASIZE 0753 60 PUSH1 0x04 0755 61 PUSH2 0x23e6 0758 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @074C stack[-1] = 0x0281 // @074F stack[0] = 0x0759 // @0752 stack[1] = msg.data.length // @0753 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x23e6 label_0759: // Incoming call from 0x17B1, returns to 0x17B2 // Incoming call from 0x094C, returns to 0x094D // Inputs[6] // { // @0762 stack[-2] // @0775 memory[0x00:0x40] // @0776 stack[-1] // @0780 memory[0x00:0x40] // @0781 storage[keccak256(memory[0x00:0x40])] // @0785 stack[-3] // } 0759 5B JUMPDEST 075A 60 PUSH1 0x01 075C 60 PUSH1 0x01 075E 60 PUSH1 0xa0 0760 1B SHL 0761 03 SUB 0762 91 SWAP2 0763 82 DUP3 0764 16 AND 0765 60 PUSH1 0x00 0767 90 SWAP1 0768 81 DUP2 0769 52 MSTORE 076A 60 PUSH1 0x07 076C 60 PUSH1 0x20 076E 90 SWAP1 076F 81 DUP2 0770 52 MSTORE 0771 60 PUSH1 0x40 0773 80 DUP1 0774 83 DUP4 0775 20 SHA3 0776 93 SWAP4 0777 90 SWAP1 0778 94 SWAP5 0779 16 AND 077A 82 DUP3 077B 52 MSTORE 077C 91 SWAP2 077D 90 SWAP1 077E 91 SWAP2 077F 52 MSTORE 0780 20 SHA3 0781 54 SLOAD 0782 60 PUSH1 0xff 0784 16 AND 0785 90 SWAP1 0786 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0769 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0770 memory[0x20:0x40] = 0x07 // @077B memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @077F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0785 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0787: // Incoming jump from 0x006A, if 0xefbd73f4 == stack[-1] // Inputs[1] { @0788 msg.value } 0787 5B JUMPDEST 0788 34 CALLVALUE 0789 80 DUP1 078A 15 ISZERO 078B 61 PUSH2 0x0793 078E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0788 stack[0] = msg.value } // Block ends with conditional jump to 0x0793, if !msg.value label_078F: // Incoming jump from 0x078E, if not !msg.value // Inputs[1] { @0792 memory[0x00:0x00] } 078F 60 PUSH1 0x00 0791 80 DUP1 0792 FD *REVERT // Stack delta = +0 // Outputs[1] { @0792 revert(memory[0x00:0x00]); } // Block terminates label_0793: // Incoming jump from 0x078E, if !msg.value // Inputs[1] { @079B msg.data.length } 0793 5B JUMPDEST 0794 50 POP 0795 61 PUSH2 0x0310 0798 61 PUSH2 0x07a2 079B 36 CALLDATASIZE 079C 60 PUSH1 0x04 079E 61 PUSH2 0x2410 07A1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0795 stack[-1] = 0x0310 // @0798 stack[0] = 0x07a2 // @079B stack[1] = msg.data.length // @079C stack[2] = 0x04 // } // Block ends with call to 0x2410, returns to 0x07A2 label_07A2: // Incoming return from call to 0x2410 at 0x07A1 07A2 5B JUMPDEST 07A3 61 PUSH2 0x15a9 07A6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x15a9 label_07A7: // Incoming jump from 0x0075, if 0xf2fde38b == stack[-1] // Inputs[1] { @07A8 msg.value } 07A7 5B JUMPDEST 07A8 34 CALLVALUE 07A9 80 DUP1 07AA 15 ISZERO 07AB 61 PUSH2 0x07b3 07AE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07A8 stack[0] = msg.value } // Block ends with conditional jump to 0x07b3, if !msg.value label_07AF: // Incoming jump from 0x07AE, if not !msg.value // Inputs[1] { @07B2 memory[0x00:0x00] } 07AF 60 PUSH1 0x00 07B1 80 DUP1 07B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @07B2 revert(memory[0x00:0x00]); } // Block terminates label_07B3: // Incoming jump from 0x07AE, if !msg.value // Inputs[1] { @07BB msg.data.length } 07B3 5B JUMPDEST 07B4 50 POP 07B5 61 PUSH2 0x0310 07B8 61 PUSH2 0x07c2 07BB 36 CALLDATASIZE 07BC 60 PUSH1 0x04 07BE 61 PUSH2 0x225b 07C1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @07B5 stack[-1] = 0x0310 // @07B8 stack[0] = 0x07c2 // @07BB stack[1] = msg.data.length // @07BC stack[2] = 0x04 // } // Block ends with call to 0x225b, returns to 0x07C2 label_07C2: // Incoming return from call to 0x225B at 0x07C1 07C2 5B JUMPDEST 07C3 61 PUSH2 0x1649 07C6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1649 label_07C7: // Incoming jump from 0x0280 // Inputs[1] { @07D3 stack[-1] } 07C7 5B JUMPDEST 07C8 60 PUSH1 0x00 07CA 60 PUSH1 0x01 07CC 60 PUSH1 0x01 07CE 60 PUSH1 0xe0 07D0 1B SHL 07D1 03 SUB 07D2 19 NOT 07D3 82 DUP3 07D4 16 AND 07D5 63 PUSH4 0x80ac58cd 07DA 60 PUSH1 0xe0 07DC 1B SHL 07DD 14 EQ 07DE 80 DUP1 07DF 61 PUSH2 0x07f8 07E2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @07C8 stack[0] = 0x00 // @07DD stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x07f8, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_07E3: // Incoming jump from 0x07E2, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @07ED stack[-3] } 07E3 50 POP 07E4 60 PUSH1 0x01 07E6 60 PUSH1 0x01 07E8 60 PUSH1 0xe0 07EA 1B SHL 07EB 03 SUB 07EC 19 NOT 07ED 82 DUP3 07EE 16 AND 07EF 63 PUSH4 0x5b5e139f 07F4 60 PUSH1 0xe0 07F6 1B SHL 07F7 14 EQ 07F8 5B JUMPDEST 07F9 80 DUP1 07FA 61 PUSH2 0x0813 07FD 57 *JUMPI // Stack delta = +0 // Outputs[1] { @07F7 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0813, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_07FE: // Incoming jump from 0x07FD, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x07FD, if not stack[-1] // Inputs[1] { @0810 stack[-3] } 07FE 50 POP 07FF 63 PUSH4 0x01ffc9a7 0804 60 PUSH1 0xe0 0806 1B SHL 0807 60 PUSH1 0x01 0809 60 PUSH1 0x01 080B 60 PUSH1 0xe0 080D 1B SHL 080E 03 SUB 080F 19 NOT 0810 83 DUP4 0811 16 AND 0812 14 EQ // Stack delta = +0 // Outputs[1] { @0812 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block continues label_0813: // Incoming jump from 0x16FE, if !(stack[-3] < storage[0x00]) // Incoming jump from 0x16FE, if !stack[-1] // Incoming jump from 0x07FD, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x0812 // Incoming jump from 0x07FD, if stack[-1] // Inputs[3] // { // @0814 stack[-1] // @0814 stack[-4] // @0815 stack[-3] // } 0813 5B JUMPDEST 0814 92 SWAP3 0815 91 SWAP2 0816 50 POP 0817 50 POP 0818 56 *JUMP // Stack delta = -3 // Outputs[1] { @0814 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0819: // Incoming call from 0x02AA, returns to 0x02AB // Inputs[1] { @081F storage[0x02] } 0819 5B JUMPDEST 081A 60 PUSH1 0x60 081C 60 PUSH1 0x02 081E 80 DUP1 081F 54 SLOAD 0820 61 PUSH2 0x0828 0823 90 SWAP1 0824 61 PUSH2 0x2433 0827 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @081A stack[0] = 0x60 // @081C stack[1] = 0x02 // @0823 stack[2] = 0x0828 // @0823 stack[3] = storage[0x02] // } // Block ends with call to 0x2433, returns to 0x0828 label_0828: // Incoming return from call to 0x2433 at 0x0827 // Incoming return from call to 0x2433 at 0x1C26 // Incoming return from call to 0x2433 at 0x0E83 // Inputs[4] // { // @0829 stack[-1] // @0838 memory[0x40:0x60] // @0840 stack[-2] // @084B storage[stack[-2]] // } 0828 5B JUMPDEST 0829 80 DUP1 082A 60 PUSH1 0x1f 082C 01 ADD 082D 60 PUSH1 0x20 082F 80 DUP1 0830 91 SWAP2 0831 04 DIV 0832 02 MUL 0833 60 PUSH1 0x20 0835 01 ADD 0836 60 PUSH1 0x40 0838 51 MLOAD 0839 90 SWAP1 083A 81 DUP2 083B 01 ADD 083C 60 PUSH1 0x40 083E 52 MSTORE 083F 80 DUP1 0840 92 SWAP3 0841 91 SWAP2 0842 90 SWAP1 0843 81 DUP2 0844 81 DUP2 0845 52 MSTORE 0846 60 PUSH1 0x20 0848 01 ADD 0849 82 DUP3 084A 80 DUP1 084B 54 SLOAD 084C 61 PUSH2 0x0854 084F 90 SWAP1 0850 61 PUSH2 0x2433 0853 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @083E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0840 stack[-2] = memory[0x40:0x60] // @0841 stack[-1] = stack[-2] // @0842 stack[0] = stack[-1] // @0845 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0848 stack[1] = 0x20 + memory[0x40:0x60] // @0849 stack[2] = stack[-2] // @084F stack[4] = storage[stack[-2]] // @084F stack[3] = 0x0854 // } // Block ends with call to 0x2433, returns to 0x0854 label_0854: // Incoming return from call to 0x2433 at 0x0853 // Inputs[1] { @0855 stack[-1] } 0854 5B JUMPDEST 0855 80 DUP1 0856 15 ISZERO 0857 61 PUSH2 0x08a1 085A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08a1, if !stack[-1] label_085B: // Incoming jump from 0x085A, if not !stack[-1] // Inputs[1] { @085B stack[-1] } 085B 80 DUP1 085C 60 PUSH1 0x1f 085E 10 LT 085F 61 PUSH2 0x0876 0862 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0876, if 0x1f < stack[-1] label_0863: // Incoming jump from 0x0862, if not 0x1f < stack[-1] // Inputs[4] // { // @0867 stack[-2] // @0868 storage[stack[-2]] // @086B stack[-3] // @086D stack[-1] // } 0863 61 PUSH2 0x0100 0866 80 DUP1 0867 83 DUP4 0868 54 SLOAD 0869 04 DIV 086A 02 MUL 086B 83 DUP4 086C 52 MSTORE 086D 91 SWAP2 086E 60 PUSH1 0x20 0870 01 ADD 0871 91 SWAP2 0872 61 PUSH2 0x08a1 0875 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @086C memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0871 stack[-1] = stack[-1] // @0871 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x08a1 label_0876: // Incoming jump from 0x0862, if 0x1f < stack[-1] // Inputs[5] // { // @0877 stack[-3] // @0878 stack[-1] // @087A stack[-2] // @0882 memory[0x00:0x20] // @0886 storage[keccak256(memory[0x00:0x20])] // } 0876 5B JUMPDEST 0877 82 DUP3 0878 01 ADD 0879 91 SWAP2 087A 90 SWAP1 087B 60 PUSH1 0x00 087D 52 MSTORE 087E 60 PUSH1 0x20 0880 60 PUSH1 0x00 0882 20 SHA3 0883 90 SWAP1 0884 5B JUMPDEST 0885 81 DUP2 0886 54 SLOAD 0887 81 DUP2 0888 52 MSTORE 0889 90 SWAP1 088A 60 PUSH1 0x01 088C 01 ADD 088D 90 SWAP1 088E 60 PUSH1 0x20 0890 01 ADD 0891 80 DUP1 0892 83 DUP4 0893 11 GT 0894 61 PUSH2 0x0884 0897 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0879 stack[-3] = stack[-3] + stack[-1] // @087D memory[0x00:0x20] = stack[-2] // @0888 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @088D stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0890 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0884, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0898: // Incoming jump from 0x0897, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0897, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0898 stack[-3] // @0899 stack[-1] // } 0898 82 DUP3 0899 90 SWAP1 089A 03 SUB 089B 60 PUSH1 0x1f 089D 16 AND 089E 82 DUP3 089F 01 ADD 08A0 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @08A0 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @08A0 stack[-1] = stack[-3] // } // Block continues label_08A1: // Incoming jump from 0x085A, if !stack[-1] // Incoming jump from 0x0875 // Incoming jump from 0x08A0 // Inputs[3] // { // @08A7 stack[-7] // @08A7 stack[-6] // @08A9 stack[-8] // } 08A1 5B JUMPDEST 08A2 50 POP 08A3 50 POP 08A4 50 POP 08A5 50 POP 08A6 50 POP 08A7 90 SWAP1 08A8 50 POP 08A9 90 SWAP1 08AA 56 *JUMP // Stack delta = -7 // Outputs[1] { @08A9 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_08AB: // Incoming call from 0x17C1, returns to 0x17C2 // Incoming jump from 0x02D7 // Inputs[1] { @08B1 stack[-1] } 08AB 5B JUMPDEST 08AC 60 PUSH1 0x00 08AE 61 PUSH2 0x08b6 08B1 82 DUP3 08B2 61 PUSH2 0x16e4 08B5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @08AC stack[0] = 0x00 // @08AE stack[1] = 0x08b6 // @08B1 stack[2] = stack[-1] // } // Block ends with call to 0x16e4, returns to 0x08B6 label_08B6: // Incoming return from call to 0x16E4 at 0x08B5 // Inputs[1] { @08BA stack[-1] } 08B6 5B JUMPDEST 08B7 61 PUSH2 0x08d3 08BA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x08d3, if stack[-1] label_08BB: // Incoming jump from 0x08BA, if not stack[-1] // Inputs[3] // { // @08BD memory[0x40:0x60] // @08CD memory[0x40:0x60] // @08D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 08BB 60 PUSH1 0x40 08BD 51 MLOAD 08BE 63 PUSH4 0x33d1c039 08C3 60 PUSH1 0xe2 08C5 1B SHL 08C6 81 DUP2 08C7 52 MSTORE 08C8 60 PUSH1 0x04 08CA 01 ADD 08CB 60 PUSH1 0x40 08CD 51 MLOAD 08CE 80 DUP1 08CF 91 SWAP2 08D0 03 SUB 08D1 90 SWAP1 08D2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @08C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x33d1c039 << 0xe2 // @08D2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_08D3: // Incoming jump from 0x08BA, if stack[-1] // Inputs[4] // { // @08D7 stack[-2] // @08E2 memory[0x00:0x40] // @08E3 storage[keccak256(memory[0x00:0x40])] // @08ED stack[-3] // } 08D3 5B JUMPDEST 08D4 50 POP 08D5 60 PUSH1 0x00 08D7 90 SWAP1 08D8 81 DUP2 08D9 52 MSTORE 08DA 60 PUSH1 0x06 08DC 60 PUSH1 0x20 08DE 52 MSTORE 08DF 60 PUSH1 0x40 08E1 90 SWAP1 08E2 20 SHA3 08E3 54 SLOAD 08E4 60 PUSH1 0x01 08E6 60 PUSH1 0x01 08E8 60 PUSH1 0xa0 08EA 1B SHL 08EB 03 SUB 08EC 16 AND 08ED 90 SWAP1 08EE 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @08D9 memory[0x00:0x20] = stack[-2] // @08DE memory[0x20:0x40] = 0x06 // @08ED stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_08EF: // Incoming jump from 0x030F // Inputs[1] { @08F5 stack[-1] } 08EF 5B JUMPDEST 08F0 60 PUSH1 0x00 08F2 61 PUSH2 0x08fa 08F5 82 DUP3 08F6 61 PUSH2 0x0d73 08F9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @08F0 stack[0] = 0x00 // @08F2 stack[1] = 0x08fa // @08F5 stack[2] = stack[-1] // } // Block ends with call to 0x0d73, returns to 0x08FA label_08FA: // Incoming return from call to 0x0D73 at 0x08F9 // Inputs[3] // { // @08FB stack[-1] // @08FB stack[-2] // @0907 stack[-4] // } 08FA 5B JUMPDEST 08FB 90 SWAP1 08FC 50 POP 08FD 80 DUP1 08FE 60 PUSH1 0x01 0900 60 PUSH1 0x01 0902 60 PUSH1 0xa0 0904 1B SHL 0905 03 SUB 0906 16 AND 0907 83 DUP4 0908 60 PUSH1 0x01 090A 60 PUSH1 0x01 090C 60 PUSH1 0xa0 090E 1B SHL 090F 03 SUB 0910 16 AND 0911 14 EQ 0912 15 ISZERO 0913 61 PUSH2 0x092f 0916 57 *JUMPI // Stack delta = -1 // Outputs[1] { @08FB stack[-2] = stack[-1] } // Block ends with conditional jump to 0x092f, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0917: // Incoming jump from 0x0916, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @0919 memory[0x40:0x60] // @0929 memory[0x40:0x60] // @092E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0917 60 PUSH1 0x40 0919 51 MLOAD 091A 63 PUSH4 0x250fdee3 091F 60 PUSH1 0xe2 0921 1B SHL 0922 81 DUP2 0923 52 MSTORE 0924 60 PUSH1 0x04 0926 01 ADD 0927 60 PUSH1 0x40 0929 51 MLOAD 092A 80 DUP1 092B 91 SWAP2 092C 03 SUB 092D 90 SWAP1 092E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0923 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x250fdee3 << 0xe2 // @092E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_092F: // Incoming jump from 0x0916, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @0930 msg.sender // @0939 stack[-1] // } 092F 5B JUMPDEST 0930 33 CALLER 0931 60 PUSH1 0x01 0933 60 PUSH1 0x01 0935 60 PUSH1 0xa0 0937 1B SHL 0938 03 SUB 0939 82 DUP3 093A 16 AND 093B 14 EQ 093C 80 DUP1 093D 15 ISZERO 093E 90 SWAP1 093F 61 PUSH2 0x094f 0942 57 *JUMPI // Stack delta = +1 // Outputs[1] { @093E stack[0] = !(stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender) } // Block ends with conditional jump to 0x094f, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_0943: // Incoming jump from 0x0942, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0947 stack[-2] // @0948 msg.sender // } 0943 50 POP 0944 61 PUSH2 0x094d 0947 81 DUP2 0948 33 CALLER 0949 61 PUSH2 0x0759 094C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0944 stack[-1] = 0x094d // @0947 stack[0] = stack[-2] // @0948 stack[1] = msg.sender // } // Block ends with call to 0x0759, returns to 0x094D label_094D: // Incoming return from call to 0x0759 at 0x094C // Inputs[1] { @094E stack[-1] } 094D 5B JUMPDEST 094E 15 ISZERO // Stack delta = +0 // Outputs[1] { @094E stack[-1] = !stack[-1] } // Block continues label_094F: // Incoming jump from 0x094E // Incoming jump from 0x0942, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @0950 stack[-1] } 094F 5B JUMPDEST 0950 15 ISZERO 0951 61 PUSH2 0x096d 0954 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x096d, if !stack[-1] label_0955: // Incoming jump from 0x0954, if not !stack[-1] // Inputs[3] // { // @0957 memory[0x40:0x60] // @0967 memory[0x40:0x60] // @096C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0955 60 PUSH1 0x40 0957 51 MLOAD 0958 63 PUSH4 0x67d9dca1 095D 60 PUSH1 0xe1 095F 1B SHL 0960 81 DUP2 0961 52 MSTORE 0962 60 PUSH1 0x04 0964 01 ADD 0965 60 PUSH1 0x40 0967 51 MLOAD 0968 80 DUP1 0969 91 SWAP2 096A 03 SUB 096B 90 SWAP1 096C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0961 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x67d9dca1 << 0xe1 // @096C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_096D: // Incoming jump from 0x0954, if !stack[-1] // Inputs[3] // { // @0971 stack[-3] // @0972 stack[-2] // @0973 stack[-1] // } 096D 5B JUMPDEST 096E 61 PUSH2 0x0978 0971 83 DUP4 0972 83 DUP4 0973 83 DUP4 0974 61 PUSH2 0x171d 0977 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @096E stack[0] = 0x0978 // @0971 stack[1] = stack[-3] // @0972 stack[2] = stack[-2] // @0973 stack[3] = stack[-1] // } // Block ends with call to 0x171d, returns to 0x0978 label_0978: // Incoming return from call to 0x171D at 0x0977 // Incoming return from call to 0x1DBB at 0x1D46 // Incoming return from call to 0x1B06 at 0x1648 // Incoming return from call to 0x1B06 at 0x1026 // Inputs[1] { @097C stack[-4] } 0978 5B JUMPDEST 0979 50 POP 097A 50 POP 097B 50 POP 097C 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_097D: // Incoming jump from 0x0355 // Inputs[2] // { // @0980 storage[0x08] // @098A msg.sender // } 097D 5B JUMPDEST 097E 60 PUSH1 0x08 0980 54 SLOAD 0981 60 PUSH1 0x01 0983 60 PUSH1 0x01 0985 60 PUSH1 0xa0 0987 1B SHL 0988 03 SUB 0989 16 AND 098A 33 CALLER 098B 14 EQ 098C 61 PUSH2 0x09b0 098F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09b0, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0990: // Incoming jump from 0x098F, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0992 memory[0x40:0x60] } 0990 60 PUSH1 0x40 0992 51 MLOAD 0993 62 PUSH3 0x461bcd 0997 60 PUSH1 0xe5 0999 1B SHL 099A 81 DUP2 099B 52 MSTORE 099C 60 PUSH1 0x04 099E 01 ADD 099F 61 PUSH2 0x09a7 09A2 90 SWAP1 09A3 61 PUSH2 0x246e 09A6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @099B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09A2 stack[0] = 0x09a7 // @09A2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x246e, returns to 0x09A7 label_09A7: // Incoming return from call to 0x24EA at 0x15D7 // Incoming return from call to 0x246E at 0x0E61 // Incoming jump from 0x16D7 // Incoming return from call to 0x246E at 0x1122 // Incoming return from call to 0x246E at 0x1672 // Incoming jump from 0x0F43 // Incoming return from call to 0x246E at 0x0A38 // Incoming return from call to 0x246E at 0x0C95 // Incoming return from call to 0x246E at 0x0DFC // Incoming jump from 0x147F // Incoming jump from 0x141F // Incoming return from call to 0x2530 at 0x1369 // Incoming return from call to 0x2530 at 0x1614 // Incoming jump from 0x0F96 // Incoming jump from 0x1002 // Incoming jump from 0x0A8B // Incoming jump from 0x1536 // Incoming jump from 0x13BD // Incoming return from call to 0x246E at 0x09A6 // Incoming return from call to 0x2530 at 0x0EEF // Incoming return from call to 0x246E at 0x158C // Incoming return from call to 0x246E at 0x0E32 // Incoming return from call to 0x246E at 0x09F0 // Incoming return from call to 0x246E at 0x163E // Incoming return from call to 0x24EA at 0x132C // Incoming return from call to 0x246E at 0x0CC4 // Incoming return from call to 0x246E at 0x10F3 // Incoming jump from 0x11FC // Incoming return from call to 0x24EA at 0x0EB2 // Inputs[3] // { // @09AA memory[0x40:0x60] // @09AC stack[-1] // @09AF memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 09A7 5B JUMPDEST 09A8 60 PUSH1 0x40 09AA 51 MLOAD 09AB 80 DUP1 09AC 91 SWAP2 09AD 03 SUB 09AE 90 SWAP1 09AF FD *REVERT // Stack delta = -1 // Outputs[1] { @09AF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_09B0: // Incoming jump from 0x098F, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @09B1 stack[-1] // @09B2 memory[stack[-1]:stack[-1] + 0x20] // } 09B0 5B JUMPDEST 09B1 80 DUP1 09B2 51 MLOAD 09B3 61 PUSH2 0x09c3 09B6 90 SWAP1 09B7 60 PUSH1 0x0e 09B9 90 SWAP1 09BA 60 PUSH1 0x20 09BC 84 DUP5 09BD 01 ADD 09BE 90 SWAP1 09BF 61 PUSH2 0x1f8b 09C2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @09B6 stack[0] = 0x09c3 // @09B9 stack[1] = 0x0e // @09BE stack[2] = stack[-1] + 0x20 // @09BE stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1f8b label_09C3: // Incoming return from call to 0x1D3A at 0x1B1F // Inputs[1] { @09C6 stack[-3] } 09C3 5B JUMPDEST 09C4 50 POP 09C5 50 POP 09C6 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_09C7: // Incoming jump from 0x0375 // Inputs[2] // { // @09CA storage[0x08] // @09D4 msg.sender // } 09C7 5B JUMPDEST 09C8 60 PUSH1 0x08 09CA 54 SLOAD 09CB 60 PUSH1 0x01 09CD 60 PUSH1 0x01 09CF 60 PUSH1 0xa0 09D1 1B SHL 09D2 03 SUB 09D3 16 AND 09D4 33 CALLER 09D5 14 EQ 09D6 61 PUSH2 0x09f1 09D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09f1, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_09DA: // Incoming jump from 0x09D9, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @09DC memory[0x40:0x60] } 09DA 60 PUSH1 0x40 09DC 51 MLOAD 09DD 62 PUSH3 0x461bcd 09E1 60 PUSH1 0xe5 09E3 1B SHL 09E4 81 DUP2 09E5 52 MSTORE 09E6 60 PUSH1 0x04 09E8 01 ADD 09E9 61 PUSH2 0x09a7 09EC 90 SWAP1 09ED 61 PUSH2 0x246e 09F0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09EC stack[0] = 0x09a7 // @09EC stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x246e, returns to 0x09A7 label_09F1: // Incoming jump from 0x09D9, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @09F5 storage[0x13] // @09FA stack[-1] // @0A03 stack[-2] // } 09F1 5B JUMPDEST 09F2 60 PUSH1 0x13 09F4 80 DUP1 09F5 54 SLOAD 09F6 60 PUSH1 0xff 09F8 19 NOT 09F9 16 AND 09FA 91 SWAP2 09FB 15 ISZERO 09FC 15 ISZERO 09FD 91 SWAP2 09FE 90 SWAP1 09FF 91 SWAP2 0A00 17 OR 0A01 90 SWAP1 0A02 55 SSTORE 0A03 56 *JUMP // Stack delta = -2 // Outputs[1] { @0A02 storage[0x13] = !!stack[-1] | (~0xff & storage[0x13]) } // Block ends with unconditional jump to stack[-2] label_0A04: // Incoming jump from 0x03B3 // Inputs[3] // { // @0A08 stack[-3] // @0A09 stack[-2] // @0A0A stack[-1] // } 0A04 5B JUMPDEST 0A05 61 PUSH2 0x0978 0A08 83 DUP4 0A09 83 DUP4 0A0A 83 DUP4 0A0B 61 PUSH2 0x1779 0A0E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A05 stack[0] = 0x0978 // @0A08 stack[1] = stack[-3] // @0A09 stack[2] = stack[-2] // @0A0A stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1779 label_0A0F: // Incoming call from 0x03DE, returns to 0x0310 // Inputs[2] // { // @0A12 storage[0x08] // @0A1C msg.sender // } 0A0F 5B JUMPDEST 0A10 60 PUSH1 0x08 0A12 54 SLOAD 0A13 60 PUSH1 0x01 0A15 60 PUSH1 0x01 0A17 60 PUSH1 0xa0 0A19 1B SHL 0A1A 03 SUB 0A1B 16 AND 0A1C 33 CALLER 0A1D 14 EQ 0A1E 61 PUSH2 0x0a39 0A21 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a39, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0A22: // Incoming jump from 0x0A21, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0A24 memory[0x40:0x60] } 0A22 60 PUSH1 0x40 0A24 51 MLOAD 0A25 62 PUSH3 0x461bcd 0A29 60 PUSH1 0xe5 0A2B 1B SHL 0A2C 81 DUP2 0A2D 52 MSTORE 0A2E 60 PUSH1 0x04 0A30 01 ADD 0A31 61 PUSH2 0x09a7 0A34 90 SWAP1 0A35 61 PUSH2 0x246e 0A38 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A2D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A34 stack[0] = 0x09a7 // @0A34 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x246e, returns to 0x09A7 label_0A39: // Incoming jump from 0x0A21, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0A3E storage[0x09] } 0A39 5B JUMPDEST 0A3A 60 PUSH1 0x02 0A3C 60 PUSH1 0x09 0A3E 54 SLOAD 0A3F 14 EQ 0A40 15 ISZERO 0A41 61 PUSH2 0x0a8c 0A44 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a8c, if !(storage[0x09] == 0x02) label_0A45: // Incoming jump from 0x0A44, if not !(storage[0x09] == 0x02) // Inputs[1] { @0A47 memory[0x40:0x60] } 0A45 60 PUSH1 0x40 0A47 51 MLOAD 0A48 62 PUSH3 0x461bcd 0A4C 60 PUSH1 0xe5 0A4E 1B SHL 0A4F 81 DUP2 0A50 52 MSTORE 0A51 60 PUSH1 0x20 0A53 60 PUSH1 0x04 0A55 82 DUP3 0A56 01 ADD 0A57 52 MSTORE 0A58 60 PUSH1 0x1f 0A5A 60 PUSH1 0x24 0A5C 82 DUP3 0A5D 01 ADD 0A5E 52 MSTORE 0A5F 7F PUSH32 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 0A80 60 PUSH1 0x44 0A82 82 DUP3 0A83 01 ADD 0A84 52 MSTORE 0A85 60 PUSH1 0x64 0A87 01 ADD 0A88 61 PUSH2 0x09a7 0A8B 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A50 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A57 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A5E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @0A84 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 // @0A87 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x09a7 label_0A8C: // Incoming jump from 0x0A44, if !(storage[0x09] == 0x02) // Inputs[1] { @0A99 storage[0x08] } 0A8C 5B JUMPDEST 0A8D 60 PUSH1 0x02 0A8F 60 PUSH1 0x09 0A91 55 SSTORE 0A92 60 PUSH1 0x00 0A94 61 PUSH2 0x0aa5 0A97 60 PUSH1 0x08 0A99 54 SLOAD 0A9A 60 PUSH1 0x01 0A9C 60 PUSH1 0x01 0A9E 60 PUSH1 0xa0 0AA0 1B SHL 0AA1 03 SUB 0AA2 16 AND 0AA3 90 SWAP1 0AA4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A91 storage[0x09] = 0x02 // @0A92 stack[0] = 0x00 // @0AA3 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x08] // } // Block ends with unconditional jump to 0x0aa5 label_0AA5: // Incoming jump from 0x0AA4 // Inputs[9] // { // @0AAE stack[-1] // @0AAF address(this).balance // @0AAF address(this) // @0AB2 memory[0x40:0x60] // @0AB7 memory[0x40:0x60] // @0ABE msg.gas // @0ABF memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0ABF address((0x01 << 0xa0) - 0x01 & stack[-1]).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @0AC4 returndata.length // } 0AA5 5B JUMPDEST 0AA6 60 PUSH1 0x01 0AA8 60 PUSH1 0x01 0AAA 60 PUSH1 0xa0 0AAC 1B SHL 0AAD 03 SUB 0AAE 16 AND 0AAF 47 SELFBALANCE 0AB0 60 PUSH1 0x40 0AB2 51 MLOAD 0AB3 60 PUSH1 0x00 0AB5 60 PUSH1 0x40 0AB7 51 MLOAD 0AB8 80 DUP1 0AB9 83 DUP4 0ABA 03 SUB 0ABB 81 DUP2 0ABC 85 DUP6 0ABD 87 DUP8 0ABE 5A GAS 0ABF F1 CALL 0AC0 92 SWAP3 0AC1 50 POP 0AC2 50 POP 0AC3 50 POP 0AC4 3D RETURNDATASIZE 0AC5 80 DUP1 0AC6 60 PUSH1 0x00 0AC8 81 DUP2 0AC9 14 EQ 0ACA 61 PUSH2 0x0aef 0ACD 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0ABF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address((0x01 << 0xa0) - 0x01 & stack[-1]).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @0AC0 stack[-1] = address((0x01 << 0xa0) - 0x01 & stack[-1]).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @0AC4 stack[0] = returndata.length // @0AC5 stack[1] = returndata.length // } // Block ends with conditional jump to 0x0aef, if returndata.length == 0x00 label_0ACE: // Incoming jump from 0x0ACD, if not returndata.length == 0x00 // Inputs[6] // { // @0AD0 memory[0x40:0x60] // @0AD1 stack[-2] // @0AD8 returndata.length // @0AE0 returndata.length // @0AE3 returndata.length // @0AEA returndata[0x00:0x00 + returndata.length] // } 0ACE 60 PUSH1 0x40 0AD0 51 MLOAD 0AD1 91 SWAP2 0AD2 50 POP 0AD3 60 PUSH1 0x1f 0AD5 19 NOT 0AD6 60 PUSH1 0x3f 0AD8 3D RETURNDATASIZE 0AD9 01 ADD 0ADA 16 AND 0ADB 82 DUP3 0ADC 01 ADD 0ADD 60 PUSH1 0x40 0ADF 52 MSTORE 0AE0 3D RETURNDATASIZE 0AE1 82 DUP3 0AE2 52 MSTORE 0AE3 3D RETURNDATASIZE 0AE4 60 PUSH1 0x00 0AE6 60 PUSH1 0x20 0AE8 84 DUP5 0AE9 01 ADD 0AEA 3E RETURNDATACOPY 0AEB 61 PUSH2 0x0af4 0AEE 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0AD1 stack[-2] = memory[0x40:0x60] // @0ADF memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0AE2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0AEA memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0af4 label_0AEF: // Incoming jump from 0x0ACD, if returndata.length == 0x00 // Inputs[3] // { // @0AF2 stack[-2] // @0AF7 stack[-4] // @0AF7 stack[-3] // } 0AEF 5B JUMPDEST 0AF0 60 PUSH1 0x60 0AF2 91 SWAP2 0AF3 50 POP 0AF4 5B JUMPDEST 0AF5 50 POP 0AF6 50 POP 0AF7 90 SWAP1 0AF8 50 POP 0AF9 80 DUP1 0AFA 61 PUSH2 0x0b02 0AFD 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0AF7 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x0b02, if stack[-3] label_0AFE: // Incoming jump from 0x0AFD, if not stack[-3] // Incoming jump from 0x0AFD, if not stack[-3] // Inputs[1] { @0B01 memory[0x00:0x00] } 0AFE 60 PUSH1 0x00 0B00 80 DUP1 0B01 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B01 revert(memory[0x00:0x00]); } // Block terminates label_0B02: // Incoming jump from 0x0AFD, if stack[-3] // Incoming jump from 0x0AFD, if stack[-3] // Inputs[1] { @0B09 stack[-2] } 0B02 5B JUMPDEST 0B03 50 POP 0B04 60 PUSH1 0x01 0B06 60 PUSH1 0x09 0B08 55 SSTORE 0B09 56 *JUMP // Stack delta = -2 // Outputs[1] { @0B08 storage[0x09] = 0x01 } // Block ends with unconditional jump to stack[-2] label_0B0A: // Incoming jump from 0x03FE // Inputs[4] // { // @0B0E stack[-3] // @0B0F stack[-2] // @0B10 stack[-1] // @0B13 memory[0x40:0x60] // } 0B0A 5B JUMPDEST 0B0B 61 PUSH2 0x0978 0B0E 83 DUP4 0B0F 83 DUP4 0B10 83 DUP4 0B11 60 PUSH1 0x40 0B13 51 MLOAD 0B14 80 DUP1 0B15 60 PUSH1 0x20 0B17 01 ADD 0B18 60 PUSH1 0x40 0B1A 52 MSTORE 0B1B 80 DUP1 0B1C 60 PUSH1 0x00 0B1E 81 DUP2 0B1F 52 MSTORE 0B20 50 POP 0B21 61 PUSH2 0x113d 0B24 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0B0B stack[0] = 0x0978 // @0B0E stack[1] = stack[-3] // @0B0F stack[2] = stack[-2] // @0B10 stack[3] = stack[-1] // @0B13 stack[4] = memory[0x40:0x60] // @0B1A memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0B1F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x113d label_0B25: // Incoming jump from 0x041E // Inputs[1] { @0B2D stack[-1] } 0B25 5B JUMPDEST 0B26 60 PUSH1 0x60 0B28 60 PUSH1 0x00 0B2A 61 PUSH2 0x0b32 0B2D 83 DUP4 0B2E 61 PUSH2 0x0d85 0B31 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B26 stack[0] = 0x60 // @0B28 stack[1] = 0x00 // @0B2A stack[2] = 0x0b32 // @0B2D stack[3] = stack[-1] // } // Block ends with call to 0x0d85, returns to 0x0B32 label_0B32: // Incoming return from call to 0x0D85 at 0x0B31 // Inputs[2] // { // @0B33 stack[-1] // @0B33 stack[-2] // } 0B32 5B JUMPDEST 0B33 90 SWAP1 0B34 50 POP 0B35 60 PUSH1 0x00 0B37 81 DUP2 0B38 60 PUSH1 0x01 0B3A 60 PUSH1 0x01 0B3C 60 PUSH1 0x40 0B3E 1B SHL 0B3F 03 SUB 0B40 81 DUP2 0B41 11 GT 0B42 15 ISZERO 0B43 61 PUSH2 0x0b4e 0B46 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0B33 stack[-2] = stack[-1] // @0B35 stack[-1] = 0x00 // @0B37 stack[0] = stack[-1] // } // Block ends with conditional jump to 0x0b4e, if !(stack[-1] > (0x01 << 0x40) - 0x01) label_0B47: // Incoming jump from 0x0B46, if not !(stack[-1] > (0x01 << 0x40) - 0x01) 0B47 61 PUSH2 0x0b4e 0B4A 61 PUSH2 0x2121 0B4D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B47 stack[0] = 0x0b4e } // Block ends with unconditional jump to 0x2121 label_0B4E: // Incoming jump from 0x0B46, if !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @0B51 memory[0x40:0x60] // @0B52 stack[-1] // } 0B4E 5B JUMPDEST 0B4F 60 PUSH1 0x40 0B51 51 MLOAD 0B52 90 SWAP1 0B53 80 DUP1 0B54 82 DUP3 0B55 52 MSTORE 0B56 80 DUP1 0B57 60 PUSH1 0x20 0B59 02 MUL 0B5A 60 PUSH1 0x20 0B5C 01 ADD 0B5D 82 DUP3 0B5E 01 ADD 0B5F 60 PUSH1 0x40 0B61 52 MSTORE 0B62 80 DUP1 0B63 15 ISZERO 0B64 61 PUSH2 0x0b77 0B67 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0B52 stack[-1] = memory[0x40:0x60] // @0B52 stack[0] = stack[-1] // @0B55 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0B61 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x0b77, if !stack[-1] label_0B68: // Incoming jump from 0x0B67, if not !stack[-1] // Inputs[6] // { // @0B68 stack[-2] // @0B6E stack[-1] // @0B71 msg.data.length // @0B73 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0B79 stack[-3] // @0B81 stack[-4] // } 0B68 81 DUP2 0B69 60 PUSH1 0x20 0B6B 01 ADD 0B6C 60 PUSH1 0x20 0B6E 82 DUP3 0B6F 02 MUL 0B70 80 DUP1 0B71 36 CALLDATASIZE 0B72 83 DUP4 0B73 37 CALLDATACOPY 0B74 01 ADD 0B75 90 SWAP1 0B76 50 POP 0B77 5B JUMPDEST 0B78 50 POP 0B79 90 SWAP1 0B7A 50 POP 0B7B 60 PUSH1 0x01 0B7D 60 PUSH1 0x00 0B7F 80 DUP1 0B80 5B JUMPDEST 0B81 84 DUP5 0B82 82 DUP3 0B83 10 LT 0B84 80 DUP1 0B85 15 ISZERO 0B86 61 PUSH2 0x0b91 0B89 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @0B73 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0B79 stack[-3] = stack[-2] // @0B7B stack[-2] = 0x01 // @0B7D stack[-1] = 0x00 // @0B7F stack[0] = 0x00 // @0B83 stack[1] = 0x00 < stack[-4] // } // Block ends with conditional jump to 0x0b91, if !(0x00 < stack[-4]) label_0B8A: // Incoming jump from 0x0B89, if not !(0x00 < stack[-4]) // Incoming jump from 0x0B89, if not !(0x00 < stack[-4]) // Incoming jump from 0x0B89, if not !(stack[-2] < stack[-5]) // Inputs[2] // { // @0B8D storage[0x11] // @0B8E stack[-4] // } 0B8A 50 POP 0B8B 60 PUSH1 0x11 0B8D 54 SLOAD 0B8E 83 DUP4 0B8F 11 GT 0B90 15 ISZERO 0B91 5B JUMPDEST 0B92 15 ISZERO 0B93 61 PUSH2 0x0c61 0B96 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c61, if !!(stack[-4] > storage[0x11]) label_0B97: // Incoming jump from 0x0B96, if not !stack[-1] // Incoming jump from 0x0B96, if not !!(stack[-4] > storage[0x11]) // Inputs[4] // { // @0B99 stack[-3] // @0BA8 memory[0x00:0x40] // @0BAA memory[0x40:0x60] // @0BB2 storage[keccak256(memory[0x00:0x40])] // } 0B97 60 PUSH1 0x00 0B99 83 DUP4 0B9A 81 DUP2 0B9B 52 MSTORE 0B9C 60 PUSH1 0x04 0B9E 60 PUSH1 0x20 0BA0 90 SWAP1 0BA1 81 DUP2 0BA2 52 MSTORE 0BA3 60 PUSH1 0x40 0BA5 91 SWAP2 0BA6 82 DUP3 0BA7 90 SWAP1 0BA8 20 SHA3 0BA9 82 DUP3 0BAA 51 MLOAD 0BAB 60 PUSH1 0x60 0BAD 81 DUP2 0BAE 01 ADD 0BAF 84 DUP5 0BB0 52 MSTORE 0BB1 90 SWAP1 0BB2 54 SLOAD 0BB3 60 PUSH1 0x01 0BB5 60 PUSH1 0x01 0BB7 60 PUSH1 0xa0 0BB9 1B SHL 0BBA 03 SUB 0BBB 81 DUP2 0BBC 16 AND 0BBD 82 DUP3 0BBE 52 MSTORE 0BBF 60 PUSH1 0x01 0BC1 60 PUSH1 0xa0 0BC3 1B SHL 0BC4 81 DUP2 0BC5 04 DIV 0BC6 60 PUSH1 0x01 0BC8 60 PUSH1 0x01 0BCA 60 PUSH1 0x40 0BCC 1B SHL 0BCD 03 SUB 0BCE 16 AND 0BCF 92 SWAP3 0BD0 82 DUP3 0BD1 01 ADD 0BD2 92 SWAP3 0BD3 90 SWAP1 0BD4 92 SWAP3 0BD5 52 MSTORE 0BD6 60 PUSH1 0x01 0BD8 60 PUSH1 0xe0 0BDA 1B SHL 0BDB 90 SWAP1 0BDC 91 SWAP2 0BDD 04 DIV 0BDE 60 PUSH1 0xff 0BE0 16 AND 0BE1 15 ISZERO 0BE2 80 DUP1 0BE3 15 ISZERO 0BE4 92 SWAP3 0BE5 82 DUP3 0BE6 01 ADD 0BE7 83 DUP4 0BE8 90 SWAP1 0BE9 52 MSTORE 0BEA 90 SWAP1 0BEB 91 SWAP2 0BEC 61 PUSH2 0x0bfe 0BEF 57 *JUMPI // Stack delta = +2 // Outputs[8] // { // @0B9B memory[0x00:0x20] = stack[-3] // @0BA2 memory[0x20:0x40] = 0x04 // @0BB0 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @0BBE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @0BD5 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @0BE9 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // @0BEA stack[1] = !(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // @0BEB stack[0] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x0bfe, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) label_0BF0: // Incoming jump from 0x0BEF, if not !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // Inputs[2] // { // @0BF1 stack[-2] // @0BF2 memory[stack[-2]:stack[-2] + 0x20] // } 0BF0 50 POP 0BF1 80 DUP1 0BF2 51 MLOAD 0BF3 60 PUSH1 0x01 0BF5 60 PUSH1 0x01 0BF7 60 PUSH1 0xa0 0BF9 1B SHL 0BFA 03 SUB 0BFB 16 AND 0BFC 15 ISZERO 0BFD 15 ISZERO 0BFE 5B JUMPDEST 0BFF 15 ISZERO 0C00 61 PUSH2 0x0c08 0C03 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c08, if !!!((0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20]) label_0C04: // Incoming jump from 0x0C03, if not !stack[-1] // Incoming jump from 0x0C03, if not !!!((0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @0C04 stack[-1] // @0C05 memory[stack[-1]:stack[-1] + 0x20] // @0C06 stack[-2] // @0C09 stack[-8] // } 0C04 80 DUP1 0C05 51 MLOAD 0C06 91 SWAP2 0C07 50 POP 0C08 5B JUMPDEST 0C09 87 DUP8 0C0A 60 PUSH1 0x01 0C0C 60 PUSH1 0x01 0C0E 60 PUSH1 0xa0 0C10 1B SHL 0C11 03 SUB 0C12 16 AND 0C13 82 DUP3 0C14 60 PUSH1 0x01 0C16 60 PUSH1 0x01 0C18 60 PUSH1 0xa0 0C1A 1B SHL 0C1B 03 SUB 0C1C 16 AND 0C1D 14 EQ 0C1E 15 ISZERO 0C1F 61 PUSH2 0x0c4e 0C22 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0C06 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x0c4e, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-8]) label_0C23: // Incoming jump from 0x0C22, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-8]) // Incoming jump from 0x0C22, if not !((0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-8]) // Inputs[4] // { // @0C23 stack[-4] // @0C24 stack[-5] // @0C25 stack[-3] // @0C27 memory[stack[-5]:stack[-5] + 0x20] // } 0C23 83 DUP4 0C24 85 DUP6 0C25 84 DUP5 0C26 81 DUP2 0C27 51 MLOAD 0C28 81 DUP2 0C29 10 LT 0C2A 61 PUSH2 0x0c35 0C2D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0C23 stack[0] = stack[-4] // @0C24 stack[1] = stack[-5] // @0C25 stack[2] = stack[-3] // } // Block ends with conditional jump to 0x0c35, if stack[-3] < memory[stack[-5]:stack[-5] + 0x20] label_0C2E: // Incoming jump from 0x0C2D, if not stack[-3] < memory[stack[-5]:stack[-5] + 0x20] 0C2E 61 PUSH2 0x0c35 0C31 61 PUSH2 0x24a3 0C34 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C2E stack[0] = 0x0c35 } // Block ends with unconditional jump to 0x24a3 label_0C35: // Incoming jump from 0x0C2D, if stack[-3] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[4] // { // @0C38 stack[-1] // @0C3B stack[-2] // @0C40 stack[-3] // @0C41 stack[-6] // } 0C35 5B JUMPDEST 0C36 60 PUSH1 0x20 0C38 90 SWAP1 0C39 81 DUP2 0C3A 02 MUL 0C3B 91 SWAP2 0C3C 90 SWAP1 0C3D 91 SWAP2 0C3E 01 ADD 0C3F 01 ADD 0C40 52 MSTORE 0C41 82 DUP3 0C42 61 PUSH2 0x0c4a 0C45 81 DUP2 0C46 61 PUSH2 0x24cf 0C49 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0C40 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @0C41 stack[-3] = stack[-6] // @0C42 stack[-2] = 0x0c4a // @0C45 stack[-1] = stack[-6] // } // Block ends with call to 0x24cf, returns to 0x0C4A label_0C4A: // Incoming return from call to 0x24CF at 0x0C49 // Inputs[2] // { // @0C4B stack[-5] // @0C4B stack[-1] // } 0C4A 5B JUMPDEST 0C4B 93 SWAP4 0C4C 50 POP 0C4D 50 POP // Stack delta = -2 // Outputs[1] { @0C4B stack[-5] = stack[-1] } // Block continues label_0C4E: // Incoming jump from 0x0C22, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-8]) // Incoming jump from 0x0C22, if !((0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-8]) // Incoming jump from 0x0C4D // Inputs[1] { @0C4F stack[-4] } 0C4E 5B JUMPDEST 0C4F 83 DUP4 0C50 61 PUSH2 0x0c58 0C53 81 DUP2 0C54 61 PUSH2 0x24cf 0C57 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C4F stack[0] = stack[-4] // @0C50 stack[1] = 0x0c58 // @0C53 stack[2] = stack[-4] // } // Block ends with call to 0x24cf, returns to 0x0C58 label_0C58: // Incoming return from call to 0x24CF at 0x0C57 // Inputs[2] // { // @0C59 stack[-6] // @0C59 stack[-1] // } 0C58 5B JUMPDEST 0C59 94 SWAP5 0C5A 50 POP 0C5B 50 POP 0C5C 50 POP 0C5D 61 PUSH2 0x0b80 0C60 56 *JUMP // Stack delta = -3 // Outputs[1] { @0C59 stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x0b80 label_0C61: // Incoming jump from 0x0B96, if !stack[-1] // Incoming jump from 0x0B96, if !!(stack[-4] > storage[0x11]) // Inputs[4] // { // @0C63 stack[-4] // @0C63 stack[-2] // @0C64 stack[-8] // @0C65 stack[-7] // } 0C61 5B JUMPDEST 0C62 50 POP 0C63 91 SWAP2 0C64 95 SWAP6 0C65 94 SWAP5 0C66 50 POP 0C67 50 POP 0C68 50 POP 0C69 50 POP 0C6A 50 POP 0C6B 56 *JUMP // Stack delta = -7 // Outputs[1] { @0C64 stack[-8] = stack[-4] } // Block ends with unconditional jump to stack[-8] label_0C6C: // Incoming jump from 0x044B // Inputs[2] // { // @0C6F storage[0x08] // @0C79 msg.sender // } 0C6C 5B JUMPDEST 0C6D 60 PUSH1 0x08 0C6F 54 SLOAD 0C70 60 PUSH1 0x01 0C72 60 PUSH1 0x01 0C74 60 PUSH1 0xa0 0C76 1B SHL 0C77 03 SUB 0C78 16 AND 0C79 33 CALLER 0C7A 14 EQ 0C7B 61 PUSH2 0x0c96 0C7E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c96, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0C7F: // Incoming jump from 0x0C7E, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0C81 memory[0x40:0x60] } 0C7F 60 PUSH1 0x40 0C81 51 MLOAD 0C82 62 PUSH3 0x461bcd 0C86 60 PUSH1 0xe5 0C88 1B SHL 0C89 81 DUP2 0C8A 52 MSTORE 0C8B 60 PUSH1 0x04 0C8D 01 ADD 0C8E 61 PUSH2 0x09a7 0C91 90 SWAP1 0C92 61 PUSH2 0x246e 0C95 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C8A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C91 stack[0] = 0x09a7 // @0C91 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x246e, returns to 0x09A7 label_0C96: // Incoming jump from 0x0C7E, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0C99 stack[-1] // @0C9A stack[-2] // } 0C96 5B JUMPDEST 0C97 60 PUSH1 0x10 0C99 55 SSTORE 0C9A 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C99 storage[0x10] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0C9B: // Incoming jump from 0x046B // Inputs[2] // { // @0C9E storage[0x08] // @0CA8 msg.sender // } 0C9B 5B JUMPDEST 0C9C 60 PUSH1 0x08 0C9E 54 SLOAD 0C9F 60 PUSH1 0x01 0CA1 60 PUSH1 0x01 0CA3 60 PUSH1 0xa0 0CA5 1B SHL 0CA6 03 SUB 0CA7 16 AND 0CA8 33 CALLER 0CA9 14 EQ 0CAA 61 PUSH2 0x0cc5 0CAD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cc5, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0CAE: // Incoming jump from 0x0CAD, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0CB0 memory[0x40:0x60] } 0CAE 60 PUSH1 0x40 0CB0 51 MLOAD 0CB1 62 PUSH3 0x461bcd 0CB5 60 PUSH1 0xe5 0CB7 1B SHL 0CB8 81 DUP2 0CB9 52 MSTORE 0CBA 60 PUSH1 0x04 0CBC 01 ADD 0CBD 61 PUSH2 0x09a7 0CC0 90 SWAP1 0CC1 61 PUSH2 0x246e 0CC4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0CB9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CC0 stack[0] = 0x09a7 // @0CC0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x246e, returns to 0x09A7 label_0CC5: // Incoming jump from 0x0CAD, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0CC6 stack[-1] // @0CC7 memory[stack[-1]:stack[-1] + 0x20] // } 0CC5 5B JUMPDEST 0CC6 80 DUP1 0CC7 51 MLOAD 0CC8 61 PUSH2 0x09c3 0CCB 90 SWAP1 0CCC 60 PUSH1 0x0f 0CCE 90 SWAP1 0CCF 60 PUSH1 0x20 0CD1 84 DUP5 0CD2 01 ADD 0CD3 90 SWAP1 0CD4 61 PUSH2 0x1f8b 0CD7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0CCB stack[0] = 0x09c3 // @0CCE stack[1] = 0x0f // @0CD3 stack[2] = stack[-1] + 0x20 // @0CD3 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1f8b label_0CD8: // Incoming call from 0x04A0, returns to 0x02AB // Inputs[1] { @0CDC storage[0x0e] } 0CD8 5B JUMPDEST 0CD9 60 PUSH1 0x0e 0CDB 80 DUP1 0CDC 54 SLOAD 0CDD 61 PUSH2 0x0ce5 0CE0 90 SWAP1 0CE1 61 PUSH2 0x2433 0CE4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CD9 stack[0] = 0x0e // @0CE0 stack[1] = 0x0ce5 // @0CE0 stack[2] = storage[0x0e] // } // Block ends with call to 0x2433, returns to 0x0CE5 label_0CE5: // Incoming return from call to 0x2433 at 0x10C9 // Incoming return from call to 0x2433 at 0x0CE4 // Incoming return from call to 0x2433 at 0x0D72 // Inputs[4] // { // @0CE6 stack[-1] // @0CF5 memory[0x40:0x60] // @0CFD stack[-2] // @0D08 storage[stack[-2]] // } 0CE5 5B JUMPDEST 0CE6 80 DUP1 0CE7 60 PUSH1 0x1f 0CE9 01 ADD 0CEA 60 PUSH1 0x20 0CEC 80 DUP1 0CED 91 SWAP2 0CEE 04 DIV 0CEF 02 MUL 0CF0 60 PUSH1 0x20 0CF2 01 ADD 0CF3 60 PUSH1 0x40 0CF5 51 MLOAD 0CF6 90 SWAP1 0CF7 81 DUP2 0CF8 01 ADD 0CF9 60 PUSH1 0x40 0CFB 52 MSTORE 0CFC 80 DUP1 0CFD 92 SWAP3 0CFE 91 SWAP2 0CFF 90 SWAP1 0D00 81 DUP2 0D01 81 DUP2 0D02 52 MSTORE 0D03 60 PUSH1 0x20 0D05 01 ADD 0D06 82 DUP3 0D07 80 DUP1 0D08 54 SLOAD 0D09 61 PUSH2 0x0d11 0D0C 90 SWAP1 0D0D 61 PUSH2 0x2433 0D10 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0CFB memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0CFD stack[-2] = memory[0x40:0x60] // @0CFE stack[-1] = stack[-2] // @0CFF stack[0] = stack[-1] // @0D02 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0D05 stack[1] = 0x20 + memory[0x40:0x60] // @0D06 stack[2] = stack[-2] // @0D0C stack[4] = storage[stack[-2]] // @0D0C stack[3] = 0x0d11 // } // Block ends with call to 0x2433, returns to 0x0D11 label_0D11: // Incoming return from call to 0x2433 at 0x0D10 // Inputs[1] { @0D12 stack[-1] } 0D11 5B JUMPDEST 0D12 80 DUP1 0D13 15 ISZERO 0D14 61 PUSH2 0x0d5e 0D17 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d5e, if !stack[-1] label_0D18: // Incoming jump from 0x0D17, if not !stack[-1] // Inputs[1] { @0D18 stack[-1] } 0D18 80 DUP1 0D19 60 PUSH1 0x1f 0D1B 10 LT 0D1C 61 PUSH2 0x0d33 0D1F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d33, if 0x1f < stack[-1] label_0D20: // Incoming jump from 0x0D1F, if not 0x1f < stack[-1] // Inputs[4] // { // @0D24 stack[-2] // @0D25 storage[stack[-2]] // @0D28 stack[-3] // @0D2A stack[-1] // } 0D20 61 PUSH2 0x0100 0D23 80 DUP1 0D24 83 DUP4 0D25 54 SLOAD 0D26 04 DIV 0D27 02 MUL 0D28 83 DUP4 0D29 52 MSTORE 0D2A 91 SWAP2 0D2B 60 PUSH1 0x20 0D2D 01 ADD 0D2E 91 SWAP2 0D2F 61 PUSH2 0x0d5e 0D32 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0D29 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0D2E stack[-1] = stack[-1] // @0D2E stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0d5e label_0D33: // Incoming jump from 0x0D1F, if 0x1f < stack[-1] // Inputs[5] // { // @0D34 stack[-3] // @0D35 stack[-1] // @0D37 stack[-2] // @0D3F memory[0x00:0x20] // @0D43 storage[keccak256(memory[0x00:0x20])] // } 0D33 5B JUMPDEST 0D34 82 DUP3 0D35 01 ADD 0D36 91 SWAP2 0D37 90 SWAP1 0D38 60 PUSH1 0x00 0D3A 52 MSTORE 0D3B 60 PUSH1 0x20 0D3D 60 PUSH1 0x00 0D3F 20 SHA3 0D40 90 SWAP1 0D41 5B JUMPDEST 0D42 81 DUP2 0D43 54 SLOAD 0D44 81 DUP2 0D45 52 MSTORE 0D46 90 SWAP1 0D47 60 PUSH1 0x01 0D49 01 ADD 0D4A 90 SWAP1 0D4B 60 PUSH1 0x20 0D4D 01 ADD 0D4E 80 DUP1 0D4F 83 DUP4 0D50 11 GT 0D51 61 PUSH2 0x0d41 0D54 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0D36 stack[-3] = stack[-3] + stack[-1] // @0D3A memory[0x00:0x20] = stack[-2] // @0D45 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0D4A stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0D4D stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0d41, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0D55: // Incoming jump from 0x0D54, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0D54, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0D55 stack[-3] // @0D56 stack[-1] // } 0D55 82 DUP3 0D56 90 SWAP1 0D57 03 SUB 0D58 60 PUSH1 0x1f 0D5A 16 AND 0D5B 82 DUP3 0D5C 01 ADD 0D5D 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0D5D stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0D5D stack[-1] = stack[-3] // } // Block continues label_0D5E: // Incoming jump from 0x0D5D // Incoming jump from 0x0D17, if !stack[-1] // Incoming jump from 0x0D32 // Inputs[1] { @0D64 stack[-7] } 0D5E 5B JUMPDEST 0D5F 50 POP 0D60 50 POP 0D61 50 POP 0D62 50 POP 0D63 50 POP 0D64 81 DUP2 0D65 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0D66: // Incoming call from 0x04CF, returns to 0x02AB // Inputs[1] { @0D6A storage[0x0d] } 0D66 5B JUMPDEST 0D67 60 PUSH1 0x0d 0D69 80 DUP1 0D6A 54 SLOAD 0D6B 61 PUSH2 0x0ce5 0D6E 90 SWAP1 0D6F 61 PUSH2 0x2433 0D72 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D67 stack[0] = 0x0d // @0D6E stack[1] = 0x0ce5 // @0D6E stack[2] = storage[0x0d] // } // Block ends with call to 0x2433, returns to 0x0CE5 label_0D73: // Incoming jump from 0x04EF // Incoming call from 0x08F9, returns to 0x08FA // Inputs[1] { @0D79 stack[-1] } 0D73 5B JUMPDEST 0D74 60 PUSH1 0x00 0D76 61 PUSH2 0x0d7e 0D79 82 DUP3 0D7A 61 PUSH2 0x198d 0D7D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D74 stack[0] = 0x00 // @0D76 stack[1] = 0x0d7e // @0D79 stack[2] = stack[-1] // } // Block ends with call to 0x198d, returns to 0x0D7E label_0D7E: // Incoming return from call to 0x198D at 0x0D7D // Inputs[4] // { // @0D7F stack[-1] // @0D7F memory[stack[-1]:stack[-1] + 0x20] // @0D80 stack[-4] // @0D81 stack[-3] // } 0D7E 5B JUMPDEST 0D7F 51 MLOAD 0D80 92 SWAP3 0D81 91 SWAP2 0D82 50 POP 0D83 50 POP 0D84 56 *JUMP // Stack delta = -3 // Outputs[1] { @0D80 stack[-4] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-4] label_0D85: // Incoming call from 0x0B31, returns to 0x0B32 // Incoming jump from 0x052E // Inputs[1] { @0D90 stack[-1] } 0D85 5B JUMPDEST 0D86 60 PUSH1 0x00 0D88 60 PUSH1 0x01 0D8A 60 PUSH1 0x01 0D8C 60 PUSH1 0xa0 0D8E 1B SHL 0D8F 03 SUB 0D90 82 DUP3 0D91 16 AND 0D92 61 PUSH2 0x0dae 0D95 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D86 stack[0] = 0x00 } // Block ends with conditional jump to 0x0dae, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0D96: // Incoming jump from 0x0D95, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0D98 memory[0x40:0x60] // @0DA8 memory[0x40:0x60] // @0DAD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0D96 60 PUSH1 0x40 0D98 51 MLOAD 0D99 63 PUSH4 0x23d3ad81 0D9E 60 PUSH1 0xe2 0DA0 1B SHL 0DA1 81 DUP2 0DA2 52 MSTORE 0DA3 60 PUSH1 0x04 0DA5 01 ADD 0DA6 60 PUSH1 0x40 0DA8 51 MLOAD 0DA9 80 DUP1 0DAA 91 SWAP2 0DAB 03 SUB 0DAC 90 SWAP1 0DAD FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0DA2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x23d3ad81 << 0xe2 // @0DAD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0DAE: // Incoming jump from 0x0D95, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0DB8 stack[-2] // @0DC6 memory[0x00:0x40] // @0DC7 storage[keccak256(memory[0x00:0x40])] // @0DD1 stack[-3] // } 0DAE 5B JUMPDEST 0DAF 50 POP 0DB0 60 PUSH1 0x01 0DB2 60 PUSH1 0x01 0DB4 60 PUSH1 0xa0 0DB6 1B SHL 0DB7 03 SUB 0DB8 16 AND 0DB9 60 PUSH1 0x00 0DBB 90 SWAP1 0DBC 81 DUP2 0DBD 52 MSTORE 0DBE 60 PUSH1 0x05 0DC0 60 PUSH1 0x20 0DC2 52 MSTORE 0DC3 60 PUSH1 0x40 0DC5 90 SWAP1 0DC6 20 SHA3 0DC7 54 SLOAD 0DC8 60 PUSH1 0x01 0DCA 60 PUSH1 0x01 0DCC 60 PUSH1 0x40 0DCE 1B SHL 0DCF 03 SUB 0DD0 16 AND 0DD1 90 SWAP1 0DD2 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0DBD memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0DC2 memory[0x20:0x40] = 0x05 // @0DD1 stack[-3] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0DD3: // Incoming call from 0x0543, returns to 0x0310 // Inputs[2] // { // @0DD6 storage[0x08] // @0DE0 msg.sender // } 0DD3 5B JUMPDEST 0DD4 60 PUSH1 0x08 0DD6 54 SLOAD 0DD7 60 PUSH1 0x01 0DD9 60 PUSH1 0x01 0DDB 60 PUSH1 0xa0 0DDD 1B SHL 0DDE 03 SUB 0DDF 16 AND 0DE0 33 CALLER 0DE1 14 EQ 0DE2 61 PUSH2 0x0dfd 0DE5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dfd, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0DE6: // Incoming jump from 0x0DE5, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0DE8 memory[0x40:0x60] } 0DE6 60 PUSH1 0x40 0DE8 51 MLOAD 0DE9 62 PUSH3 0x461bcd 0DED 60 PUSH1 0xe5 0DEF 1B SHL 0DF0 81 DUP2 0DF1 52 MSTORE 0DF2 60 PUSH1 0x04 0DF4 01 ADD 0DF5 61 PUSH2 0x09a7 0DF8 90 SWAP1 0DF9 61 PUSH2 0x246e 0DFC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DF1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DF8 stack[0] = 0x09a7 // @0DF8 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x246e, returns to 0x09A7 label_0DFD: // Incoming jump from 0x0DE5, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] 0DFD 5B JUMPDEST 0DFE 61 PUSH2 0x0e07 0E01 60 PUSH1 0x00 0E03 61 PUSH2 0x1ab4 0E06 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0DFE stack[0] = 0x0e07 // @0E01 stack[1] = 0x00 // } // Block ends with call to 0x1ab4, returns to 0x0E07 label_0E07: // Incoming return from call to 0x1AB4 at 0x0E06 // Inputs[1] { @0E08 stack[-1] } 0E07 5B JUMPDEST 0E08 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0E09: // Incoming jump from 0x0563 // Inputs[2] // { // @0E0C storage[0x08] // @0E16 msg.sender // } 0E09 5B JUMPDEST 0E0A 60 PUSH1 0x08 0E0C 54 SLOAD 0E0D 60 PUSH1 0x01 0E0F 60 PUSH1 0x01 0E11 60 PUSH1 0xa0 0E13 1B SHL 0E14 03 SUB 0E15 16 AND 0E16 33 CALLER 0E17 14 EQ 0E18 61 PUSH2 0x0e33 0E1B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e33, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0E1C: // Incoming jump from 0x0E1B, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0E1E memory[0x40:0x60] } 0E1C 60 PUSH1 0x40 0E1E 51 MLOAD 0E1F 62 PUSH3 0x461bcd 0E23 60 PUSH1 0xe5 0E25 1B SHL 0E26 81 DUP2 0E27 52 MSTORE 0E28 60 PUSH1 0x04 0E2A 01 ADD 0E2B 61 PUSH2 0x09a7 0E2E 90 SWAP1 0E2F 61 PUSH2 0x246e 0E32 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E27 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E2E stack[0] = 0x09a7 // @0E2E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x246e, returns to 0x09A7 label_0E33: // Incoming jump from 0x0E1B, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0E36 stack[-1] // @0E37 stack[-2] // } 0E33 5B JUMPDEST 0E34 60 PUSH1 0x0a 0E36 55 SSTORE 0E37 56 *JUMP // Stack delta = -2 // Outputs[1] { @0E36 storage[0x0a] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0E38: // Incoming jump from 0x0583 // Inputs[2] // { // @0E3B storage[0x08] // @0E45 msg.sender // } 0E38 5B JUMPDEST 0E39 60 PUSH1 0x08 0E3B 54 SLOAD 0E3C 60 PUSH1 0x01 0E3E 60 PUSH1 0x01 0E40 60 PUSH1 0xa0 0E42 1B SHL 0E43 03 SUB 0E44 16 AND 0E45 33 CALLER 0E46 14 EQ 0E47 61 PUSH2 0x0e62 0E4A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e62, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0E4B: // Incoming jump from 0x0E4A, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0E4D memory[0x40:0x60] } 0E4B 60 PUSH1 0x40 0E4D 51 MLOAD 0E4E 62 PUSH3 0x461bcd 0E52 60 PUSH1 0xe5 0E54 1B SHL 0E55 81 DUP2 0E56 52 MSTORE 0E57 60 PUSH1 0x04 0E59 01 ADD 0E5A 61 PUSH2 0x09a7 0E5D 90 SWAP1 0E5E 61 PUSH2 0x246e 0E61 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E56 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E5D stack[0] = 0x09a7 // @0E5D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x246e, returns to 0x09A7 label_0E62: // Incoming jump from 0x0E4A, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0E63 stack[-1] // @0E64 memory[stack[-1]:stack[-1] + 0x20] // } 0E62 5B JUMPDEST 0E63 80 DUP1 0E64 51 MLOAD 0E65 61 PUSH2 0x09c3 0E68 90 SWAP1 0E69 60 PUSH1 0x0d 0E6B 90 SWAP1 0E6C 60 PUSH1 0x20 0E6E 84 DUP5 0E6F 01 ADD 0E70 90 SWAP1 0E71 61 PUSH2 0x1f8b 0E74 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E68 stack[0] = 0x09c3 // @0E6B stack[1] = 0x0d // @0E70 stack[2] = stack[-1] + 0x20 // @0E70 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1f8b label_0E75: // Incoming call from 0x05CC, returns to 0x02AB // Inputs[1] { @0E7B storage[0x03] } 0E75 5B JUMPDEST 0E76 60 PUSH1 0x60 0E78 60 PUSH1 0x03 0E7A 80 DUP1 0E7B 54 SLOAD 0E7C 61 PUSH2 0x0828 0E7F 90 SWAP1 0E80 61 PUSH2 0x2433 0E83 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E76 stack[0] = 0x60 // @0E78 stack[1] = 0x03 // @0E7F stack[2] = 0x0828 // @0E7F stack[3] = storage[0x03] // } // Block ends with call to 0x2433, returns to 0x0828 label_0E84: // Incoming jump from 0x05DF // Inputs[1] { @0E85 stack[-1] } 0E84 5B JUMPDEST 0E85 80 DUP1 0E86 60 PUSH1 0x00 0E88 81 DUP2 0E89 11 GT 0E8A 80 DUP1 0E8B 15 ISZERO 0E8C 61 PUSH2 0x0e97 0E8F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0E85 stack[0] = stack[-1] // @0E89 stack[1] = stack[-1] > 0x00 // } // Block ends with conditional jump to 0x0e97, if !(stack[-1] > 0x00) label_0E90: // Incoming jump from 0x0E8F, if not !(stack[-1] > 0x00) // Inputs[2] // { // @0E93 storage[0x12] // @0E94 stack[-2] // } 0E90 50 POP 0E91 60 PUSH1 0x12 0E93 54 SLOAD 0E94 81 DUP2 0E95 11 GT 0E96 15 ISZERO 0E97 5B JUMPDEST 0E98 61 PUSH2 0x0eb3 0E9B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0eb3, if !(stack[-2] > storage[0x12]) label_0E9C: // Incoming jump from 0x0E9B, if not !(stack[-2] > storage[0x12]) // Incoming jump from 0x0E9B, if not stack[-1] // Inputs[1] { @0E9E memory[0x40:0x60] } 0E9C 60 PUSH1 0x40 0E9E 51 MLOAD 0E9F 62 PUSH3 0x461bcd 0EA3 60 PUSH1 0xe5 0EA5 1B SHL 0EA6 81 DUP2 0EA7 52 MSTORE 0EA8 60 PUSH1 0x04 0EAA 01 ADD 0EAB 61 PUSH2 0x09a7 0EAE 90 SWAP1 0EAF 61 PUSH2 0x24ea 0EB2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0EA7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EAE stack[0] = 0x09a7 // @0EAE stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24ea, returns to 0x09A7 label_0EB3: // Incoming jump from 0x0E9B, if !(stack[-2] > storage[0x12]) // Incoming jump from 0x0E9B, if stack[-1] // Inputs[4] // { // @0EB6 storage[0x11] // @0EB7 stack[-1] // @0EBD storage[0x01] // @0EC0 storage[0x00] // } 0EB3 5B JUMPDEST 0EB4 60 PUSH1 0x11 0EB6 54 SLOAD 0EB7 81 DUP2 0EB8 61 PUSH2 0x0ec8 0EBB 60 PUSH1 0x01 0EBD 54 SLOAD 0EBE 60 PUSH1 0x00 0EC0 54 SLOAD 0EC1 03 SUB 0EC2 60 PUSH1 0x00 0EC4 19 NOT 0EC5 01 ADD 0EC6 90 SWAP1 0EC7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0EB6 stack[0] = storage[0x11] // @0EB7 stack[1] = stack[-1] // @0EC6 stack[2] = ~0x00 + (storage[0x00] - storage[0x01]) // } // Block ends with unconditional jump to 0x0ec8 label_0EC8: // Incoming jump from 0x0EC7 // Inputs[2] // { // @0ECC stack[-2] // @0ECD stack[-1] // } 0EC8 5B JUMPDEST 0EC9 61 PUSH2 0x0ed2 0ECC 91 SWAP2 0ECD 90 SWAP1 0ECE 61 PUSH2 0x2518 0ED1 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0ECC stack[-2] = 0x0ed2 // @0ECD stack[-1] = stack[-2] // @0ECD stack[0] = stack[-1] // } // Block ends with call to 0x2518, returns to 0x0ED2 label_0ED2: // Incoming return from call to 0x2518 at 0x0ED1 // Inputs[2] // { // @0ED3 stack[-2] // @0ED3 stack[-1] // } 0ED2 5B JUMPDEST 0ED3 11 GT 0ED4 15 ISZERO 0ED5 61 PUSH2 0x0ef0 0ED8 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0ef0, if !(stack[-1] > stack[-2]) label_0ED9: // Incoming jump from 0x0ED8, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0EDB memory[0x40:0x60] } 0ED9 60 PUSH1 0x40 0EDB 51 MLOAD 0EDC 62 PUSH3 0x461bcd 0EE0 60 PUSH1 0xe5 0EE2 1B SHL 0EE3 81 DUP2 0EE4 52 MSTORE 0EE5 60 PUSH1 0x04 0EE7 01 ADD 0EE8 61 PUSH2 0x09a7 0EEB 90 SWAP1 0EEC 61 PUSH2 0x2530 0EEF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0EE4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EEB stack[0] = 0x09a7 // @0EEB stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2530, returns to 0x09A7 label_0EF0: // Incoming jump from 0x0ED8, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @0EF1 stack[-2] // @0EF5 storage[0x10] // } 0EF0 5B JUMPDEST 0EF1 81 DUP2 0EF2 80 DUP1 0EF3 60 PUSH1 0x10 0EF5 54 SLOAD 0EF6 61 PUSH2 0x0eff 0EF9 91 SWAP2 0EFA 90 SWAP1 0EFB 61 PUSH2 0x255e 0EFE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EF1 stack[0] = stack[-2] // @0EF9 stack[1] = 0x0eff // @0EFA stack[2] = stack[-2] // @0EFA stack[3] = storage[0x10] // } // Block ends with call to 0x255e, returns to 0x0EFF label_0EFF: // Incoming return from call to 0x255E at 0x0EFE // Inputs[2] // { // @0F00 msg.value // @0F01 stack[-1] // } 0EFF 5B JUMPDEST 0F00 34 CALLVALUE 0F01 10 LT 0F02 15 ISZERO 0F03 61 PUSH2 0x0f44 0F06 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f44, if !(msg.value < stack[-1]) label_0F07: // Incoming jump from 0x0F06, if not !(msg.value < stack[-1]) // Inputs[1] { @0F09 memory[0x40:0x60] } 0F07 60 PUSH1 0x40 0F09 51 MLOAD 0F0A 62 PUSH3 0x461bcd 0F0E 60 PUSH1 0xe5 0F10 1B SHL 0F11 81 DUP2 0F12 52 MSTORE 0F13 60 PUSH1 0x20 0F15 60 PUSH1 0x04 0F17 82 DUP3 0F18 01 ADD 0F19 52 MSTORE 0F1A 60 PUSH1 0x13 0F1C 60 PUSH1 0x24 0F1E 82 DUP3 0F1F 01 ADD 0F20 52 MSTORE 0F21 72 PUSH19 0x496e73756666696369656e742066756e647321 0F35 60 PUSH1 0x68 0F37 1B SHL 0F38 60 PUSH1 0x44 0F3A 82 DUP3 0F3B 01 ADD 0F3C 52 MSTORE 0F3D 60 PUSH1 0x64 0F3F 01 ADD 0F40 61 PUSH2 0x09a7 0F43 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0F12 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F19 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F20 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x13 // @0F3C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e73756666696369656e742066756e647321 << 0x68 // @0F3F stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x09a7 label_0F44: // Incoming jump from 0x0F06, if !(msg.value < stack[-1]) // Inputs[1] { @0F47 storage[0x13] } 0F44 5B JUMPDEST 0F45 60 PUSH1 0x13 0F47 54 SLOAD 0F48 60 PUSH1 0xff 0F4A 16 AND 0F4B 15 ISZERO 0F4C 61 PUSH2 0x0f97 0F4F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f97, if !(0xff & storage[0x13]) label_0F50: // Incoming jump from 0x0F4F, if not !(0xff & storage[0x13]) // Inputs[1] { @0F52 memory[0x40:0x60] } 0F50 60 PUSH1 0x40 0F52 51 MLOAD 0F53 62 PUSH3 0x461bcd 0F57 60 PUSH1 0xe5 0F59 1B SHL 0F5A 81 DUP2 0F5B 52 MSTORE 0F5C 60 PUSH1 0x20 0F5E 60 PUSH1 0x04 0F60 82 DUP3 0F61 01 ADD 0F62 52 MSTORE 0F63 60 PUSH1 0x17 0F65 60 PUSH1 0x24 0F67 82 DUP3 0F68 01 ADD 0F69 52 MSTORE 0F6A 7F PUSH32 0x54686520636f6e74726163742069732070617573656421000000000000000000 0F8B 60 PUSH1 0x44 0F8D 82 DUP3 0F8E 01 ADD 0F8F 52 MSTORE 0F90 60 PUSH1 0x64 0F92 01 ADD 0F93 61 PUSH2 0x09a7 0F96 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0F5B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F62 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F69 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x17 // @0F8F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x54686520636f6e74726163742069732070617573656421000000000000000000 // @0F92 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x09a7 label_0F97: // Incoming jump from 0x0F4F, if !(0xff & storage[0x13]) // Inputs[3] // { // @0F98 msg.sender // @0FA6 memory[0x00:0x40] // @0FA7 storage[keccak256(memory[0x00:0x40])] // } 0F97 5B JUMPDEST 0F98 33 CALLER 0F99 60 PUSH1 0x00 0F9B 90 SWAP1 0F9C 81 DUP2 0F9D 52 MSTORE 0F9E 60 PUSH1 0x0c 0FA0 60 PUSH1 0x20 0FA2 52 MSTORE 0FA3 60 PUSH1 0x40 0FA5 90 SWAP1 0FA6 20 SHA3 0FA7 54 SLOAD 0FA8 60 PUSH1 0xff 0FAA 16 AND 0FAB 15 ISZERO 0FAC 61 PUSH2 0x1003 0FAF 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0F9D memory[0x00:0x20] = msg.sender // @0FA2 memory[0x20:0x40] = 0x0c // } // Block ends with conditional jump to 0x1003, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_0FB0: // Incoming jump from 0x0FAF, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0FB2 memory[0x40:0x60] } 0FB0 60 PUSH1 0x40 0FB2 51 MLOAD 0FB3 62 PUSH3 0x461bcd 0FB7 60 PUSH1 0xe5 0FB9 1B SHL 0FBA 81 DUP2 0FBB 52 MSTORE 0FBC 60 PUSH1 0x20 0FBE 60 PUSH1 0x04 0FC0 82 DUP3 0FC1 01 ADD 0FC2 52 MSTORE 0FC3 60 PUSH1 0x24 0FC5 80 DUP1 0FC6 82 DUP3 0FC7 01 ADD 0FC8 52 MSTORE 0FC9 7F PUSH32 0x4164647265737320616c726561647920636c61696d6564207075626c69632073 0FEA 60 PUSH1 0x44 0FEC 82 DUP3 0FED 01 ADD 0FEE 52 MSTORE 0FEF 63 PUSH4 0x616c6521 0FF4 60 PUSH1 0xe0 0FF6 1B SHL 0FF7 60 PUSH1 0x64 0FF9 82 DUP3 0FFA 01 ADD 0FFB 52 MSTORE 0FFC 60 PUSH1 0x84 0FFE 01 ADD 0FFF 61 PUSH2 0x09a7 1002 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0FBB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FC2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0FC8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @0FEE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4164647265737320616c726561647920636c61696d6564207075626c69632073 // @0FFB memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x616c6521 << 0xe0 // @0FFE stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x09a7 label_1003: // Incoming jump from 0x0FAF, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @1004 msg.sender // @1012 memory[0x00:0x40] // @1014 storage[keccak256(memory[0x00:0x40])] // @1022 stack[-3] // } 1003 5B JUMPDEST 1004 33 CALLER 1005 60 PUSH1 0x00 1007 81 DUP2 1008 81 DUP2 1009 52 MSTORE 100A 60 PUSH1 0x0c 100C 60 PUSH1 0x20 100E 52 MSTORE 100F 60 PUSH1 0x40 1011 90 SWAP1 1012 20 SHA3 1013 80 DUP1 1014 54 SLOAD 1015 60 PUSH1 0xff 1017 19 NOT 1018 16 AND 1019 60 PUSH1 0x01 101B 17 OR 101C 90 SWAP1 101D 55 SSTORE 101E 61 PUSH2 0x0978 1021 90 SWAP1 1022 84 DUP5 1023 61 PUSH2 0x1b06 1026 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @1009 memory[0x00:0x20] = msg.sender // @100E memory[0x20:0x40] = 0x0c // @101D storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1021 stack[0] = 0x0978 // @1021 stack[1] = msg.sender // @1022 stack[2] = stack[-3] // } // Block ends with call to 0x1b06, returns to 0x0978 1027 5B JUMPDEST 1028 60 PUSH1 0x01 102A 60 PUSH1 0x01 102C 60 PUSH1 0xa0 102E 1B SHL 102F 03 SUB 1030 82 DUP3 1031 16 AND 1032 33 CALLER 1033 14 EQ 1034 15 ISZERO 1035 61 PUSH2 0x1051 1038 57 *JUMPI 1039 60 PUSH1 0x40 103B 51 MLOAD 103C 63 PUSH4 0xb06307db 1041 60 PUSH1 0xe0 1043 1B SHL 1044 81 DUP2 1045 52 MSTORE 1046 60 PUSH1 0x04 1048 01 ADD 1049 60 PUSH1 0x40 104B 51 MLOAD 104C 80 DUP1 104D 91 SWAP2 104E 03 SUB 104F 90 SWAP1 1050 FD *REVERT 1051 5B JUMPDEST 1052 33 CALLER 1053 60 PUSH1 0x00 1055 81 DUP2 1056 81 DUP2 1057 52 MSTORE 1058 60 PUSH1 0x07 105A 60 PUSH1 0x20 105C 90 SWAP1 105D 81 DUP2 105E 52 MSTORE 105F 60 PUSH1 0x40 1061 80 DUP1 1062 83 DUP4 1063 20 SHA3 1064 60 PUSH1 0x01 1066 60 PUSH1 0x01 1068 60 PUSH1 0xa0 106A 1B SHL 106B 03 SUB 106C 87 DUP8 106D 16 AND 106E 80 DUP1 106F 85 DUP6 1070 52 MSTORE 1071 90 SWAP1 1072 83 DUP4 1073 52 MSTORE 1074 92 SWAP3 1075 81 DUP2 1076 90 SWAP1 1077 20 SHA3 1078 80 DUP1 1079 54 SLOAD 107A 60 PUSH1 0xff 107C 19 NOT 107D 16 AND 107E 86 DUP7 107F 15 ISZERO 1080 15 ISZERO 1081 90 SWAP1 1082 81 DUP2 1083 17 OR 1084 90 SWAP1 1085 91 SWAP2 1086 55 SSTORE 1087 90 SWAP1 1088 51 MLOAD 1089 90 SWAP1 108A 81 DUP2 108B 52 MSTORE 108C 91 SWAP2 108D 92 SWAP3 108E 91 SWAP2 108F 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 10B0 91 SWAP2 10B1 01 ADD 10B2 60 PUSH1 0x40 10B4 51 MLOAD 10B5 80 DUP1 10B6 91 SWAP2 10B7 03 SUB 10B8 90 SWAP1 10B9 A3 LOG3 10BA 50 POP 10BB 50 POP 10BC 56 *JUMP label_10BD: // Incoming call from 0x0614, returns to 0x02AB // Inputs[1] { @10C1 storage[0x0f] } 10BD 5B JUMPDEST 10BE 60 PUSH1 0x0f 10C0 80 DUP1 10C1 54 SLOAD 10C2 61 PUSH2 0x0ce5 10C5 90 SWAP1 10C6 61 PUSH2 0x2433 10C9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10BE stack[0] = 0x0f // @10C5 stack[1] = 0x0ce5 // @10C5 stack[2] = storage[0x0f] // } // Block ends with call to 0x2433, returns to 0x0CE5 label_10CA: // Incoming jump from 0x0634 // Inputs[2] // { // @10CD storage[0x08] // @10D7 msg.sender // } 10CA 5B JUMPDEST 10CB 60 PUSH1 0x08 10CD 54 SLOAD 10CE 60 PUSH1 0x01 10D0 60 PUSH1 0x01 10D2 60 PUSH1 0xa0 10D4 1B SHL 10D5 03 SUB 10D6 16 AND 10D7 33 CALLER 10D8 14 EQ 10D9 61 PUSH2 0x10f4 10DC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10f4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_10DD: // Incoming jump from 0x10DC, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @10DF memory[0x40:0x60] } 10DD 60 PUSH1 0x40 10DF 51 MLOAD 10E0 62 PUSH3 0x461bcd 10E4 60 PUSH1 0xe5 10E6 1B SHL 10E7 81 DUP2 10E8 52 MSTORE 10E9 60 PUSH1 0x04 10EB 01 ADD 10EC 61 PUSH2 0x09a7 10EF 90 SWAP1 10F0 61 PUSH2 0x246e 10F3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @10E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10EF stack[0] = 0x09a7 // @10EF stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x246e, returns to 0x09A7 label_10F4: // Incoming jump from 0x10DC, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @10F7 stack[-1] // @10F8 stack[-2] // } 10F4 5B JUMPDEST 10F5 60 PUSH1 0x12 10F7 55 SSTORE 10F8 56 *JUMP // Stack delta = -2 // Outputs[1] { @10F7 storage[0x12] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_10F9: // Incoming jump from 0x0684 // Inputs[2] // { // @10FC storage[0x08] // @1106 msg.sender // } 10F9 5B JUMPDEST 10FA 60 PUSH1 0x08 10FC 54 SLOAD 10FD 60 PUSH1 0x01 10FF 60 PUSH1 0x01 1101 60 PUSH1 0xa0 1103 1B SHL 1104 03 SUB 1105 16 AND 1106 33 CALLER 1107 14 EQ 1108 61 PUSH2 0x1123 110B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1123, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_110C: // Incoming jump from 0x110B, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @110E memory[0x40:0x60] } 110C 60 PUSH1 0x40 110E 51 MLOAD 110F 62 PUSH3 0x461bcd 1113 60 PUSH1 0xe5 1115 1B SHL 1116 81 DUP2 1117 52 MSTORE 1118 60 PUSH1 0x04 111A 01 ADD 111B 61 PUSH2 0x09a7 111E 90 SWAP1 111F 61 PUSH2 0x246e 1122 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1117 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @111E stack[0] = 0x09a7 // @111E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x246e, returns to 0x09A7 label_1123: // Incoming jump from 0x110B, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @1127 storage[0x13] // @1128 stack[-1] // @113C stack[-2] // } 1123 5B JUMPDEST 1124 60 PUSH1 0x13 1126 80 DUP1 1127 54 SLOAD 1128 91 SWAP2 1129 15 ISZERO 112A 15 ISZERO 112B 61 PUSH2 0x0100 112E 02 MUL 112F 61 PUSH2 0xff00 1132 19 NOT 1133 90 SWAP1 1134 92 SWAP3 1135 16 AND 1136 91 SWAP2 1137 90 SWAP1 1138 91 SWAP2 1139 17 OR 113A 90 SWAP1 113B 55 SSTORE 113C 56 *JUMP // Stack delta = -2 // Outputs[1] { @113B storage[0x13] = (storage[0x13] & ~0xff00) | 0x0100 * !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_113D: // Incoming jump from 0x06A4 // Incoming jump from 0x0B24 // Inputs[3] // { // @1141 stack[-4] // @1142 stack[-3] // @1143 stack[-2] // } 113D 5B JUMPDEST 113E 61 PUSH2 0x1148 1141 84 DUP5 1142 84 DUP5 1143 84 DUP5 1144 61 PUSH2 0x1779 1147 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @113E stack[0] = 0x1148 // @1141 stack[1] = stack[-4] // @1142 stack[2] = stack[-3] // @1143 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1779 1148 5B JUMPDEST 1149 60 PUSH1 0x01 114B 60 PUSH1 0x01 114D 60 PUSH1 0xa0 114F 1B SHL 1150 03 SUB 1151 83 DUP4 1152 16 AND 1153 3B EXTCODESIZE 1154 15 ISZERO 1155 15 ISZERO 1156 80 DUP1 1157 15 ISZERO 1158 61 PUSH2 0x116a 115B 57 *JUMPI 115C 50 POP 115D 61 PUSH2 0x1168 1160 84 DUP5 1161 84 DUP5 1162 84 DUP5 1163 84 DUP5 1164 61 PUSH2 0x1b20 1167 56 *JUMP 1168 5B JUMPDEST 1169 15 ISZERO 116A 5B JUMPDEST 116B 15 ISZERO 116C 61 PUSH2 0x1188 116F 57 *JUMPI 1170 60 PUSH1 0x40 1172 51 MLOAD 1173 63 PUSH4 0x68d2bf6b 1178 60 PUSH1 0xe1 117A 1B SHL 117B 81 DUP2 117C 52 MSTORE 117D 60 PUSH1 0x04 117F 01 ADD 1180 60 PUSH1 0x40 1182 51 MLOAD 1183 80 DUP1 1184 91 SWAP2 1185 03 SUB 1186 90 SWAP1 1187 FD *REVERT label_1188: // Incoming jump from 0x207A, if !(stack[-1] > stack[-4]) // Inputs[1] { @118D stack[-5] } 1188 5B JUMPDEST 1189 50 POP 118A 50 POP 118B 50 POP 118C 50 POP 118D 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_118E: // Incoming jump from 0x06C4 // Inputs[1] { @1194 stack[-1] } 118E 5B JUMPDEST 118F 60 PUSH1 0x60 1191 61 PUSH2 0x1199 1194 82 DUP3 1195 61 PUSH2 0x16e4 1198 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @118F stack[0] = 0x60 // @1191 stack[1] = 0x1199 // @1194 stack[2] = stack[-1] // } // Block ends with call to 0x16e4, returns to 0x1199 label_1199: // Incoming return from call to 0x16E4 at 0x1198 // Inputs[1] { @119D stack[-1] } 1199 5B JUMPDEST 119A 61 PUSH2 0x11fd 119D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x11fd, if stack[-1] label_119E: // Incoming jump from 0x119D, if not stack[-1] // Inputs[1] { @11A0 memory[0x40:0x60] } 119E 60 PUSH1 0x40 11A0 51 MLOAD 11A1 62 PUSH3 0x461bcd 11A5 60 PUSH1 0xe5 11A7 1B SHL 11A8 81 DUP2 11A9 52 MSTORE 11AA 60 PUSH1 0x20 11AC 60 PUSH1 0x04 11AE 82 DUP3 11AF 01 ADD 11B0 52 MSTORE 11B1 60 PUSH1 0x2f 11B3 60 PUSH1 0x24 11B5 82 DUP3 11B6 01 ADD 11B7 52 MSTORE 11B8 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 11D9 60 PUSH1 0x44 11DB 82 DUP3 11DC 01 ADD 11DD 52 MSTORE 11DE 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 11EE 60 PUSH1 0x89 11F0 1B SHL 11F1 60 PUSH1 0x64 11F3 82 DUP3 11F4 01 ADD 11F5 52 MSTORE 11F6 60 PUSH1 0x84 11F8 01 ADD 11F9 61 PUSH2 0x09a7 11FC 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @11A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11B0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11B7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @11DD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @11F5 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3732bc34b9ba32b73a103a37b5b2b7 << 0x89 // @11F8 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x09a7 label_11FD: // Incoming jump from 0x119D, if stack[-1] // Inputs[1] { @1200 storage[0x13] } 11FD 5B JUMPDEST 11FE 60 PUSH1 0x13 1200 54 SLOAD 1201 62 PUSH3 0x010000 1205 90 SWAP1 1206 04 DIV 1207 60 PUSH1 0xff 1209 16 AND 120A 61 PUSH2 0x129f 120D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x129f, if 0xff & storage[0x13] / 0x010000 label_120E: // Incoming jump from 0x120D, if not 0xff & storage[0x13] / 0x010000 // Inputs[1] { @1211 storage[0x0f] } 120E 60 PUSH1 0x0f 1210 80 DUP1 1211 54 SLOAD 1212 61 PUSH2 0x121a 1215 90 SWAP1 1216 61 PUSH2 0x2433 1219 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @120E stack[0] = 0x0f // @1215 stack[1] = 0x121a // @1215 stack[2] = storage[0x0f] // } // Block ends with call to 0x2433, returns to 0x121A label_121A: // Incoming return from call to 0x2433 at 0x1219 // Inputs[4] // { // @121B stack[-1] // @122A memory[0x40:0x60] // @1232 stack[-2] // @123D storage[stack[-2]] // } 121A 5B JUMPDEST 121B 80 DUP1 121C 60 PUSH1 0x1f 121E 01 ADD 121F 60 PUSH1 0x20 1221 80 DUP1 1222 91 SWAP2 1223 04 DIV 1224 02 MUL 1225 60 PUSH1 0x20 1227 01 ADD 1228 60 PUSH1 0x40 122A 51 MLOAD 122B 90 SWAP1 122C 81 DUP2 122D 01 ADD 122E 60 PUSH1 0x40 1230 52 MSTORE 1231 80 DUP1 1232 92 SWAP3 1233 91 SWAP2 1234 90 SWAP1 1235 81 DUP2 1236 81 DUP2 1237 52 MSTORE 1238 60 PUSH1 0x20 123A 01 ADD 123B 82 DUP3 123C 80 DUP1 123D 54 SLOAD 123E 61 PUSH2 0x1246 1241 90 SWAP1 1242 61 PUSH2 0x2433 1245 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @1230 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @1232 stack[-2] = memory[0x40:0x60] // @1233 stack[-1] = stack[-2] // @1234 stack[0] = stack[-1] // @1237 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @123A stack[1] = 0x20 + memory[0x40:0x60] // @123B stack[2] = stack[-2] // @1241 stack[4] = storage[stack[-2]] // @1241 stack[3] = 0x1246 // } // Block ends with call to 0x2433, returns to 0x1246 label_1246: // Incoming return from call to 0x2433 at 0x1245 // Inputs[1] { @1247 stack[-1] } 1246 5B JUMPDEST 1247 80 DUP1 1248 15 ISZERO 1249 61 PUSH2 0x1293 124C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1293, if !stack[-1] label_124D: // Incoming jump from 0x124C, if not !stack[-1] // Inputs[1] { @124D stack[-1] } 124D 80 DUP1 124E 60 PUSH1 0x1f 1250 10 LT 1251 61 PUSH2 0x1268 1254 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1268, if 0x1f < stack[-1] label_1255: // Incoming jump from 0x1254, if not 0x1f < stack[-1] // Inputs[4] // { // @1259 stack[-2] // @125A storage[stack[-2]] // @125D stack[-3] // @125F stack[-1] // } 1255 61 PUSH2 0x0100 1258 80 DUP1 1259 83 DUP4 125A 54 SLOAD 125B 04 DIV 125C 02 MUL 125D 83 DUP4 125E 52 MSTORE 125F 91 SWAP2 1260 60 PUSH1 0x20 1262 01 ADD 1263 91 SWAP2 1264 61 PUSH2 0x1293 1267 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @125E memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1263 stack[-1] = stack[-1] // @1263 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1293 label_1268: // Incoming jump from 0x1254, if 0x1f < stack[-1] // Inputs[5] // { // @1269 stack[-3] // @126A stack[-1] // @126C stack[-2] // @1274 memory[0x00:0x20] // @1278 storage[keccak256(memory[0x00:0x20])] // } 1268 5B JUMPDEST 1269 82 DUP3 126A 01 ADD 126B 91 SWAP2 126C 90 SWAP1 126D 60 PUSH1 0x00 126F 52 MSTORE 1270 60 PUSH1 0x20 1272 60 PUSH1 0x00 1274 20 SHA3 1275 90 SWAP1 1276 5B JUMPDEST 1277 81 DUP2 1278 54 SLOAD 1279 81 DUP2 127A 52 MSTORE 127B 90 SWAP1 127C 60 PUSH1 0x01 127E 01 ADD 127F 90 SWAP1 1280 60 PUSH1 0x20 1282 01 ADD 1283 80 DUP1 1284 83 DUP4 1285 11 GT 1286 61 PUSH2 0x1276 1289 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @126B stack[-3] = stack[-3] + stack[-1] // @126F memory[0x00:0x20] = stack[-2] // @127A memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @127F stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1282 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1276, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_128A: // Incoming jump from 0x1289, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1289, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @128A stack[-3] // @128B stack[-1] // } 128A 82 DUP3 128B 90 SWAP1 128C 03 SUB 128D 60 PUSH1 0x1f 128F 16 AND 1290 82 DUP3 1291 01 ADD 1292 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1292 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1292 stack[-1] = stack[-3] // } // Block continues label_1293: // Incoming jump from 0x124C, if !stack[-1] // Incoming jump from 0x1292 // Incoming jump from 0x1267 // Inputs[4] // { // @1299 stack[-7] // @1299 stack[-6] // @129B stack[-9] // @129C stack[-8] // } 1293 5B JUMPDEST 1294 50 POP 1295 50 POP 1296 50 POP 1297 50 POP 1298 50 POP 1299 90 SWAP1 129A 50 POP 129B 91 SWAP2 129C 90 SWAP1 129D 50 POP 129E 56 *JUMP // Stack delta = -8 // Outputs[1] { @129B stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_129F: // Incoming jump from 0x120D, if 0xff & storage[0x13] / 0x010000 129F 5B JUMPDEST 12A0 60 PUSH1 0x00 12A2 61 PUSH2 0x12a9 12A5 61 PUSH2 0x1c18 12A8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @12A0 stack[0] = 0x00 // @12A2 stack[1] = 0x12a9 // } // Block ends with unconditional jump to 0x1c18 12A9 5B JUMPDEST 12AA 90 SWAP1 12AB 50 POP 12AC 60 PUSH1 0x00 12AE 81 DUP2 12AF 51 MLOAD 12B0 11 GT 12B1 61 PUSH2 0x12c9 12B4 57 *JUMPI 12B5 60 PUSH1 0x40 12B7 51 MLOAD 12B8 80 DUP1 12B9 60 PUSH1 0x20 12BB 01 ADD 12BC 60 PUSH1 0x40 12BE 52 MSTORE 12BF 80 DUP1 12C0 60 PUSH1 0x00 12C2 81 DUP2 12C3 52 MSTORE 12C4 50 POP 12C5 61 PUSH2 0x12f7 12C8 56 *JUMP 12C9 5B JUMPDEST 12CA 80 DUP1 12CB 61 PUSH2 0x12d3 12CE 84 DUP5 12CF 61 PUSH2 0x1c27 12D2 56 *JUMP 12D3 5B JUMPDEST 12D4 60 PUSH1 0x0e 12D6 60 PUSH1 0x40 12D8 51 MLOAD 12D9 60 PUSH1 0x20 12DB 01 ADD 12DC 61 PUSH2 0x12e7 12DF 93 SWAP4 12E0 92 SWAP3 12E1 91 SWAP2 12E2 90 SWAP1 12E3 61 PUSH2 0x257d 12E6 56 *JUMP 12E7 5B JUMPDEST 12E8 60 PUSH1 0x40 12EA 51 MLOAD 12EB 60 PUSH1 0x20 12ED 81 DUP2 12EE 83 DUP4 12EF 03 SUB 12F0 03 SUB 12F1 81 DUP2 12F2 52 MSTORE 12F3 90 SWAP1 12F4 60 PUSH1 0x40 12F6 52 MSTORE label_12F7: // Incoming return from call to 0x2024 at 0x269A // Incoming return from call to 0x2083 at 0x20C1 // Incoming return from call to 0x2024 at 0x2056 // Incoming return from call to 0x21F4 at 0x221E // Incoming return from call to 0x20DB at 0x2275 // Inputs[3] // { // @12F8 stack[-1] // @12F8 stack[-5] // @12F9 stack[-4] // } 12F7 5B JUMPDEST 12F8 93 SWAP4 12F9 92 SWAP3 12FA 50 POP 12FB 50 POP 12FC 50 POP 12FD 56 *JUMP // Stack delta = -4 // Outputs[1] { @12F8 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_12FE: // Incoming jump from 0x06D7 // Inputs[1] { @12FF stack[-3] } 12FE 5B JUMPDEST 12FF 82 DUP3 1300 60 PUSH1 0x00 1302 81 DUP2 1303 11 GT 1304 80 DUP1 1305 15 ISZERO 1306 61 PUSH2 0x1311 1309 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @12FF stack[0] = stack[-3] // @1303 stack[1] = stack[-3] > 0x00 // } // Block ends with conditional jump to 0x1311, if !(stack[-3] > 0x00) label_130A: // Incoming jump from 0x1309, if not !(stack[-3] > 0x00) // Inputs[2] // { // @130D storage[0x12] // @130E stack[-2] // } 130A 50 POP 130B 60 PUSH1 0x12 130D 54 SLOAD 130E 81 DUP2 130F 11 GT 1310 15 ISZERO 1311 5B JUMPDEST 1312 61 PUSH2 0x132d 1315 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x132d, if !(stack[-2] > storage[0x12]) label_1316: // Incoming jump from 0x1315, if not stack[-1] // Incoming jump from 0x1315, if not !(stack[-2] > storage[0x12]) // Inputs[1] { @1318 memory[0x40:0x60] } 1316 60 PUSH1 0x40 1318 51 MLOAD 1319 62 PUSH3 0x461bcd 131D 60 PUSH1 0xe5 131F 1B SHL 1320 81 DUP2 1321 52 MSTORE 1322 60 PUSH1 0x04 1324 01 ADD 1325 61 PUSH2 0x09a7 1328 90 SWAP1 1329 61 PUSH2 0x24ea 132C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1321 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1328 stack[0] = 0x09a7 // @1328 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24ea, returns to 0x09A7 label_132D: // Incoming jump from 0x1315, if stack[-1] // Incoming jump from 0x1315, if !(stack[-2] > storage[0x12]) // Inputs[4] // { // @1330 storage[0x11] // @1331 stack[-1] // @1337 storage[0x01] // @133A storage[0x00] // } 132D 5B JUMPDEST 132E 60 PUSH1 0x11 1330 54 SLOAD 1331 81 DUP2 1332 61 PUSH2 0x1342 1335 60 PUSH1 0x01 1337 54 SLOAD 1338 60 PUSH1 0x00 133A 54 SLOAD 133B 03 SUB 133C 60 PUSH1 0x00 133E 19 NOT 133F 01 ADD 1340 90 SWAP1 1341 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1330 stack[0] = storage[0x11] // @1331 stack[1] = stack[-1] // @1340 stack[2] = ~0x00 + (storage[0x00] - storage[0x01]) // } // Block ends with unconditional jump to 0x1342 label_1342: // Incoming jump from 0x1341 // Inputs[2] // { // @1346 stack[-2] // @1347 stack[-1] // } 1342 5B JUMPDEST 1343 61 PUSH2 0x134c 1346 91 SWAP2 1347 90 SWAP1 1348 61 PUSH2 0x2518 134B 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1346 stack[-2] = 0x134c // @1347 stack[-1] = stack[-2] // @1347 stack[0] = stack[-1] // } // Block ends with call to 0x2518, returns to 0x134C label_134C: // Incoming return from call to 0x2518 at 0x134B // Inputs[2] // { // @134D stack[-1] // @134D stack[-2] // } 134C 5B JUMPDEST 134D 11 GT 134E 15 ISZERO 134F 61 PUSH2 0x136a 1352 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x136a, if !(stack[-1] > stack[-2]) label_1353: // Incoming jump from 0x1352, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1355 memory[0x40:0x60] } 1353 60 PUSH1 0x40 1355 51 MLOAD 1356 62 PUSH3 0x461bcd 135A 60 PUSH1 0xe5 135C 1B SHL 135D 81 DUP2 135E 52 MSTORE 135F 60 PUSH1 0x04 1361 01 ADD 1362 61 PUSH2 0x09a7 1365 90 SWAP1 1366 61 PUSH2 0x2530 1369 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @135E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1365 stack[0] = 0x09a7 // @1365 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2530, returns to 0x09A7 label_136A: // Incoming jump from 0x1352, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @136B stack[-4] // @136F storage[0x10] // } 136A 5B JUMPDEST 136B 83 DUP4 136C 80 DUP1 136D 60 PUSH1 0x10 136F 54 SLOAD 1370 61 PUSH2 0x1379 1373 91 SWAP2 1374 90 SWAP1 1375 61 PUSH2 0x255e 1378 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @136B stack[0] = stack[-4] // @1373 stack[1] = 0x1379 // @1374 stack[2] = stack[-4] // @1374 stack[3] = storage[0x10] // } // Block ends with call to 0x255e, returns to 0x1379 label_1379: // Incoming return from call to 0x255E at 0x1378 // Inputs[2] // { // @137A msg.value // @137B stack[-1] // } 1379 5B JUMPDEST 137A 34 CALLVALUE 137B 10 LT 137C 15 ISZERO 137D 61 PUSH2 0x13be 1380 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x13be, if !(msg.value < stack[-1]) label_1381: // Incoming jump from 0x1380, if not !(msg.value < stack[-1]) // Inputs[1] { @1383 memory[0x40:0x60] } 1381 60 PUSH1 0x40 1383 51 MLOAD 1384 62 PUSH3 0x461bcd 1388 60 PUSH1 0xe5 138A 1B SHL 138B 81 DUP2 138C 52 MSTORE 138D 60 PUSH1 0x20 138F 60 PUSH1 0x04 1391 82 DUP3 1392 01 ADD 1393 52 MSTORE 1394 60 PUSH1 0x13 1396 60 PUSH1 0x24 1398 82 DUP3 1399 01 ADD 139A 52 MSTORE 139B 72 PUSH19 0x496e73756666696369656e742066756e647321 13AF 60 PUSH1 0x68 13B1 1B SHL 13B2 60 PUSH1 0x44 13B4 82 DUP3 13B5 01 ADD 13B6 52 MSTORE 13B7 60 PUSH1 0x64 13B9 01 ADD 13BA 61 PUSH2 0x09a7 13BD 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @138C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1393 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @139A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x13 // @13B6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e73756666696369656e742066756e647321 << 0x68 // @13B9 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x09a7 label_13BE: // Incoming jump from 0x1380, if !(msg.value < stack[-1]) // Inputs[1] { @13C1 storage[0x13] } 13BE 5B JUMPDEST 13BF 60 PUSH1 0x13 13C1 54 SLOAD 13C2 61 PUSH2 0x0100 13C5 90 SWAP1 13C6 04 DIV 13C7 60 PUSH1 0xff 13C9 16 AND 13CA 61 PUSH2 0x1420 13CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1420, if 0xff & storage[0x13] / 0x0100 label_13CE: // Incoming jump from 0x13CD, if not 0xff & storage[0x13] / 0x0100 // Inputs[1] { @13D0 memory[0x40:0x60] } 13CE 60 PUSH1 0x40 13D0 51 MLOAD 13D1 62 PUSH3 0x461bcd 13D5 60 PUSH1 0xe5 13D7 1B SHL 13D8 81 DUP2 13D9 52 MSTORE 13DA 60 PUSH1 0x20 13DC 60 PUSH1 0x04 13DE 82 DUP3 13DF 01 ADD 13E0 52 MSTORE 13E1 60 PUSH1 0x22 13E3 60 PUSH1 0x24 13E5 82 DUP3 13E6 01 ADD 13E7 52 MSTORE 13E8 7F PUSH32 0x5468652077686974656c6973742073616c65206973206e6f7420656e61626c65 1409 60 PUSH1 0x44 140B 82 DUP3 140C 01 ADD 140D 52 MSTORE 140E 61 PUSH2 0x6421 1411 60 PUSH1 0xf0 1413 1B SHL 1414 60 PUSH1 0x64 1416 82 DUP3 1417 01 ADD 1418 52 MSTORE 1419 60 PUSH1 0x84 141B 01 ADD 141C 61 PUSH2 0x09a7 141F 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @13D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13E0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @13E7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @140D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5468652077686974656c6973742073616c65206973206e6f7420656e61626c65 // @1418 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6421 << 0xf0 // @141B stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x09a7 label_1420: // Incoming jump from 0x13CD, if 0xff & storage[0x13] / 0x0100 // Inputs[3] // { // @1421 msg.sender // @142F memory[0x00:0x40] // @1430 storage[keccak256(memory[0x00:0x40])] // } 1420 5B JUMPDEST 1421 33 CALLER 1422 60 PUSH1 0x00 1424 90 SWAP1 1425 81 DUP2 1426 52 MSTORE 1427 60 PUSH1 0x0b 1429 60 PUSH1 0x20 142B 52 MSTORE 142C 60 PUSH1 0x40 142E 90 SWAP1 142F 20 SHA3 1430 54 SLOAD 1431 60 PUSH1 0xff 1433 16 AND 1434 15 ISZERO 1435 61 PUSH2 0x1480 1438 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1426 memory[0x00:0x20] = msg.sender // @142B memory[0x20:0x40] = 0x0b // } // Block ends with conditional jump to 0x1480, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_1439: // Incoming jump from 0x1438, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @143B memory[0x40:0x60] } 1439 60 PUSH1 0x40 143B 51 MLOAD 143C 62 PUSH3 0x461bcd 1440 60 PUSH1 0xe5 1442 1B SHL 1443 81 DUP2 1444 52 MSTORE 1445 60 PUSH1 0x20 1447 60 PUSH1 0x04 1449 82 DUP3 144A 01 ADD 144B 52 MSTORE 144C 60 PUSH1 0x18 144E 60 PUSH1 0x24 1450 82 DUP3 1451 01 ADD 1452 52 MSTORE 1453 7F PUSH32 0x4164647265737320616c726561647920636c61696d6564210000000000000000 1474 60 PUSH1 0x44 1476 82 DUP3 1477 01 ADD 1478 52 MSTORE 1479 60 PUSH1 0x64 147B 01 ADD 147C 61 PUSH2 0x09a7 147F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1444 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @144B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1452 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x18 // @1478 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4164647265737320616c726561647920636c61696d6564210000000000000000 // @147B stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x09a7 label_1480: // Incoming jump from 0x1438, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[10] // { // @1483 memory[0x40:0x60] // @1492 msg.sender // @14A4 memory[0x40:0x60] // @14B2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @14B7 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @14BD stack[-4] // @14BE stack[-3] // @14C9 memory[0x40:0x60] // @14E3 msg.data[stack[-4]:stack[-4] + 0x20 * stack[-3]] // @14F0 storage[0x0a] // } 1480 5B JUMPDEST 1481 60 PUSH1 0x40 1483 51 MLOAD 1484 6B PUSH12 0xffffffffffffffffffffffff 1491 19 NOT 1492 33 CALLER 1493 60 PUSH1 0x60 1495 1B SHL 1496 16 AND 1497 60 PUSH1 0x20 1499 82 DUP3 149A 01 ADD 149B 52 MSTORE 149C 60 PUSH1 0x00 149E 90 SWAP1 149F 60 PUSH1 0x34 14A1 01 ADD 14A2 60 PUSH1 0x40 14A4 51 MLOAD 14A5 60 PUSH1 0x20 14A7 81 DUP2 14A8 83 DUP4 14A9 03 SUB 14AA 03 SUB 14AB 81 DUP2 14AC 52 MSTORE 14AD 90 SWAP1 14AE 60 PUSH1 0x40 14B0 52 MSTORE 14B1 80 DUP1 14B2 51 MLOAD 14B3 90 SWAP1 14B4 60 PUSH1 0x20 14B6 01 ADD 14B7 20 SHA3 14B8 90 SWAP1 14B9 50 POP 14BA 61 PUSH2 0x14fa 14BD 85 DUP6 14BE 85 DUP6 14BF 80 DUP1 14C0 80 DUP1 14C1 60 PUSH1 0x20 14C3 02 MUL 14C4 60 PUSH1 0x20 14C6 01 ADD 14C7 60 PUSH1 0x40 14C9 51 MLOAD 14CA 90 SWAP1 14CB 81 DUP2 14CC 01 ADD 14CD 60 PUSH1 0x40 14CF 52 MSTORE 14D0 80 DUP1 14D1 93 SWAP4 14D2 92 SWAP3 14D3 91 SWAP2 14D4 90 SWAP1 14D5 81 DUP2 14D6 81 DUP2 14D7 52 MSTORE 14D8 60 PUSH1 0x20 14DA 01 ADD 14DB 83 DUP4 14DC 83 DUP4 14DD 60 PUSH1 0x20 14DF 02 MUL 14E0 80 DUP1 14E1 82 DUP3 14E2 84 DUP5 14E3 37 CALLDATACOPY 14E4 60 PUSH1 0x00 14E6 92 SWAP3 14E7 01 ADD 14E8 91 SWAP2 14E9 90 SWAP1 14EA 91 SWAP2 14EB 52 MSTORE 14EC 50 POP 14ED 50 POP 14EE 60 PUSH1 0x0a 14F0 54 SLOAD 14F1 91 SWAP2 14F2 50 POP 14F3 84 DUP5 14F4 90 SWAP1 14F5 50 POP 14F6 61 PUSH2 0x1d24 14F9 56 *JUMP // Stack delta = +5 // Outputs[12] // { // @149B memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (msg.sender << 0x60) & ~0xffffffffffffffffffffffff // @14AC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x34 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @14B0 memory[0x40:0x60] = 0x34 + memory[0x40:0x60] // @14B8 stack[0] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @14BA stack[1] = 0x14fa // @14CF memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-3] // @14D1 stack[2] = memory[0x40:0x60] // @14D7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @14E3 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-3]] = msg.data[stack[-4]:stack[-4] + 0x20 * stack[-3]] // @14EB memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-3]:0x20 + memory[0x40:0x60] + 0x20 * stack[-3] + 0x20] = 0x00 // @14F1 stack[3] = storage[0x0a] // @14F4 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 0x1d24, returns to 0x14FA label_14FA: // Incoming return from call to 0x1D24 at 0x14F9 // Inputs[1] { @14FE stack[-1] } 14FA 5B JUMPDEST 14FB 61 PUSH2 0x1537 14FE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1537, if stack[-1] label_14FF: // Incoming jump from 0x14FE, if not stack[-1] // Inputs[1] { @1501 memory[0x40:0x60] } 14FF 60 PUSH1 0x40 1501 51 MLOAD 1502 62 PUSH3 0x461bcd 1506 60 PUSH1 0xe5 1508 1B SHL 1509 81 DUP2 150A 52 MSTORE 150B 60 PUSH1 0x20 150D 60 PUSH1 0x04 150F 82 DUP3 1510 01 ADD 1511 52 MSTORE 1512 60 PUSH1 0x0e 1514 60 PUSH1 0x24 1516 82 DUP3 1517 01 ADD 1518 52 MSTORE 1519 6D PUSH14 0x496e76616c69642070726f6f6621 1528 60 PUSH1 0x90 152A 1B SHL 152B 60 PUSH1 0x44 152D 82 DUP3 152E 01 ADD 152F 52 MSTORE 1530 60 PUSH1 0x64 1532 01 ADD 1533 61 PUSH2 0x09a7 1536 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @150A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1511 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1518 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @152F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e76616c69642070726f6f6621 << 0x90 // @1532 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x09a7 label_1537: // Incoming jump from 0x14FE, if stack[-1] // Inputs[4] // { // @1538 msg.sender // @1546 memory[0x00:0x40] // @1548 storage[keccak256(memory[0x00:0x40])] // @1556 stack[-6] // } 1537 5B JUMPDEST 1538 33 CALLER 1539 60 PUSH1 0x00 153B 81 DUP2 153C 81 DUP2 153D 52 MSTORE 153E 60 PUSH1 0x0b 1540 60 PUSH1 0x20 1542 52 MSTORE 1543 60 PUSH1 0x40 1545 90 SWAP1 1546 20 SHA3 1547 80 DUP1 1548 54 SLOAD 1549 60 PUSH1 0xff 154B 19 NOT 154C 16 AND 154D 60 PUSH1 0x01 154F 17 OR 1550 90 SWAP1 1551 55 SSTORE 1552 61 PUSH2 0x155b 1555 90 SWAP1 1556 87 DUP8 1557 61 PUSH2 0x1b06 155A 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @153D memory[0x00:0x20] = msg.sender // @1542 memory[0x20:0x40] = 0x0b // @1551 storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1555 stack[0] = 0x155b // @1555 stack[1] = msg.sender // @1556 stack[2] = stack[-6] // } // Block ends with call to 0x1b06, returns to 0x155B label_155B: // Incoming return from call to 0x1B06 at 0x155A // Inputs[1] { @1562 stack[-7] } 155B 5B JUMPDEST 155C 50 POP 155D 50 POP 155E 50 POP 155F 50 POP 1560 50 POP 1561 50 POP 1562 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_1563: // Incoming jump from 0x073D // Inputs[2] // { // @1566 storage[0x08] // @1570 msg.sender // } 1563 5B JUMPDEST 1564 60 PUSH1 0x08 1566 54 SLOAD 1567 60 PUSH1 0x01 1569 60 PUSH1 0x01 156B 60 PUSH1 0xa0 156D 1B SHL 156E 03 SUB 156F 16 AND 1570 33 CALLER 1571 14 EQ 1572 61 PUSH2 0x158d 1575 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x158d, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_1576: // Incoming jump from 0x1575, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @1578 memory[0x40:0x60] } 1576 60 PUSH1 0x40 1578 51 MLOAD 1579 62 PUSH3 0x461bcd 157D 60 PUSH1 0xe5 157F 1B SHL 1580 81 DUP2 1581 52 MSTORE 1582 60 PUSH1 0x04 1584 01 ADD 1585 61 PUSH2 0x09a7 1588 90 SWAP1 1589 61 PUSH2 0x246e 158C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1581 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1588 stack[0] = 0x09a7 // @1588 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x246e, returns to 0x09A7 label_158D: // Incoming jump from 0x1575, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @1591 storage[0x13] // @1592 stack[-1] // @15A8 stack[-2] // } 158D 5B JUMPDEST 158E 60 PUSH1 0x13 1590 80 DUP1 1591 54 SLOAD 1592 91 SWAP2 1593 15 ISZERO 1594 15 ISZERO 1595 62 PUSH3 0x010000 1599 02 MUL 159A 62 PUSH3 0xff0000 159E 19 NOT 159F 90 SWAP1 15A0 92 SWAP3 15A1 16 AND 15A2 91 SWAP2 15A3 90 SWAP1 15A4 91 SWAP2 15A5 17 OR 15A6 90 SWAP1 15A7 55 SSTORE 15A8 56 *JUMP // Stack delta = -2 // Outputs[1] { @15A7 storage[0x13] = (storage[0x13] & ~0xff0000) | 0x010000 * !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_15A9: // Incoming jump from 0x07A6 // Inputs[1] { @15AA stack[-2] } 15A9 5B JUMPDEST 15AA 81 DUP2 15AB 60 PUSH1 0x00 15AD 81 DUP2 15AE 11 GT 15AF 80 DUP1 15B0 15 ISZERO 15B1 61 PUSH2 0x15bc 15B4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @15AA stack[0] = stack[-2] // @15AE stack[1] = stack[-2] > 0x00 // } // Block ends with conditional jump to 0x15bc, if !(stack[-2] > 0x00) label_15B5: // Incoming jump from 0x15B4, if not !(stack[-2] > 0x00) // Inputs[2] // { // @15B8 storage[0x12] // @15B9 stack[-2] // } 15B5 50 POP 15B6 60 PUSH1 0x12 15B8 54 SLOAD 15B9 81 DUP2 15BA 11 GT 15BB 15 ISZERO 15BC 5B JUMPDEST 15BD 61 PUSH2 0x15d8 15C0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x15d8, if !(stack[-2] > storage[0x12]) label_15C1: // Incoming jump from 0x15C0, if not !(stack[-2] > storage[0x12]) // Incoming jump from 0x15C0, if not stack[-1] // Inputs[1] { @15C3 memory[0x40:0x60] } 15C1 60 PUSH1 0x40 15C3 51 MLOAD 15C4 62 PUSH3 0x461bcd 15C8 60 PUSH1 0xe5 15CA 1B SHL 15CB 81 DUP2 15CC 52 MSTORE 15CD 60 PUSH1 0x04 15CF 01 ADD 15D0 61 PUSH2 0x09a7 15D3 90 SWAP1 15D4 61 PUSH2 0x24ea 15D7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @15CC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @15D3 stack[0] = 0x09a7 // @15D3 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24ea, returns to 0x09A7 label_15D8: // Incoming jump from 0x15C0, if !(stack[-2] > storage[0x12]) // Incoming jump from 0x15C0, if stack[-1] // Inputs[4] // { // @15DB storage[0x11] // @15DC stack[-1] // @15E2 storage[0x01] // @15E5 storage[0x00] // } 15D8 5B JUMPDEST 15D9 60 PUSH1 0x11 15DB 54 SLOAD 15DC 81 DUP2 15DD 61 PUSH2 0x15ed 15E0 60 PUSH1 0x01 15E2 54 SLOAD 15E3 60 PUSH1 0x00 15E5 54 SLOAD 15E6 03 SUB 15E7 60 PUSH1 0x00 15E9 19 NOT 15EA 01 ADD 15EB 90 SWAP1 15EC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @15DB stack[0] = storage[0x11] // @15DC stack[1] = stack[-1] // @15EB stack[2] = ~0x00 + (storage[0x00] - storage[0x01]) // } // Block ends with unconditional jump to 0x15ed label_15ED: // Incoming jump from 0x15EC // Inputs[2] // { // @15F1 stack[-2] // @15F2 stack[-1] // } 15ED 5B JUMPDEST 15EE 61 PUSH2 0x15f7 15F1 91 SWAP2 15F2 90 SWAP1 15F3 61 PUSH2 0x2518 15F6 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @15F1 stack[-2] = 0x15f7 // @15F2 stack[-1] = stack[-2] // @15F2 stack[0] = stack[-1] // } // Block ends with call to 0x2518, returns to 0x15F7 label_15F7: // Incoming return from call to 0x2518 at 0x15F6 // Inputs[2] // { // @15F8 stack[-1] // @15F8 stack[-2] // } 15F7 5B JUMPDEST 15F8 11 GT 15F9 15 ISZERO 15FA 61 PUSH2 0x1615 15FD 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1615, if !(stack[-1] > stack[-2]) label_15FE: // Incoming jump from 0x15FD, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1600 memory[0x40:0x60] } 15FE 60 PUSH1 0x40 1600 51 MLOAD 1601 62 PUSH3 0x461bcd 1605 60 PUSH1 0xe5 1607 1B SHL 1608 81 DUP2 1609 52 MSTORE 160A 60 PUSH1 0x04 160C 01 ADD 160D 61 PUSH2 0x09a7 1610 90 SWAP1 1611 61 PUSH2 0x2530 1614 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1609 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1610 stack[0] = 0x09a7 // @1610 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2530, returns to 0x09A7 label_1615: // Incoming jump from 0x15FD, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @1618 storage[0x08] // @1622 msg.sender // } 1615 5B JUMPDEST 1616 60 PUSH1 0x08 1618 54 SLOAD 1619 60 PUSH1 0x01 161B 60 PUSH1 0x01 161D 60 PUSH1 0xa0 161F 1B SHL 1620 03 SUB 1621 16 AND 1622 33 CALLER 1623 14 EQ 1624 61 PUSH2 0x163f 1627 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x163f, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_1628: // Incoming jump from 0x1627, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @162A memory[0x40:0x60] } 1628 60 PUSH1 0x40 162A 51 MLOAD 162B 62 PUSH3 0x461bcd 162F 60 PUSH1 0xe5 1631 1B SHL 1632 81 DUP2 1633 52 MSTORE 1634 60 PUSH1 0x04 1636 01 ADD 1637 61 PUSH2 0x09a7 163A 90 SWAP1 163B 61 PUSH2 0x246e 163E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1633 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @163A stack[0] = 0x09a7 // @163A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x246e, returns to 0x09A7 label_163F: // Incoming jump from 0x1627, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @1643 stack[-2] // @1644 stack[-3] // } 163F 5B JUMPDEST 1640 61 PUSH2 0x0978 1643 82 DUP3 1644 84 DUP5 1645 61 PUSH2 0x1b06 1648 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1640 stack[0] = 0x0978 // @1643 stack[1] = stack[-2] // @1644 stack[2] = stack[-3] // } // Block ends with call to 0x1b06, returns to 0x0978 label_1649: // Incoming jump from 0x07C6 // Inputs[2] // { // @164C storage[0x08] // @1656 msg.sender // } 1649 5B JUMPDEST 164A 60 PUSH1 0x08 164C 54 SLOAD 164D 60 PUSH1 0x01 164F 60 PUSH1 0x01 1651 60 PUSH1 0xa0 1653 1B SHL 1654 03 SUB 1655 16 AND 1656 33 CALLER 1657 14 EQ 1658 61 PUSH2 0x1673 165B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1673, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_165C: // Incoming jump from 0x165B, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @165E memory[0x40:0x60] } 165C 60 PUSH1 0x40 165E 51 MLOAD 165F 62 PUSH3 0x461bcd 1663 60 PUSH1 0xe5 1665 1B SHL 1666 81 DUP2 1667 52 MSTORE 1668 60 PUSH1 0x04 166A 01 ADD 166B 61 PUSH2 0x09a7 166E 90 SWAP1 166F 61 PUSH2 0x246e 1672 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1667 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @166E stack[0] = 0x09a7 // @166E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x246e, returns to 0x09A7 label_1673: // Incoming jump from 0x165B, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @167C stack[-1] } 1673 5B JUMPDEST 1674 60 PUSH1 0x01 1676 60 PUSH1 0x01 1678 60 PUSH1 0xa0 167A 1B SHL 167B 03 SUB 167C 81 DUP2 167D 16 AND 167E 61 PUSH2 0x16d8 1681 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x16d8, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1682: // Incoming jump from 0x1681, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1684 memory[0x40:0x60] } 1682 60 PUSH1 0x40 1684 51 MLOAD 1685 62 PUSH3 0x461bcd 1689 60 PUSH1 0xe5 168B 1B SHL 168C 81 DUP2 168D 52 MSTORE 168E 60 PUSH1 0x20 1690 60 PUSH1 0x04 1692 82 DUP3 1693 01 ADD 1694 52 MSTORE 1695 60 PUSH1 0x26 1697 60 PUSH1 0x24 1699 82 DUP3 169A 01 ADD 169B 52 MSTORE 169C 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 16BD 60 PUSH1 0x44 16BF 82 DUP3 16C0 01 ADD 16C1 52 MSTORE 16C2 65 PUSH6 0x646472657373 16C9 60 PUSH1 0xd0 16CB 1B SHL 16CC 60 PUSH1 0x64 16CE 82 DUP3 16CF 01 ADD 16D0 52 MSTORE 16D1 60 PUSH1 0x84 16D3 01 ADD 16D4 61 PUSH2 0x09a7 16D7 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @168D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1694 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @169B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @16C1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @16D0 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @16D3 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x09a7 label_16D8: // Incoming jump from 0x1681, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @16DC stack[-1] } 16D8 5B JUMPDEST 16D9 61 PUSH2 0x16e1 16DC 81 DUP2 16DD 61 PUSH2 0x1ab4 16E0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @16D9 stack[0] = 0x16e1 // @16DC stack[1] = stack[-1] // } // Block ends with call to 0x1ab4, returns to 0x16E1 label_16E1: // Incoming return from call to 0x1AB4 at 0x16E0 // Incoming jump from 0x2035, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @16E3 stack[-2] } 16E1 5B JUMPDEST 16E2 50 POP 16E3 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_16E4: // Incoming call from 0x08B5, returns to 0x08B6 // Incoming call from 0x1198, returns to 0x1199 // Inputs[1] { @16E7 stack[-1] } 16E4 5B JUMPDEST 16E5 60 PUSH1 0x00 16E7 81 DUP2 16E8 60 PUSH1 0x01 16EA 11 GT 16EB 15 ISZERO 16EC 80 DUP1 16ED 15 ISZERO 16EE 61 PUSH2 0x16f8 16F1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @16E5 stack[0] = 0x00 // @16EB stack[1] = !(0x01 > stack[-1]) // } // Block ends with conditional jump to 0x16f8, if !!(0x01 > stack[-1]) label_16F2: // Incoming jump from 0x16F1, if not !!(0x01 > stack[-1]) // Inputs[2] // { // @16F5 storage[0x00] // @16F6 stack[-3] // } 16F2 50 POP 16F3 60 PUSH1 0x00 16F5 54 SLOAD 16F6 82 DUP3 16F7 10 LT 16F8 5B JUMPDEST 16F9 80 DUP1 16FA 15 ISZERO 16FB 61 PUSH2 0x0813 16FE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @16F7 stack[-1] = stack[-3] < storage[0x00] } // Block ends with conditional jump to 0x0813, if !(stack[-3] < storage[0x00]) label_16FF: // Incoming jump from 0x16FE, if not !(stack[-3] < storage[0x00]) // Incoming jump from 0x16FE, if not !stack[-1] // Inputs[4] // { // @1703 stack[-3] // @170E memory[0x00:0x40] // @170F storage[keccak256(memory[0x00:0x40])] // @171B stack[-4] // } 16FF 50 POP 1700 50 POP 1701 60 PUSH1 0x00 1703 90 SWAP1 1704 81 DUP2 1705 52 MSTORE 1706 60 PUSH1 0x04 1708 60 PUSH1 0x20 170A 52 MSTORE 170B 60 PUSH1 0x40 170D 90 SWAP1 170E 20 SHA3 170F 54 SLOAD 1710 60 PUSH1 0x01 1712 60 PUSH1 0xe0 1714 1B SHL 1715 90 SWAP1 1716 04 DIV 1717 60 PUSH1 0xff 1719 16 AND 171A 15 ISZERO 171B 90 SWAP1 171C 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1705 memory[0x00:0x20] = stack[-3] // @170A memory[0x20:0x40] = 0x04 // @171B stack[-4] = !(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with unconditional jump to stack[-4] label_171D: // Incoming call from 0x0977, returns to 0x0978 // Incoming call from 0x1858, returns to 0x1859 // Inputs[8] // { // @1720 stack[-2] // @172C memory[0x00:0x40] // @172E storage[keccak256(memory[0x00:0x40])] // @1741 stack[-3] // @174B memory[0x40:0x60] // @174F stack[-1] // @1774 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1778 stack[-4] // } 171D 5B JUMPDEST 171E 60 PUSH1 0x00 1720 82 DUP3 1721 81 DUP2 1722 52 MSTORE 1723 60 PUSH1 0x06 1725 60 PUSH1 0x20 1727 52 MSTORE 1728 60 PUSH1 0x40 172A 80 DUP1 172B 82 DUP3 172C 20 SHA3 172D 80 DUP1 172E 54 SLOAD 172F 60 PUSH1 0x01 1731 60 PUSH1 0x01 1733 60 PUSH1 0xa0 1735 1B SHL 1736 03 SUB 1737 19 NOT 1738 16 AND 1739 60 PUSH1 0x01 173B 60 PUSH1 0x01 173D 60 PUSH1 0xa0 173F 1B SHL 1740 03 SUB 1741 87 DUP8 1742 81 DUP2 1743 16 AND 1744 91 SWAP2 1745 82 DUP3 1746 17 OR 1747 90 SWAP1 1748 92 SWAP3 1749 55 SSTORE 174A 91 SWAP2 174B 51 MLOAD 174C 85 DUP6 174D 93 SWAP4 174E 91 SWAP2 174F 85 DUP6 1750 16 AND 1751 91 SWAP2 1752 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1773 91 SWAP2 1774 A4 LOG4 1775 50 POP 1776 50 POP 1777 50 POP 1778 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1722 memory[0x00:0x20] = stack[-2] // @1727 memory[0x20:0x40] = 0x06 // @1749 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1774 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_1779: // Incoming jump from 0x1147 // Incoming jump from 0x0A0E // Inputs[1] { @177F stack[-1] } 1779 5B JUMPDEST 177A 60 PUSH1 0x00 177C 61 PUSH2 0x1784 177F 82 DUP3 1780 61 PUSH2 0x198d 1783 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @177A stack[0] = 0x00 // @177C stack[1] = 0x1784 // @177F stack[2] = stack[-1] // } // Block ends with call to 0x198d, returns to 0x1784 label_1784: // Incoming return from call to 0x198D at 0x1783 // Inputs[4] // { // @1785 stack[-1] // @1786 memory[stack[-1]:stack[-1] + 0x20] // @1788 stack[-2] // @1796 msg.sender // } 1784 5B JUMPDEST 1785 80 DUP1 1786 51 MLOAD 1787 90 SWAP1 1788 91 SWAP2 1789 50 POP 178A 60 PUSH1 0x00 178C 90 SWAP1 178D 60 PUSH1 0x01 178F 60 PUSH1 0x01 1791 60 PUSH1 0xa0 1793 1B SHL 1794 03 SUB 1795 16 AND 1796 33 CALLER 1797 60 PUSH1 0x01 1799 60 PUSH1 0x01 179B 60 PUSH1 0xa0 179D 1B SHL 179E 03 SUB 179F 16 AND 17A0 14 EQ 17A1 80 DUP1 17A2 61 PUSH2 0x17b2 17A5 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1788 stack[-2] = stack[-1] // @178C stack[-1] = 0x00 // @17A0 stack[0] = (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x17b2, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] label_17A6: // Incoming jump from 0x17A5, if not (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @17A7 stack[-3] // @17A8 memory[stack[-3]:stack[-3] + 0x20] // @17AD msg.sender // } 17A6 50 POP 17A7 81 DUP2 17A8 51 MLOAD 17A9 61 PUSH2 0x17b2 17AC 90 SWAP1 17AD 33 CALLER 17AE 61 PUSH2 0x0759 17B1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @17AC stack[0] = memory[stack[-3]:stack[-3] + 0x20] // @17AC stack[-1] = 0x17b2 // @17AD stack[1] = msg.sender // } // Block ends with call to 0x0759, returns to 0x17B2 label_17B2: // Incoming jump from 0x17A5, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] // Incoming return from call to 0x0759 at 0x17B1 // Inputs[1] { @17B3 stack[-1] } 17B2 5B JUMPDEST 17B3 80 DUP1 17B4 61 PUSH2 0x17cd 17B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17cd, if stack[-1] label_17B8: // Incoming jump from 0x17B7, if not stack[-1] // Inputs[2] // { // @17B9 msg.sender // @17BD stack[-4] // } 17B8 50 POP 17B9 33 CALLER 17BA 61 PUSH2 0x17c2 17BD 84 DUP5 17BE 61 PUSH2 0x08ab 17C1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @17B9 stack[-1] = msg.sender // @17BA stack[0] = 0x17c2 // @17BD stack[1] = stack[-4] // } // Block ends with call to 0x08ab, returns to 0x17C2 label_17C2: // Incoming return from call to 0x08AB at 0x17C1 // Inputs[2] // { // @17CB stack[-1] // @17CC stack[-2] // } 17C2 5B JUMPDEST 17C3 60 PUSH1 0x01 17C5 60 PUSH1 0x01 17C7 60 PUSH1 0xa0 17C9 1B SHL 17CA 03 SUB 17CB 16 AND 17CC 14 EQ // Stack delta = -1 // Outputs[1] { @17CC stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_17CD: // Incoming jump from 0x17B7, if stack[-1] // Incoming jump from 0x17CC // Inputs[2] // { // @17CE stack[-1] // @17CE stack[-2] // } 17CD 5B JUMPDEST 17CE 90 SWAP1 17CF 50 POP 17D0 80 DUP1 17D1 61 PUSH2 0x17ed 17D4 57 *JUMPI // Stack delta = -1 // Outputs[1] { @17CE stack[-2] = stack[-1] } // Block ends with conditional jump to 0x17ed, if stack[-1] label_17D5: // Incoming jump from 0x17D4, if not stack[-1] // Inputs[3] // { // @17D7 memory[0x40:0x60] // @17E7 memory[0x40:0x60] // @17EC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 17D5 60 PUSH1 0x40 17D7 51 MLOAD 17D8 63 PUSH4 0x2ce44b5f 17DD 60 PUSH1 0xe1 17DF 1B SHL 17E0 81 DUP2 17E1 52 MSTORE 17E2 60 PUSH1 0x04 17E4 01 ADD 17E5 60 PUSH1 0x40 17E7 51 MLOAD 17E8 80 DUP1 17E9 91 SWAP2 17EA 03 SUB 17EB 90 SWAP1 17EC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @17E1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @17EC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_17ED: // Incoming jump from 0x17D4, if stack[-1] // Inputs[3] // { // @17EE stack[-5] // @17F8 stack[-2] // @17FC memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] // } 17ED 5B JUMPDEST 17EE 84 DUP5 17EF 60 PUSH1 0x01 17F1 60 PUSH1 0x01 17F3 60 PUSH1 0xa0 17F5 1B SHL 17F6 03 SUB 17F7 16 AND 17F8 82 DUP3 17F9 60 PUSH1 0x00 17FB 01 ADD 17FC 51 MLOAD 17FD 60 PUSH1 0x01 17FF 60 PUSH1 0x01 1801 60 PUSH1 0xa0 1803 1B SHL 1804 03 SUB 1805 16 AND 1806 14 EQ 1807 61 PUSH2 0x1822 180A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1822, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] label_180B: // Incoming jump from 0x180A, if not (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @180D memory[0x40:0x60] // @181C memory[0x40:0x60] // @1821 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 180B 60 PUSH1 0x40 180D 51 MLOAD 180E 62 PUSH3 0xa11481 1812 60 PUSH1 0xe8 1814 1B SHL 1815 81 DUP2 1816 52 MSTORE 1817 60 PUSH1 0x04 1819 01 ADD 181A 60 PUSH1 0x40 181C 51 MLOAD 181D 80 DUP1 181E 91 SWAP2 181F 03 SUB 1820 90 SWAP1 1821 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1816 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa11481 << 0xe8 // @1821 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1822: // Incoming jump from 0x180A, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[1] { @182B stack[-4] } 1822 5B JUMPDEST 1823 60 PUSH1 0x01 1825 60 PUSH1 0x01 1827 60 PUSH1 0xa0 1829 1B SHL 182A 03 SUB 182B 84 DUP5 182C 16 AND 182D 61 PUSH2 0x1849 1830 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1849, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1831: // Incoming jump from 0x1830, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1833 memory[0x40:0x60] // @1843 memory[0x40:0x60] // @1848 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1831 60 PUSH1 0x40 1833 51 MLOAD 1834 63 PUSH4 0x3a954ecd 1839 60 PUSH1 0xe2 183B 1B SHL 183C 81 DUP2 183D 52 MSTORE 183E 60 PUSH1 0x04 1840 01 ADD 1841 60 PUSH1 0x40 1843 51 MLOAD 1844 80 DUP1 1845 91 SWAP2 1846 03 SUB 1847 90 SWAP1 1848 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @183D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3a954ecd << 0xe2 // @1848 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1849: // Incoming jump from 0x1830, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @184F stack[-3] // @1850 stack[-2] // @1854 memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] // } 1849 5B JUMPDEST 184A 61 PUSH2 0x1859 184D 60 PUSH1 0x00 184F 84 DUP5 1850 84 DUP5 1851 60 PUSH1 0x00 1853 01 ADD 1854 51 MLOAD 1855 61 PUSH2 0x171d 1858 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @184A stack[0] = 0x1859 // @184D stack[1] = 0x00 // @184F stack[2] = stack[-3] // @1854 stack[3] = memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] // } // Block ends with call to 0x171d, returns to 0x1859 label_1859: // Incoming return from call to 0x171D at 0x1858 // Inputs[12] // { // @1862 stack[-5] // @1875 memory[0x00:0x40] // @1877 storage[keccak256(memory[0x00:0x40])] // @189A stack[-4] // @18A2 memory[0x00:0x40] // @18A4 storage[keccak256(memory[0x00:0x40])] // @18B8 stack[-3] // @18C2 memory[0x00:0x40] // @18C4 storage[keccak256(memory[0x00:0x40])] // @18D7 block.timestamp // @18EA memory[0x00:0x40] // @18EB storage[keccak256(memory[0x00:0x40])] // } 1859 5B JUMPDEST 185A 60 PUSH1 0x01 185C 60 PUSH1 0x01 185E 60 PUSH1 0xa0 1860 1B SHL 1861 03 SUB 1862 85 DUP6 1863 81 DUP2 1864 16 AND 1865 60 PUSH1 0x00 1867 90 SWAP1 1868 81 DUP2 1869 52 MSTORE 186A 60 PUSH1 0x05 186C 60 PUSH1 0x20 186E 90 SWAP1 186F 81 DUP2 1870 52 MSTORE 1871 60 PUSH1 0x40 1873 80 DUP1 1874 83 DUP4 1875 20 SHA3 1876 80 DUP1 1877 54 SLOAD 1878 67 PUSH8 0xffffffffffffffff 1881 19 NOT 1882 80 DUP1 1883 82 DUP3 1884 16 AND 1885 60 PUSH1 0x01 1887 60 PUSH1 0x01 1889 60 PUSH1 0x40 188B 1B SHL 188C 03 SUB 188D 92 SWAP3 188E 83 DUP4 188F 16 AND 1890 60 PUSH1 0x00 1892 19 NOT 1893 01 ADD 1894 83 DUP4 1895 16 AND 1896 17 OR 1897 90 SWAP1 1898 92 SWAP3 1899 55 SSTORE 189A 89 DUP10 189B 86 DUP7 189C 16 AND 189D 80 DUP1 189E 86 DUP7 189F 52 MSTORE 18A0 83 DUP4 18A1 86 DUP7 18A2 20 SHA3 18A3 80 DUP1 18A4 54 SLOAD 18A5 93 SWAP4 18A6 84 DUP5 18A7 16 AND 18A8 93 SWAP4 18A9 83 DUP4 18AA 16 AND 18AB 60 PUSH1 0x01 18AD 90 SWAP1 18AE 81 DUP2 18AF 01 ADD 18B0 84 DUP5 18B1 16 AND 18B2 94 SWAP5 18B3 90 SWAP1 18B4 94 SWAP5 18B5 17 OR 18B6 90 SWAP1 18B7 55 SSTORE 18B8 89 DUP10 18B9 86 DUP7 18BA 52 MSTORE 18BB 60 PUSH1 0x04 18BD 90 SWAP1 18BE 94 SWAP5 18BF 52 MSTORE 18C0 82 DUP3 18C1 85 DUP6 18C2 20 SHA3 18C3 80 DUP1 18C4 54 SLOAD 18C5 60 PUSH1 0x01 18C7 60 PUSH1 0x01 18C9 60 PUSH1 0xe0 18CB 1B SHL 18CC 03 SUB 18CD 19 NOT 18CE 16 AND 18CF 90 SWAP1 18D0 94 SWAP5 18D1 17 OR 18D2 60 PUSH1 0x01 18D4 60 PUSH1 0xa0 18D6 1B SHL 18D7 42 TIMESTAMP 18D8 90 SWAP1 18D9 92 SWAP3 18DA 16 AND 18DB 91 SWAP2 18DC 90 SWAP1 18DD 91 SWAP2 18DE 02 MUL 18DF 17 OR 18E0 90 SWAP1 18E1 92 SWAP3 18E2 55 SSTORE 18E3 90 SWAP1 18E4 86 DUP7 18E5 01 ADD 18E6 80 DUP1 18E7 83 DUP4 18E8 52 MSTORE 18E9 91 SWAP2 18EA 20 SHA3 18EB 54 SLOAD 18EC 90 SWAP1 18ED 91 SWAP2 18EE 16 AND 18EF 61 PUSH2 0x1943 18F2 57 *JUMPI // Stack delta = +1 // Outputs[10] // { // @1869 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1870 memory[0x20:0x40] = 0x05 // @1899 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x40) - 0x01 & ~0x00 + ((0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @189F memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @18B7 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x40) - 0x01 & 0x01 + ((0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @18BA memory[0x00:0x20] = stack[-3] // @18BF memory[0x20:0x40] = 0x04 // @18E2 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x40) - 0x01 & block.timestamp) * (0x01 << 0xa0) | ((0x01 << 0xa0) - 0x01 & stack[-4]) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @18E8 memory[0x00:0x20] = stack[-3] + 0x01 // @18ED stack[0] = stack[-3] + 0x01 // } // Block ends with conditional jump to 0x1943, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_18F3: // Incoming jump from 0x18F2, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @18F5 storage[0x00] // @18F6 stack[-1] // } 18F3 60 PUSH1 0x00 18F5 54 SLOAD 18F6 81 DUP2 18F7 10 LT 18F8 15 ISZERO 18F9 61 PUSH2 0x1943 18FC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1943, if !(stack[-1] < storage[0x00]) label_18FD: // Incoming jump from 0x18FC, if not !(stack[-1] < storage[0x00]) // Inputs[6] // { // @18FD stack[-3] // @18FE memory[stack[-3]:stack[-3] + 0x20] // @1901 stack[-1] // @190F memory[0x00:0x40] // @1911 storage[keccak256(memory[0x00:0x40])] // @1915 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 18FD 82 DUP3 18FE 51 MLOAD 18FF 60 PUSH1 0x00 1901 82 DUP3 1902 81 DUP2 1903 52 MSTORE 1904 60 PUSH1 0x04 1906 60 PUSH1 0x20 1908 90 SWAP1 1909 81 DUP2 190A 52 MSTORE 190B 60 PUSH1 0x40 190D 90 SWAP1 190E 91 SWAP2 190F 20 SHA3 1910 80 DUP1 1911 54 SLOAD 1912 91 SWAP2 1913 86 DUP7 1914 01 ADD 1915 51 MLOAD 1916 60 PUSH1 0x01 1918 60 PUSH1 0x01 191A 60 PUSH1 0x40 191C 1B SHL 191D 03 SUB 191E 16 AND 191F 60 PUSH1 0x01 1921 60 PUSH1 0xa0 1923 1B SHL 1924 02 MUL 1925 60 PUSH1 0x01 1927 60 PUSH1 0x01 1929 60 PUSH1 0xe0 192B 1B SHL 192C 03 SUB 192D 19 NOT 192E 90 SWAP1 192F 92 SWAP3 1930 16 AND 1931 60 PUSH1 0x01 1933 60 PUSH1 0x01 1935 60 PUSH1 0xa0 1937 1B SHL 1938 03 SUB 1939 90 SWAP1 193A 93 SWAP4 193B 16 AND 193C 92 SWAP3 193D 90 SWAP1 193E 92 SWAP3 193F 17 OR 1940 17 OR 1941 90 SWAP1 1942 55 SSTORE // Stack delta = +0 // Outputs[3] // { // @1903 memory[0x00:0x20] = stack[-1] // @190A memory[0x20:0x40] = 0x04 // @1942 storage[keccak256(memory[0x00:0x40])] = (memory[stack[-3]:stack[-3] + 0x20] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * ((0x01 << 0x40) - 0x01 & memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20]) // } // Block continues label_1943: // Incoming jump from 0x18FC, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x18F2, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1942 // Inputs[6] // { // @1945 stack[-4] // @1946 stack[-5] // @1950 stack[-6] // @197D memory[0x40:0x60] // @1980 memory[0x40:0x60] // @1985 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 1943 5B JUMPDEST 1944 50 POP 1945 82 DUP3 1946 84 DUP5 1947 60 PUSH1 0x01 1949 60 PUSH1 0x01 194B 60 PUSH1 0xa0 194D 1B SHL 194E 03 SUB 194F 16 AND 1950 86 DUP7 1951 60 PUSH1 0x01 1953 60 PUSH1 0x01 1955 60 PUSH1 0xa0 1957 1B SHL 1958 03 SUB 1959 16 AND 195A 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 197B 60 PUSH1 0x40 197D 51 MLOAD 197E 60 PUSH1 0x40 1980 51 MLOAD 1981 80 DUP1 1982 91 SWAP2 1983 03 SUB 1984 90 SWAP1 1985 A4 LOG4 // Stack delta = -1 // Outputs[1] { @1985 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5] & (0x01 << 0xa0) - 0x01, stack[-4]]); } // Block continues label_1986: // Incoming jump from 0x1985 // Incoming jump from 0x1F8A // Inputs[1] { @198C stack[-6] } 1986 5B JUMPDEST 1987 50 POP 1988 50 POP 1989 50 POP 198A 50 POP 198B 50 POP 198C 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_198D: // Incoming call from 0x0D7D, returns to 0x0D7E // Incoming call from 0x1783, returns to 0x1784 // Inputs[2] // { // @1991 memory[0x40:0x60] // @19AB stack[-1] // } 198D 5B JUMPDEST 198E 60 PUSH1 0x40 1990 80 DUP1 1991 51 MLOAD 1992 60 PUSH1 0x60 1994 81 DUP2 1995 01 ADD 1996 82 DUP3 1997 52 MSTORE 1998 60 PUSH1 0x00 199A 80 DUP1 199B 82 DUP3 199C 52 MSTORE 199D 60 PUSH1 0x20 199F 82 DUP3 19A0 01 ADD 19A1 81 DUP2 19A2 90 SWAP1 19A3 52 MSTORE 19A4 91 SWAP2 19A5 81 DUP2 19A6 01 ADD 19A7 91 SWAP2 19A8 90 SWAP1 19A9 91 SWAP2 19AA 52 MSTORE 19AB 81 DUP2 19AC 80 DUP1 19AD 60 PUSH1 0x01 19AF 11 GT 19B0 15 ISZERO 19B1 80 DUP1 19B2 15 ISZERO 19B3 61 PUSH2 0x19bd 19B6 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @1997 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @199C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @19A3 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @19A9 stack[0] = memory[0x40:0x60] // @19AA memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @19AB stack[1] = stack[-1] // @19B0 stack[2] = !(0x01 > stack[-1]) // } // Block ends with conditional jump to 0x19bd, if !!(0x01 > stack[-1]) label_19B7: // Incoming jump from 0x19B6, if not !!(0x01 > stack[-1]) // Inputs[2] // { // @19BA storage[0x00] // @19BB stack[-2] // } 19B7 50 POP 19B8 60 PUSH1 0x00 19BA 54 SLOAD 19BB 81 DUP2 19BC 10 LT 19BD 5B JUMPDEST 19BE 15 ISZERO 19BF 61 PUSH2 0x1a9b 19C2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1a9b, if !(stack[-2] < storage[0x00]) label_19C3: // Incoming jump from 0x19C2, if not !(stack[-2] < storage[0x00]) // Incoming jump from 0x19C2, if not !stack[-1] // Inputs[4] // { // @19C5 stack[-1] // @19D4 memory[0x00:0x40] // @19D6 memory[0x40:0x60] // @19DE storage[keccak256(memory[0x00:0x40])] // } 19C3 60 PUSH1 0x00 19C5 81 DUP2 19C6 81 DUP2 19C7 52 MSTORE 19C8 60 PUSH1 0x04 19CA 60 PUSH1 0x20 19CC 90 SWAP1 19CD 81 DUP2 19CE 52 MSTORE 19CF 60 PUSH1 0x40 19D1 91 SWAP2 19D2 82 DUP3 19D3 90 SWAP1 19D4 20 SHA3 19D5 82 DUP3 19D6 51 MLOAD 19D7 60 PUSH1 0x60 19D9 81 DUP2 19DA 01 ADD 19DB 84 DUP5 19DC 52 MSTORE 19DD 90 SWAP1 19DE 54 SLOAD 19DF 60 PUSH1 0x01 19E1 60 PUSH1 0x01 19E3 60 PUSH1 0xa0 19E5 1B SHL 19E6 03 SUB 19E7 81 DUP2 19E8 16 AND 19E9 82 DUP3 19EA 52 MSTORE 19EB 60 PUSH1 0x01 19ED 60 PUSH1 0xa0 19EF 1B SHL 19F0 81 DUP2 19F1 04 DIV 19F2 60 PUSH1 0x01 19F4 60 PUSH1 0x01 19F6 60 PUSH1 0x40 19F8 1B SHL 19F9 03 SUB 19FA 16 AND 19FB 92 SWAP3 19FC 82 DUP3 19FD 01 ADD 19FE 92 SWAP3 19FF 90 SWAP1 1A00 92 SWAP3 1A01 52 MSTORE 1A02 60 PUSH1 0x01 1A04 60 PUSH1 0xe0 1A06 1B SHL 1A07 90 SWAP1 1A08 91 SWAP2 1A09 04 DIV 1A0A 60 PUSH1 0xff 1A0C 16 AND 1A0D 15 ISZERO 1A0E 15 ISZERO 1A0F 91 SWAP2 1A10 81 DUP2 1A11 01 ADD 1A12 82 DUP3 1A13 90 SWAP1 1A14 52 MSTORE 1A15 90 SWAP1 1A16 61 PUSH2 0x1a99 1A19 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @19C7 memory[0x00:0x20] = stack[-1] // @19CE memory[0x20:0x40] = 0x04 // @19DC memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @19EA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @1A01 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @1A14 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // @1A15 stack[0] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x1a99, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) label_1A1A: // Incoming jump from 0x1A19, if not !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // Inputs[2] // { // @1A1A stack[-1] // @1A1B memory[stack[-1]:stack[-1] + 0x20] // } 1A1A 80 DUP1 1A1B 51 MLOAD 1A1C 60 PUSH1 0x01 1A1E 60 PUSH1 0x01 1A20 60 PUSH1 0xa0 1A22 1B SHL 1A23 03 SUB 1A24 16 AND 1A25 15 ISZERO 1A26 61 PUSH2 0x1a30 1A29 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1a30, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) label_1A2A: // Incoming jump from 0x1A29, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @1A2A stack[-1] // @1A2A stack[-5] // @1A2B stack[-4] // } 1A2A 93 SWAP4 1A2B 92 SWAP3 1A2C 50 POP 1A2D 50 POP 1A2E 50 POP 1A2F 56 *JUMP // Stack delta = -4 // Outputs[1] { @1A2A stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1A30: // Incoming jump from 0x1A98 // Incoming jump from 0x1A29, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @1A35 stack[-2] // @1A47 memory[0x00:0x40] // @1A49 memory[0x40:0x60] // @1A51 storage[keccak256(memory[0x00:0x40])] // } 1A30 5B JUMPDEST 1A31 50 POP 1A32 60 PUSH1 0x00 1A34 19 NOT 1A35 01 ADD 1A36 60 PUSH1 0x00 1A38 81 DUP2 1A39 81 DUP2 1A3A 52 MSTORE 1A3B 60 PUSH1 0x04 1A3D 60 PUSH1 0x20 1A3F 90 SWAP1 1A40 81 DUP2 1A41 52 MSTORE 1A42 60 PUSH1 0x40 1A44 91 SWAP2 1A45 82 DUP3 1A46 90 SWAP1 1A47 20 SHA3 1A48 82 DUP3 1A49 51 MLOAD 1A4A 60 PUSH1 0x60 1A4C 81 DUP2 1A4D 01 ADD 1A4E 84 DUP5 1A4F 52 MSTORE 1A50 90 SWAP1 1A51 54 SLOAD 1A52 60 PUSH1 0x01 1A54 60 PUSH1 0x01 1A56 60 PUSH1 0xa0 1A58 1B SHL 1A59 03 SUB 1A5A 81 DUP2 1A5B 16 AND 1A5C 80 DUP1 1A5D 83 DUP4 1A5E 52 MSTORE 1A5F 60 PUSH1 0x01 1A61 60 PUSH1 0xa0 1A63 1B SHL 1A64 82 DUP3 1A65 04 DIV 1A66 60 PUSH1 0x01 1A68 60 PUSH1 0x01 1A6A 60 PUSH1 0x40 1A6C 1B SHL 1A6D 03 SUB 1A6E 16 AND 1A6F 93 SWAP4 1A70 83 DUP4 1A71 01 ADD 1A72 93 SWAP4 1A73 90 SWAP1 1A74 93 SWAP4 1A75 52 MSTORE 1A76 60 PUSH1 0x01 1A78 60 PUSH1 0xe0 1A7A 1B SHL 1A7B 90 SWAP1 1A7C 04 DIV 1A7D 60 PUSH1 0xff 1A7F 16 AND 1A80 15 ISZERO 1A81 15 ISZERO 1A82 92 SWAP3 1A83 81 DUP2 1A84 01 ADD 1A85 92 SWAP3 1A86 90 SWAP1 1A87 92 SWAP3 1A88 52 MSTORE 1A89 15 ISZERO 1A8A 61 PUSH2 0x1a94 1A8D 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @1A35 stack[-2] = ~0x00 + stack[-2] // @1A3A memory[0x00:0x20] = ~0x00 + stack[-2] // @1A41 memory[0x20:0x40] = 0x04 // @1A4F memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1A5E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @1A75 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @1A87 stack[-1] = memory[0x40:0x60] // @1A88 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with conditional jump to 0x1a94, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_1A8E: // Incoming jump from 0x1A8D, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @1A8E stack[-1] // @1A8E stack[-5] // @1A8F stack[-4] // } 1A8E 93 SWAP4 1A8F 92 SWAP3 1A90 50 POP 1A91 50 POP 1A92 50 POP 1A93 56 *JUMP // Stack delta = -4 // Outputs[1] { @1A8E stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1A94: // Incoming jump from 0x1A8D, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) 1A94 5B JUMPDEST 1A95 61 PUSH2 0x1a30 1A98 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1a30 label_1A99: // Incoming jump from 0x1A19, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) 1A99 5B JUMPDEST 1A9A 50 POP // Stack delta = -1 // Block continues label_1A9B: // Incoming jump from 0x1A9A // Incoming jump from 0x19C2, if !(stack[-2] < storage[0x00]) // Incoming jump from 0x19C2, if !stack[-1] // Inputs[3] // { // @1A9E memory[0x40:0x60] // @1AAE memory[0x40:0x60] // @1AB3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1A9B 5B JUMPDEST 1A9C 60 PUSH1 0x40 1A9E 51 MLOAD 1A9F 63 PUSH4 0x6f96cda1 1AA4 60 PUSH1 0xe1 1AA6 1B SHL 1AA7 81 DUP2 1AA8 52 MSTORE 1AA9 60 PUSH1 0x04 1AAB 01 ADD 1AAC 60 PUSH1 0x40 1AAE 51 MLOAD 1AAF 80 DUP1 1AB0 91 SWAP2 1AB1 03 SUB 1AB2 90 SWAP1 1AB3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1AA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @1AB3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1AB4: // Incoming call from 0x16E0, returns to 0x16E1 // Incoming call from 0x0E06, returns to 0x0E07 // Inputs[5] // { // @1AB8 storage[0x08] // @1AC1 stack[-1] // @1AD6 memory[0x40:0x60] // @1B02 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1B05 stack[-2] // } 1AB4 5B JUMPDEST 1AB5 60 PUSH1 0x08 1AB7 80 DUP1 1AB8 54 SLOAD 1AB9 60 PUSH1 0x01 1ABB 60 PUSH1 0x01 1ABD 60 PUSH1 0xa0 1ABF 1B SHL 1AC0 03 SUB 1AC1 83 DUP4 1AC2 81 DUP2 1AC3 16 AND 1AC4 60 PUSH1 0x01 1AC6 60 PUSH1 0x01 1AC8 60 PUSH1 0xa0 1ACA 1B SHL 1ACB 03 SUB 1ACC 19 NOT 1ACD 83 DUP4 1ACE 16 AND 1ACF 81 DUP2 1AD0 17 OR 1AD1 90 SWAP1 1AD2 93 SWAP4 1AD3 55 SSTORE 1AD4 60 PUSH1 0x40 1AD6 51 MLOAD 1AD7 91 SWAP2 1AD8 16 AND 1AD9 91 SWAP2 1ADA 90 SWAP1 1ADB 82 DUP3 1ADC 90 SWAP1 1ADD 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1AFE 90 SWAP1 1AFF 60 PUSH1 0x00 1B01 90 SWAP1 1B02 A3 LOG3 1B03 50 POP 1B04 50 POP 1B05 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1AD3 storage[0x08] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x08] & ~((0x01 << 0xa0) - 0x01)) // @1B02 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x08] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_1B06: // Incoming call from 0x155A, returns to 0x155B // Incoming call from 0x1648, returns to 0x0978 // Incoming call from 0x1026, returns to 0x0978 // Inputs[3] // { // @1B0A stack[-2] // @1B0B stack[-1] // @1B0E memory[0x40:0x60] // } 1B06 5B JUMPDEST 1B07 61 PUSH2 0x09c3 1B0A 82 DUP3 1B0B 82 DUP3 1B0C 60 PUSH1 0x40 1B0E 51 MLOAD 1B0F 80 DUP1 1B10 60 PUSH1 0x20 1B12 01 ADD 1B13 60 PUSH1 0x40 1B15 52 MSTORE 1B16 80 DUP1 1B17 60 PUSH1 0x00 1B19 81 DUP2 1B1A 52 MSTORE 1B1B 50 POP 1B1C 61 PUSH2 0x1d3a 1B1F 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1B07 stack[0] = 0x09c3 // @1B0A stack[1] = stack[-2] // @1B0B stack[2] = stack[-1] // @1B0E stack[3] = memory[0x40:0x60] // @1B15 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1B1A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x1d3a, returns to 0x09C3 label_1B20: // Incoming jump from 0x1F03 // Inputs[6] // { // @1B23 memory[0x40:0x60] // @1B39 stack[-3] // @1B46 msg.sender // @1B48 stack[-4] // @1B4A stack[-2] // @1B4C stack[-1] // } 1B20 5B JUMPDEST 1B21 60 PUSH1 0x40 1B23 51 MLOAD 1B24 63 PUSH4 0x0a85bd01 1B29 60 PUSH1 0xe1 1B2B 1B SHL 1B2C 81 DUP2 1B2D 52 MSTORE 1B2E 60 PUSH1 0x00 1B30 90 SWAP1 1B31 60 PUSH1 0x01 1B33 60 PUSH1 0x01 1B35 60 PUSH1 0xa0 1B37 1B SHL 1B38 03 SUB 1B39 85 DUP6 1B3A 16 AND 1B3B 90 SWAP1 1B3C 63 PUSH4 0x150b7a02 1B41 90 SWAP1 1B42 61 PUSH2 0x1b55 1B45 90 SWAP1 1B46 33 CALLER 1B47 90 SWAP1 1B48 89 DUP10 1B49 90 SWAP1 1B4A 88 DUP9 1B4B 90 SWAP1 1B4C 88 DUP9 1B4D 90 SWAP1 1B4E 60 PUSH1 0x04 1B50 01 ADD 1B51 61 PUSH2 0x2641 1B54 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @1B2D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @1B30 stack[0] = 0x00 // @1B3B stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1B41 stack[2] = 0x150b7a02 // @1B45 stack[3] = 0x1b55 // @1B47 stack[4] = msg.sender // @1B49 stack[5] = stack[-4] // @1B4B stack[6] = stack[-2] // @1B4D stack[7] = stack[-1] // @1B50 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2641, returns to 0x1B55 label_1B55: // Incoming return from call to 0x2641 at 0x1B54 // Inputs[4] // { // @1B5A memory[0x40:0x60] // @1B5C stack[-1] // @1B61 stack[-3] // @1B63 address(stack[-3]).code.length // } 1B55 5B JUMPDEST 1B56 60 PUSH1 0x20 1B58 60 PUSH1 0x40 1B5A 51 MLOAD 1B5B 80 DUP1 1B5C 83 DUP4 1B5D 03 SUB 1B5E 81 DUP2 1B5F 60 PUSH1 0x00 1B61 87 DUP8 1B62 80 DUP1 1B63 3B EXTCODESIZE 1B64 15 ISZERO 1B65 80 DUP1 1B66 15 ISZERO 1B67 61 PUSH2 0x1b6f 1B6A 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @1B56 stack[0] = 0x20 // @1B5A stack[1] = memory[0x40:0x60] // @1B5D stack[2] = stack[-1] - memory[0x40:0x60] // @1B5E stack[3] = memory[0x40:0x60] // @1B5F stack[4] = 0x00 // @1B61 stack[5] = stack[-3] // @1B64 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1b6f, if !!address(stack[-3]).code.length label_1B6B: // Incoming jump from 0x1B6A, if not !!address(stack[-3]).code.length // Inputs[1] { @1B6E memory[0x00:0x00] } 1B6B 60 PUSH1 0x00 1B6D 80 DUP1 1B6E FD *REVERT // Stack delta = +0 // Outputs[1] { @1B6E revert(memory[0x00:0x00]); } // Block terminates label_1B6F: // Incoming jump from 0x1B6A, if !!address(stack[-3]).code.length // Inputs[10] // { // @1B71 msg.gas // @1B72 stack[-6] // @1B72 stack[-4] // @1B72 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1B72 stack[-3] // @1B72 stack[-5] // @1B72 memory[stack[-4]:stack[-4] + stack[-5]] // @1B72 stack[-7] // @1B72 stack[-2] // @1B73 stack[-10] // } 1B6F 5B JUMPDEST 1B70 50 POP 1B71 5A GAS 1B72 F1 CALL 1B73 92 SWAP3 1B74 50 POP 1B75 50 POP 1B76 50 POP 1B77 80 DUP1 1B78 15 ISZERO 1B79 61 PUSH2 0x1b9f 1B7C 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @1B72 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1B73 stack[-10] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1b9f, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1B7D: // Incoming jump from 0x1B7C, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1B81 memory[0x40:0x60] // @1B84 returndata.length // } 1B7D 50 POP 1B7E 60 PUSH1 0x40 1B80 80 DUP1 1B81 51 MLOAD 1B82 60 PUSH1 0x1f 1B84 3D RETURNDATASIZE 1B85 90 SWAP1 1B86 81 DUP2 1B87 01 ADD 1B88 60 PUSH1 0x1f 1B8A 19 NOT 1B8B 16 AND 1B8C 82 DUP3 1B8D 01 ADD 1B8E 90 SWAP1 1B8F 92 SWAP3 1B90 52 MSTORE 1B91 61 PUSH2 0x1b9c 1B94 91 SWAP2 1B95 81 DUP2 1B96 01 ADD 1B97 90 SWAP1 1B98 61 PUSH2 0x267e 1B9B 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1B90 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1B94 stack[-1] = 0x1b9c // @1B97 stack[1] = memory[0x40:0x60] // @1B97 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x267e 1B9C 5B JUMPDEST 1B9D 60 PUSH1 0x01 label_1B9F: // Incoming jump from 0x1B7C, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1BA3 stack[-1] } 1B9F 5B JUMPDEST 1BA0 61 PUSH2 0x1bfa 1BA3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1bfa, if stack[-1] label_1BA4: // Incoming jump from 0x1BA3, if not stack[-1] // Inputs[1] { @1BA4 returndata.length } 1BA4 3D RETURNDATASIZE 1BA5 80 DUP1 1BA6 80 DUP1 1BA7 15 ISZERO 1BA8 61 PUSH2 0x1bcd 1BAB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1BA4 stack[0] = returndata.length // @1BA5 stack[1] = returndata.length // } // Block ends with conditional jump to 0x1bcd, if !returndata.length label_1BAC: // Incoming jump from 0x1BAB, if not !returndata.length // Inputs[6] // { // @1BAE memory[0x40:0x60] // @1BAF stack[-2] // @1BB6 returndata.length // @1BBE returndata.length // @1BC1 returndata.length // @1BC8 returndata[0x00:0x00 + returndata.length] // } 1BAC 60 PUSH1 0x40 1BAE 51 MLOAD 1BAF 91 SWAP2 1BB0 50 POP 1BB1 60 PUSH1 0x1f 1BB3 19 NOT 1BB4 60 PUSH1 0x3f 1BB6 3D RETURNDATASIZE 1BB7 01 ADD 1BB8 16 AND 1BB9 82 DUP3 1BBA 01 ADD 1BBB 60 PUSH1 0x40 1BBD 52 MSTORE 1BBE 3D RETURNDATASIZE 1BBF 82 DUP3 1BC0 52 MSTORE 1BC1 3D RETURNDATASIZE 1BC2 60 PUSH1 0x00 1BC4 60 PUSH1 0x20 1BC6 84 DUP5 1BC7 01 ADD 1BC8 3E RETURNDATACOPY 1BC9 61 PUSH2 0x1bd2 1BCC 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1BAF stack[-2] = memory[0x40:0x60] // @1BBD memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1BC0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1BC8 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1bd2 label_1BCD: // Incoming jump from 0x1BAB, if !returndata.length // Inputs[2] // { // @1BD0 stack[-2] // @1BD5 memory[0x60:0x80] // } 1BCD 5B JUMPDEST 1BCE 60 PUSH1 0x60 1BD0 91 SWAP2 1BD1 50 POP 1BD2 5B JUMPDEST 1BD3 50 POP 1BD4 80 DUP1 1BD5 51 MLOAD 1BD6 61 PUSH2 0x1bf2 1BD9 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1BD0 stack[-2] = 0x60 } // Block ends with conditional jump to 0x1bf2, if memory[0x60:0x80] label_1BDA: // Incoming jump from 0x1BD9, if not memory[0x60:0x80] // Incoming jump from 0x1BD9, if not memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @1BDC memory[0x40:0x60] // @1BEC memory[0x40:0x60] // @1BF1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1BDA 60 PUSH1 0x40 1BDC 51 MLOAD 1BDD 63 PUSH4 0x68d2bf6b 1BE2 60 PUSH1 0xe1 1BE4 1B SHL 1BE5 81 DUP2 1BE6 52 MSTORE 1BE7 60 PUSH1 0x04 1BE9 01 ADD 1BEA 60 PUSH1 0x40 1BEC 51 MLOAD 1BED 80 DUP1 1BEE 91 SWAP2 1BEF 03 SUB 1BF0 90 SWAP1 1BF1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1BE6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @1BF1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1BF2: // Incoming jump from 0x1BD9, if memory[0x60:0x80] // Incoming jump from 0x1BD9, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @1BF3 stack[-1] // @1BF4 memory[stack[-1]:stack[-1] + 0x20] // @1BF9 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 1BF2 5B JUMPDEST 1BF3 80 DUP1 1BF4 51 MLOAD 1BF5 81 DUP2 1BF6 60 PUSH1 0x20 1BF8 01 ADD 1BF9 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BF9 revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_1BFA: // Incoming jump from 0x1BA3, if stack[-1] // Inputs[2] // { // @1C04 stack[-1] // @1C0E stack[-2] // } 1BFA 5B JUMPDEST 1BFB 60 PUSH1 0x01 1BFD 60 PUSH1 0x01 1BFF 60 PUSH1 0xe0 1C01 1B SHL 1C02 03 SUB 1C03 19 NOT 1C04 16 AND 1C05 63 PUSH4 0x0a85bd01 1C0A 60 PUSH1 0xe1 1C0C 1B SHL 1C0D 14 EQ 1C0E 90 SWAP1 1C0F 50 POP // Stack delta = -1 // Outputs[1] { @1C0E stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block continues label_1C10: // Incoming return from call to 0x2137 at 0x21F3 // Incoming jump from 0x1C0F // Inputs[3] // { // @1C11 stack[-6] // @1C11 stack[-1] // @1C12 stack[-5] // } 1C10 5B JUMPDEST 1C11 94 SWAP5 1C12 93 SWAP4 1C13 50 POP 1C14 50 POP 1C15 50 POP 1C16 50 POP 1C17 56 *JUMP // Stack delta = -5 // Outputs[1] { @1C11 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1C18: // Incoming jump from 0x12A8 // Inputs[1] { @1C1E storage[0x0d] } 1C18 5B JUMPDEST 1C19 60 PUSH1 0x60 1C1B 60 PUSH1 0x0d 1C1D 80 DUP1 1C1E 54 SLOAD 1C1F 61 PUSH2 0x0828 1C22 90 SWAP1 1C23 61 PUSH2 0x2433 1C26 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C19 stack[0] = 0x60 // @1C1B stack[1] = 0x0d // @1C22 stack[2] = 0x0828 // @1C22 stack[3] = storage[0x0d] // } // Block ends with call to 0x2433, returns to 0x0828 1C27 5B JUMPDEST 1C28 60 PUSH1 0x60 1C2A 81 DUP2 1C2B 61 PUSH2 0x1c4b 1C2E 57 *JUMPI 1C2F 50 POP 1C30 50 POP 1C31 60 PUSH1 0x40 1C33 80 DUP1 1C34 51 MLOAD 1C35 80 DUP1 1C36 82 DUP3 1C37 01 ADD 1C38 90 SWAP1 1C39 91 SWAP2 1C3A 52 MSTORE 1C3B 60 PUSH1 0x01 1C3D 81 DUP2 1C3E 52 MSTORE 1C3F 60 PUSH1 0x03 1C41 60 PUSH1 0xfc 1C43 1B SHL 1C44 60 PUSH1 0x20 1C46 82 DUP3 1C47 01 ADD 1C48 52 MSTORE 1C49 90 SWAP1 1C4A 56 *JUMP 1C4B 5B JUMPDEST 1C4C 81 DUP2 1C4D 60 PUSH1 0x00 1C4F 5B JUMPDEST 1C50 81 DUP2 1C51 15 ISZERO 1C52 61 PUSH2 0x1c75 1C55 57 *JUMPI 1C56 80 DUP1 1C57 61 PUSH2 0x1c5f 1C5A 81 DUP2 1C5B 61 PUSH2 0x24cf 1C5E 56 *JUMP 1C5F 5B JUMPDEST 1C60 91 SWAP2 1C61 50 POP 1C62 61 PUSH2 0x1c6e 1C65 90 SWAP1 1C66 50 POP 1C67 60 PUSH1 0x0a 1C69 83 DUP4 1C6A 61 PUSH2 0x26b1 1C6D 56 *JUMP 1C6E 5B JUMPDEST 1C6F 91 SWAP2 1C70 50 POP 1C71 61 PUSH2 0x1c4f 1C74 56 *JUMP 1C75 5B JUMPDEST 1C76 60 PUSH1 0x00 1C78 81 DUP2 1C79 60 PUSH1 0x01 1C7B 60 PUSH1 0x01 1C7D 60 PUSH1 0x40 1C7F 1B SHL 1C80 03 SUB 1C81 81 DUP2 1C82 11 GT 1C83 15 ISZERO 1C84 61 PUSH2 0x1c8f 1C87 57 *JUMPI 1C88 61 PUSH2 0x1c8f 1C8B 61 PUSH2 0x2121 1C8E 56 *JUMP 1C8F 5B JUMPDEST 1C90 60 PUSH1 0x40 1C92 51 MLOAD 1C93 90 SWAP1 1C94 80 DUP1 1C95 82 DUP3 1C96 52 MSTORE 1C97 80 DUP1 1C98 60 PUSH1 0x1f 1C9A 01 ADD 1C9B 60 PUSH1 0x1f 1C9D 19 NOT 1C9E 16 AND 1C9F 60 PUSH1 0x20 1CA1 01 ADD 1CA2 82 DUP3 1CA3 01 ADD 1CA4 60 PUSH1 0x40 1CA6 52 MSTORE 1CA7 80 DUP1 1CA8 15 ISZERO 1CA9 61 PUSH2 0x1cb9 1CAC 57 *JUMPI 1CAD 60 PUSH1 0x20 1CAF 82 DUP3 1CB0 01 ADD 1CB1 81 DUP2 1CB2 80 DUP1 1CB3 36 CALLDATASIZE 1CB4 83 DUP4 1CB5 37 CALLDATACOPY 1CB6 01 ADD 1CB7 90 SWAP1 1CB8 50 POP 1CB9 5B JUMPDEST 1CBA 50 POP 1CBB 90 SWAP1 1CBC 50 POP 1CBD 5B JUMPDEST 1CBE 84 DUP5 1CBF 15 ISZERO 1CC0 61 PUSH2 0x1c10 1CC3 57 *JUMPI 1CC4 61 PUSH2 0x1cce 1CC7 60 PUSH1 0x01 1CC9 83 DUP4 1CCA 61 PUSH2 0x26c5 1CCD 56 *JUMP 1CCE 5B JUMPDEST 1CCF 91 SWAP2 1CD0 50 POP 1CD1 61 PUSH2 0x1cdb 1CD4 60 PUSH1 0x0a 1CD6 86 DUP7 1CD7 61 PUSH2 0x26dc 1CDA 56 *JUMP 1CDB 5B JUMPDEST 1CDC 61 PUSH2 0x1ce6 1CDF 90 SWAP1 1CE0 60 PUSH1 0x30 1CE2 61 PUSH2 0x2518 1CE5 56 *JUMP 1CE6 5B JUMPDEST 1CE7 60 PUSH1 0xf8 1CE9 1B SHL 1CEA 81 DUP2 1CEB 83 DUP4 1CEC 81 DUP2 1CED 51 MLOAD 1CEE 81 DUP2 1CEF 10 LT 1CF0 61 PUSH2 0x1cfb 1CF3 57 *JUMPI 1CF4 61 PUSH2 0x1cfb 1CF7 61 PUSH2 0x24a3 1CFA 56 *JUMP 1CFB 5B JUMPDEST 1CFC 60 PUSH1 0x20 1CFE 01 ADD 1CFF 01 ADD 1D00 90 SWAP1 1D01 60 PUSH1 0x01 1D03 60 PUSH1 0x01 1D05 60 PUSH1 0xf8 1D07 1B SHL 1D08 03 SUB 1D09 19 NOT 1D0A 16 AND 1D0B 90 SWAP1 1D0C 81 DUP2 1D0D 60 PUSH1 0x00 1D0F 1A BYTE 1D10 90 SWAP1 1D11 53 MSTORE8 1D12 50 POP 1D13 61 PUSH2 0x1d1d 1D16 60 PUSH1 0x0a 1D18 86 DUP7 1D19 61 PUSH2 0x26b1 1D1C 56 *JUMP 1D1D 5B JUMPDEST 1D1E 94 SWAP5 1D1F 50 POP 1D20 61 PUSH2 0x1cbd 1D23 56 *JUMP label_1D24: // Incoming call from 0x14F9, returns to 0x14FA // Inputs[3] // { // @1D27 stack[-2] // @1D2B stack[-3] // @1D2C stack[-1] // } 1D24 5B JUMPDEST 1D25 60 PUSH1 0x00 1D27 82 DUP3 1D28 61 PUSH2 0x1d31 1D2B 85 DUP6 1D2C 84 DUP5 1D2D 61 PUSH2 0x1d47 1D30 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1D25 stack[0] = 0x00 // @1D27 stack[1] = stack[-2] // @1D28 stack[2] = 0x1d31 // @1D2B stack[3] = stack[-3] // @1D2C stack[4] = stack[-1] // } // Block ends with call to 0x1d47, returns to 0x1D31 label_1D31: // Incoming return from call to 0x1D47 at 0x1D30 // Inputs[4] // { // @1D32 stack[-2] // @1D32 stack[-1] // @1D33 stack[-7] // @1D34 stack[-6] // } 1D31 5B JUMPDEST 1D32 14 EQ 1D33 94 SWAP5 1D34 93 SWAP4 1D35 50 POP 1D36 50 POP 1D37 50 POP 1D38 50 POP 1D39 56 *JUMP // Stack delta = -6 // Outputs[1] { @1D33 stack[-7] = stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-7] label_1D3A: // Incoming call from 0x1B1F, returns to 0x09C3 // Inputs[3] // { // @1D3E stack[-3] // @1D3F stack[-2] // @1D40 stack[-1] // } 1D3A 5B JUMPDEST 1D3B 61 PUSH2 0x0978 1D3E 83 DUP4 1D3F 83 DUP4 1D40 83 DUP4 1D41 60 PUSH1 0x01 1D43 61 PUSH2 0x1dbb 1D46 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1D3B stack[0] = 0x0978 // @1D3E stack[1] = stack[-3] // @1D3F stack[2] = stack[-2] // @1D40 stack[3] = stack[-1] // @1D41 stack[4] = 0x01 // } // Block ends with call to 0x1dbb, returns to 0x0978 label_1D47: // Incoming call from 0x1D30, returns to 0x1D31 // Inputs[3] // { // @1D4A stack[-1] // @1D4D stack[-2] // @1D4E memory[stack[-2]:stack[-2] + 0x20] // } 1D47 5B JUMPDEST 1D48 60 PUSH1 0x00 1D4A 81 DUP2 1D4B 81 DUP2 1D4C 5B JUMPDEST 1D4D 84 DUP5 1D4E 51 MLOAD 1D4F 81 DUP2 1D50 10 LT 1D51 15 ISZERO 1D52 61 PUSH2 0x1db3 1D55 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1D48 stack[0] = 0x00 // @1D4A stack[1] = stack[-1] // @1D4B stack[2] = 0x00 // } // Block ends with conditional jump to 0x1db3, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_1D56: // Incoming jump from 0x1D55, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1D55, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1D58 stack[-5] // @1D59 stack[-1] // @1D5B memory[stack[-5]:stack[-5] + 0x20] // } 1D56 60 PUSH1 0x00 1D58 85 DUP6 1D59 82 DUP3 1D5A 81 DUP2 1D5B 51 MLOAD 1D5C 81 DUP2 1D5D 10 LT 1D5E 61 PUSH2 0x1d69 1D61 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1D56 stack[0] = 0x00 // @1D58 stack[1] = stack[-5] // @1D59 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x1d69, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_1D62: // Incoming jump from 0x1D61, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 1D62 61 PUSH2 0x1d69 1D65 61 PUSH2 0x24a3 1D68 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D62 stack[0] = 0x1d69 } // Block ends with unconditional jump to 0x24a3 label_1D69: // Incoming jump from 0x1D61, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[5] // { // @1D6C stack[-1] // @1D70 stack[-2] // @1D71 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1D72 stack[-3] // @1D75 stack[-5] // } 1D69 5B JUMPDEST 1D6A 60 PUSH1 0x20 1D6C 02 MUL 1D6D 60 PUSH1 0x20 1D6F 01 ADD 1D70 01 ADD 1D71 51 MLOAD 1D72 90 SWAP1 1D73 50 POP 1D74 80 DUP1 1D75 83 DUP4 1D76 11 GT 1D77 61 PUSH2 0x1d8f 1D7A 57 *JUMPI // Stack delta = -2 // Outputs[1] { @1D72 stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with conditional jump to 0x1d8f, if stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_1D7B: // Incoming jump from 0x1D7A, if not stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[3] // { // @1D7D stack[-3] // @1D82 stack[-1] // @1D88 memory[0x00:0x40] // } 1D7B 60 PUSH1 0x00 1D7D 83 DUP4 1D7E 81 DUP2 1D7F 52 MSTORE 1D80 60 PUSH1 0x20 1D82 82 DUP3 1D83 90 SWAP1 1D84 52 MSTORE 1D85 60 PUSH1 0x40 1D87 90 SWAP1 1D88 20 SHA3 1D89 92 SWAP3 1D8A 50 POP 1D8B 61 PUSH2 0x1da0 1D8E 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1D7F memory[0x00:0x20] = stack[-3] // @1D84 memory[0x20:0x40] = stack[-1] // @1D89 stack[-3] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to 0x1da0 label_1D8F: // Incoming jump from 0x1D7A, if stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[4] // { // @1D92 stack[-1] // @1D97 stack[-3] // @1D9D memory[0x00:0x40] // @1DA2 stack[-2] // } 1D8F 5B JUMPDEST 1D90 60 PUSH1 0x00 1D92 81 DUP2 1D93 81 DUP2 1D94 52 MSTORE 1D95 60 PUSH1 0x20 1D97 84 DUP5 1D98 90 SWAP1 1D99 52 MSTORE 1D9A 60 PUSH1 0x40 1D9C 90 SWAP1 1D9D 20 SHA3 1D9E 92 SWAP3 1D9F 50 POP 1DA0 5B JUMPDEST 1DA1 50 POP 1DA2 80 DUP1 1DA3 61 PUSH2 0x1dab 1DA6 81 DUP2 1DA7 61 PUSH2 0x24cf 1DAA 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @1D94 memory[0x00:0x20] = stack[-1] // @1D99 memory[0x20:0x40] = stack[-3] // @1D9E stack[-3] = keccak256(memory[0x00:0x40]) // @1DA2 stack[-1] = stack[-2] // @1DA3 stack[0] = 0x1dab // @1DA6 stack[1] = stack[-2] // } // Block ends with call to 0x24cf, returns to 0x1DAB label_1DAB: // Incoming return from call to 0x24CF at 0x1DAA // Incoming return from call to 0x24CF at 0x1DAA // Inputs[2] // { // @1DAC stack[-1] // @1DAC stack[-3] // } 1DAB 5B JUMPDEST 1DAC 91 SWAP2 1DAD 50 POP 1DAE 50 POP 1DAF 61 PUSH2 0x1d4c 1DB2 56 *JUMP // Stack delta = -2 // Outputs[1] { @1DAC stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1d4c label_1DB3: // Incoming jump from 0x1D55, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1D55, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1DB5 stack[-6] // @1DB5 stack[-2] // @1DB6 stack[-5] // } 1DB3 5B JUMPDEST 1DB4 50 POP 1DB5 93 SWAP4 1DB6 92 SWAP3 1DB7 50 POP 1DB8 50 POP 1DB9 50 POP 1DBA 56 *JUMP // Stack delta = -5 // Outputs[1] { @1DB5 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_1DBB: // Incoming call from 0x1D46, returns to 0x0978 // Inputs[2] // { // @1DBE storage[0x00] // @1DC7 stack[-4] // } 1DBB 5B JUMPDEST 1DBC 60 PUSH1 0x00 1DBE 54 SLOAD 1DBF 60 PUSH1 0x01 1DC1 60 PUSH1 0x01 1DC3 60 PUSH1 0xa0 1DC5 1B SHL 1DC6 03 SUB 1DC7 85 DUP6 1DC8 16 AND 1DC9 61 PUSH2 0x1de4 1DCC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DBE stack[0] = storage[0x00] } // Block ends with conditional jump to 0x1de4, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1DCD: // Incoming jump from 0x1DCC, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1DCF memory[0x40:0x60] // @1DDE memory[0x40:0x60] // @1DE3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1DCD 60 PUSH1 0x40 1DCF 51 MLOAD 1DD0 62 PUSH3 0x2e0763 1DD4 60 PUSH1 0xe8 1DD6 1B SHL 1DD7 81 DUP2 1DD8 52 MSTORE 1DD9 60 PUSH1 0x04 1DDB 01 ADD 1DDC 60 PUSH1 0x40 1DDE 51 MLOAD 1DDF 80 DUP1 1DE0 91 SWAP2 1DE1 03 SUB 1DE2 90 SWAP1 1DE3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1DD8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e0763 << 0xe8 // @1DE3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1DE4: // Incoming jump from 0x1DCC, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1DE5 stack[-4] } 1DE4 5B JUMPDEST 1DE5 83 DUP4 1DE6 61 PUSH2 0x1e02 1DE9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e02, if stack[-4] label_1DEA: // Incoming jump from 0x1DE9, if not stack[-4] // Inputs[3] // { // @1DEC memory[0x40:0x60] // @1DFC memory[0x40:0x60] // @1E01 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1DEA 60 PUSH1 0x40 1DEC 51 MLOAD 1DED 63 PUSH4 0xb562e8dd 1DF2 60 PUSH1 0xe0 1DF4 1B SHL 1DF5 81 DUP2 1DF6 52 MSTORE 1DF7 60 PUSH1 0x04 1DF9 01 ADD 1DFA 60 PUSH1 0x40 1DFC 51 MLOAD 1DFD 80 DUP1 1DFE 91 SWAP2 1DFF 03 SUB 1E00 90 SWAP1 1E01 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1DF6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd << 0xe0 // @1E01 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1E02: // Incoming jump from 0x1DE9, if stack[-4] // Inputs[9] // { // @1E0B stack[-5] // @1E1D memory[0x00:0x40] // @1E1F storage[keccak256(memory[0x00:0x40])] // @1E3F stack[-4] // @1E70 stack[-1] // @1E7A memory[0x00:0x40] // @1E7C storage[keccak256(memory[0x00:0x40])] // @1E8F block.timestamp // @1E9E stack[-2] // } 1E02 5B JUMPDEST 1E03 60 PUSH1 0x01 1E05 60 PUSH1 0x01 1E07 60 PUSH1 0xa0 1E09 1B SHL 1E0A 03 SUB 1E0B 85 DUP6 1E0C 16 AND 1E0D 60 PUSH1 0x00 1E0F 81 DUP2 1E10 81 DUP2 1E11 52 MSTORE 1E12 60 PUSH1 0x05 1E14 60 PUSH1 0x20 1E16 90 SWAP1 1E17 81 DUP2 1E18 52 MSTORE 1E19 60 PUSH1 0x40 1E1B 80 DUP1 1E1C 83 DUP4 1E1D 20 SHA3 1E1E 80 DUP1 1E1F 54 SLOAD 1E20 6F PUSH16 0xffffffffffffffffffffffffffffffff 1E31 19 NOT 1E32 81 DUP2 1E33 16 AND 1E34 60 PUSH1 0x01 1E36 60 PUSH1 0x01 1E38 60 PUSH1 0x40 1E3A 1B SHL 1E3B 03 SUB 1E3C 80 DUP1 1E3D 83 DUP4 1E3E 16 AND 1E3F 8C DUP13 1E40 01 ADD 1E41 81 DUP2 1E42 16 AND 1E43 91 SWAP2 1E44 82 DUP3 1E45 17 OR 1E46 68 PUSH9 0x010000000000000000 1E50 67 PUSH8 0xffffffffffffffff 1E59 19 NOT 1E5A 90 SWAP1 1E5B 94 SWAP5 1E5C 16 AND 1E5D 90 SWAP1 1E5E 92 SWAP3 1E5F 17 OR 1E60 83 DUP4 1E61 90 SWAP1 1E62 04 DIV 1E63 81 DUP2 1E64 16 AND 1E65 8C DUP13 1E66 01 ADD 1E67 81 DUP2 1E68 16 AND 1E69 90 SWAP1 1E6A 92 SWAP3 1E6B 02 MUL 1E6C 17 OR 1E6D 90 SWAP1 1E6E 91 SWAP2 1E6F 55 SSTORE 1E70 85 DUP6 1E71 84 DUP5 1E72 52 MSTORE 1E73 60 PUSH1 0x04 1E75 90 SWAP1 1E76 92 SWAP3 1E77 52 MSTORE 1E78 90 SWAP1 1E79 91 SWAP2 1E7A 20 SHA3 1E7B 80 DUP1 1E7C 54 SLOAD 1E7D 60 PUSH1 0x01 1E7F 60 PUSH1 0x01 1E81 60 PUSH1 0xe0 1E83 1B SHL 1E84 03 SUB 1E85 19 NOT 1E86 16 AND 1E87 90 SWAP1 1E88 92 SWAP3 1E89 17 OR 1E8A 60 PUSH1 0x01 1E8C 60 PUSH1 0xa0 1E8E 1B SHL 1E8F 42 TIMESTAMP 1E90 90 SWAP1 1E91 92 SWAP3 1E92 16 AND 1E93 91 SWAP2 1E94 90 SWAP1 1E95 91 SWAP2 1E96 02 MUL 1E97 17 OR 1E98 90 SWAP1 1E99 55 SSTORE 1E9A 80 DUP1 1E9B 80 DUP1 1E9C 85 DUP6 1E9D 01 ADD 1E9E 83 DUP4 1E9F 80 DUP1 1EA0 15 ISZERO 1EA1 61 PUSH2 0x1eb3 1EA4 57 *JUMPI // Stack delta = +3 // Outputs[9] // { // @1E11 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1E18 memory[0x20:0x40] = 0x05 // @1E6F storage[keccak256(memory[0x00:0x40])] = 0x010000000000000000 * ((0x01 << 0x40) - 0x01 & stack[-4] + ((0x01 << 0x40) - 0x01 & (((0x01 << 0x40) - 0x01 & stack[-4] + (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0x40) - 0x01)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff)) / 0x010000000000000000)) | ((0x01 << 0x40) - 0x01 & stack[-4] + (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0x40) - 0x01)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffffffffffffffffffff) // @1E72 memory[0x00:0x20] = stack[-1] // @1E77 memory[0x20:0x40] = 0x04 // @1E99 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x40) - 0x01 & block.timestamp) * (0x01 << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1E9A stack[0] = stack[-1] // @1E9D stack[1] = stack[-4] + stack[-1] // @1E9E stack[2] = stack[-2] // } // Block ends with conditional jump to 0x1eb3, if !stack[-2] label_1EA5: // Incoming jump from 0x1EA4, if not !stack[-2] // Inputs[2] // { // @1EAE stack[-8] // @1EB0 address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // } 1EA5 50 POP 1EA6 60 PUSH1 0x01 1EA8 60 PUSH1 0x01 1EAA 60 PUSH1 0xa0 1EAC 1B SHL 1EAD 03 SUB 1EAE 87 DUP8 1EAF 16 AND 1EB0 3B EXTCODESIZE 1EB1 15 ISZERO 1EB2 15 ISZERO 1EB3 5B JUMPDEST 1EB4 15 ISZERO 1EB5 61 PUSH2 0x1f3c 1EB8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1f3c, if !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length label_1EB9: // Incoming jump from 0x1EB8, if not !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Incoming jump from 0x1EB8, if not !stack[-1] // Inputs[5] // { // @1EBC memory[0x40:0x60] // @1EBD stack[-2] // @1EC7 stack[-7] // @1EF1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1EFF stack[-5] // } 1EB9 5B JUMPDEST 1EBA 60 PUSH1 0x40 1EBC 51 MLOAD 1EBD 82 DUP3 1EBE 90 SWAP1 1EBF 60 PUSH1 0x01 1EC1 60 PUSH1 0x01 1EC3 60 PUSH1 0xa0 1EC5 1B SHL 1EC6 03 SUB 1EC7 89 DUP10 1EC8 16 AND 1EC9 90 SWAP1 1ECA 60 PUSH1 0x00 1ECC 90 SWAP1 1ECD 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1EEE 90 SWAP1 1EEF 82 DUP3 1EF0 90 SWAP1 1EF1 A4 LOG4 1EF2 61 PUSH2 0x1f04 1EF5 60 PUSH1 0x00 1EF7 88 DUP9 1EF8 84 DUP5 1EF9 80 DUP1 1EFA 60 PUSH1 0x01 1EFC 01 ADD 1EFD 95 SWAP6 1EFE 50 POP 1EFF 88 DUP9 1F00 61 PUSH2 0x1b20 1F03 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1EF1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // @1EF2 stack[0] = 0x1f04 // @1EF5 stack[1] = 0x00 // @1EF7 stack[2] = stack[-7] // @1EF8 stack[3] = stack[-2] // @1EFD stack[-2] = 0x01 + stack[-2] // @1EFF stack[4] = stack[-5] // } // Block ends with unconditional jump to 0x1b20 1F04 5B JUMPDEST 1F05 61 PUSH2 0x1f21 1F08 57 *JUMPI 1F09 60 PUSH1 0x40 1F0B 51 MLOAD 1F0C 63 PUSH4 0x68d2bf6b 1F11 60 PUSH1 0xe1 1F13 1B SHL 1F14 81 DUP2 1F15 52 MSTORE 1F16 60 PUSH1 0x04 1F18 01 ADD 1F19 60 PUSH1 0x40 1F1B 51 MLOAD 1F1C 80 DUP1 1F1D 91 SWAP2 1F1E 03 SUB 1F1F 90 SWAP1 1F20 FD *REVERT 1F21 5B JUMPDEST 1F22 80 DUP1 1F23 82 DUP3 1F24 14 EQ 1F25 15 ISZERO 1F26 61 PUSH2 0x1eb9 1F29 57 *JUMPI 1F2A 82 DUP3 1F2B 60 PUSH1 0x00 1F2D 54 SLOAD 1F2E 14 EQ 1F2F 61 PUSH2 0x1f37 1F32 57 *JUMPI 1F33 60 PUSH1 0x00 1F35 80 DUP1 1F36 FD *REVERT 1F37 5B JUMPDEST 1F38 61 PUSH2 0x1f82 1F3B 56 *JUMP label_1F3C: // Incoming jump from 0x1EB8, if !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Incoming jump from 0x1EB8, if !stack[-1] // Inputs[5] // { // @1F40 memory[0x40:0x60] // @1F43 stack[-2] // @1F4F stack[-7] // @1F79 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1F7A stack[-1] // } 1F3C 5B JUMPDEST 1F3D 5B JUMPDEST 1F3E 60 PUSH1 0x40 1F40 51 MLOAD 1F41 60 PUSH1 0x01 1F43 83 DUP4 1F44 01 ADD 1F45 92 SWAP3 1F46 90 SWAP1 1F47 60 PUSH1 0x01 1F49 60 PUSH1 0x01 1F4B 60 PUSH1 0xa0 1F4D 1B SHL 1F4E 03 SUB 1F4F 89 DUP10 1F50 16 AND 1F51 90 SWAP1 1F52 60 PUSH1 0x00 1F54 90 SWAP1 1F55 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1F76 90 SWAP1 1F77 82 DUP3 1F78 90 SWAP1 1F79 A4 LOG4 1F7A 80 DUP1 1F7B 82 DUP3 1F7C 14 EQ 1F7D 15 ISZERO 1F7E 61 PUSH2 0x1f3d 1F81 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1F45 stack[-2] = stack[-2] + 0x01 // @1F79 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with conditional jump to 0x1f3d, if !(stack[-2] + 0x01 == stack[-1]) label_1F82: // Incoming jump from 0x1F81, if not !(stack[-2] + 0x01 == stack[-1]) // Incoming jump from 0x1F81, if not !(stack[-2] + 0x01 == stack[-1]) // Inputs[1] { @1F86 stack[-2] } 1F82 5B JUMPDEST 1F83 50 POP 1F84 60 PUSH1 0x00 1F86 55 SSTORE 1F87 61 PUSH2 0x1986 1F8A 56 *JUMP // Stack delta = -2 // Outputs[1] { @1F86 storage[0x00] = stack[-2] } // Block ends with unconditional jump to 0x1986 label_1F8B: // Incoming jump from 0x0E74 // Incoming jump from 0x09C2 // Incoming jump from 0x0CD7 // Inputs[2] // { // @1F8C stack[-3] // @1F8E storage[stack[-3]] // } 1F8B 5B JUMPDEST 1F8C 82 DUP3 1F8D 80 DUP1 1F8E 54 SLOAD 1F8F 61 PUSH2 0x1f97 1F92 90 SWAP1 1F93 61 PUSH2 0x2433 1F96 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F8C stack[0] = stack[-3] // @1F92 stack[1] = 0x1f97 // @1F92 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x2433, returns to 0x1F97 label_1F97: // Incoming return from call to 0x2433 at 0x1F96 // Inputs[5] // { // @1F98 stack[-1] // @1F98 stack[-2] // @1FA0 memory[0x00:0x20] // @1FAB stack[-4] // @1FAC stack[-3] // } 1F97 5B JUMPDEST 1F98 90 SWAP1 1F99 60 PUSH1 0x00 1F9B 52 MSTORE 1F9C 60 PUSH1 0x20 1F9E 60 PUSH1 0x00 1FA0 20 SHA3 1FA1 90 SWAP1 1FA2 60 PUSH1 0x1f 1FA4 01 ADD 1FA5 60 PUSH1 0x20 1FA7 90 SWAP1 1FA8 04 DIV 1FA9 81 DUP2 1FAA 01 ADD 1FAB 92 SWAP3 1FAC 82 DUP3 1FAD 61 PUSH2 0x1fb9 1FB0 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1F9B memory[0x00:0x20] = stack[-2] // @1FA1 stack[-2] = keccak256(memory[0x00:0x20]) // @1FAB stack[-1] = stack[-4] // @1FAB stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x1fb9, if stack[-3] label_1FB1: // Incoming jump from 0x1FB0, if not stack[-3] // Inputs[1] { @1FB3 stack[-5] } 1FB1 60 PUSH1 0x00 1FB3 85 DUP6 1FB4 55 SSTORE 1FB5 61 PUSH2 0x1fff 1FB8 56 *JUMP // Stack delta = +0 // Outputs[1] { @1FB4 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x1fff label_1FB9: // Incoming jump from 0x1FB0, if stack[-3] // Inputs[1] { @1FBA stack[-3] } 1FB9 5B JUMPDEST 1FBA 82 DUP3 1FBB 60 PUSH1 0x1f 1FBD 10 LT 1FBE 61 PUSH2 0x1fd2 1FC1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1fd2, if 0x1f < stack[-3] label_1FC2: // Incoming jump from 0x1FC1, if not 0x1f < stack[-3] // Inputs[4] // { // @1FC2 stack[-1] // @1FC3 memory[stack[-1]:stack[-1] + 0x20] // @1FC8 stack[-3] // @1FCC stack[-5] // } 1FC2 80 DUP1 1FC3 51 MLOAD 1FC4 60 PUSH1 0xff 1FC6 19 NOT 1FC7 16 AND 1FC8 83 DUP4 1FC9 80 DUP1 1FCA 01 ADD 1FCB 17 OR 1FCC 85 DUP6 1FCD 55 SSTORE 1FCE 61 PUSH2 0x1fff 1FD1 56 *JUMP // Stack delta = +0 // Outputs[1] { @1FCD storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x1fff label_1FD2: // Incoming jump from 0x1FC1, if 0x1f < stack[-3] // Inputs[2] // { // @1FD3 stack[-3] // @1FD9 stack[-5] // } 1FD2 5B JUMPDEST 1FD3 82 DUP3 1FD4 80 DUP1 1FD5 01 ADD 1FD6 60 PUSH1 0x01 1FD8 01 ADD 1FD9 85 DUP6 1FDA 55 SSTORE 1FDB 82 DUP3 1FDC 15 ISZERO 1FDD 61 PUSH2 0x1fff 1FE0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1FDA storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1fff, if !stack[-3] label_1FE1: // Incoming jump from 0x1FE0, if not !stack[-3] // Inputs[2] // { // @1FE1 stack[-3] // @1FE1 stack[-1] // } 1FE1 91 SWAP2 1FE2 82 DUP3 1FE3 01 ADD 1FE4 5B JUMPDEST 1FE5 82 DUP3 1FE6 81 DUP2 1FE7 11 GT 1FE8 15 ISZERO 1FE9 61 PUSH2 0x1fff 1FEC 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1FE1 stack[-3] = stack[-1] // @1FE3 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1fff, if !(stack[-1] + stack[-3] > stack[-1]) label_1FED: // Incoming jump from 0x1FEC, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1FEC, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @1FED stack[-3] // @1FEE memory[stack[-3]:stack[-3] + 0x20] // @1FEF stack[-2] // @1FF1 stack[-1] // } 1FED 82 DUP3 1FEE 51 MLOAD 1FEF 82 DUP3 1FF0 55 SSTORE 1FF1 91 SWAP2 1FF2 60 PUSH1 0x20 1FF4 01 ADD 1FF5 91 SWAP2 1FF6 90 SWAP1 1FF7 60 PUSH1 0x01 1FF9 01 ADD 1FFA 90 SWAP1 1FFB 61 PUSH2 0x1fe4 1FFE 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1FF0 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1FF5 stack[-3] = 0x20 + stack[-3] // @1FFA stack[-2] = 0x01 + stack[-2] // @1FFA stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1fe4 label_1FFF: // Incoming jump from 0x1FEC, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1FD1 // Incoming jump from 0x1FB8 // Incoming jump from 0x1FE0, if !stack[-3] // Incoming jump from 0x1FEC, if !(stack[-1] > stack[-3]) // Inputs[2] // { // @2004 stack[-4] // @2005 stack[-3] // } 1FFF 5B JUMPDEST 2000 50 POP 2001 61 PUSH2 0x200b 2004 92 SWAP3 2005 91 SWAP2 2006 50 POP 2007 61 PUSH2 0x200f 200A 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2004 stack[-4] = 0x200b // @2005 stack[-3] = stack[-4] // } // Block ends with call to 0x200f, returns to 0x200B label_200B: // Incoming jump from 0x2018, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x200F at 0x200A // Incoming jump from 0x2018, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @200D stack[-2] // @200D stack[-3] // } 200B 5B JUMPDEST 200C 50 POP 200D 90 SWAP1 200E 56 *JUMP // Stack delta = -2 // Outputs[1] { @200D stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_200F: // Incoming call from 0x200A, returns to 0x200B // Inputs[2] // { // @2011 stack[-1] // @2012 stack[-2] // } 200F 5B JUMPDEST 2010 5B JUMPDEST 2011 80 DUP1 2012 82 DUP3 2013 11 GT 2014 15 ISZERO 2015 61 PUSH2 0x200b 2018 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x200b, if !(stack[-2] > stack[-1]) label_2019: // Incoming jump from 0x2018, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x2018, if not !(stack[-2] > stack[-1]) // Inputs[1] { @201B stack[-1] } 2019 60 PUSH1 0x00 201B 81 DUP2 201C 55 SSTORE 201D 60 PUSH1 0x01 201F 01 ADD 2020 61 PUSH2 0x2010 2023 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @201C storage[stack[-1]] = 0x00 // @201F stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2010 label_2024: // Incoming call from 0x269A, returns to 0x12F7 // Incoming call from 0x2056, returns to 0x12F7 // Inputs[1] { @202E stack[-1] } 2024 5B JUMPDEST 2025 60 PUSH1 0x01 2027 60 PUSH1 0x01 2029 60 PUSH1 0xe0 202B 1B SHL 202C 03 SUB 202D 19 NOT 202E 81 DUP2 202F 16 AND 2030 81 DUP2 2031 14 EQ 2032 61 PUSH2 0x16e1 2035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x16e1, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_2036: // Incoming jump from 0x2035, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2039 memory[0x00:0x00] } 2036 60 PUSH1 0x00 2038 80 DUP1 2039 FD *REVERT // Stack delta = +0 // Outputs[1] { @2039 revert(memory[0x00:0x00]); } // Block terminates label_203A: // Incoming call from 0x027B, returns to 0x027C // Inputs[2] // { // @203F stack[-1] // @2040 stack[-2] // } 203A 5B JUMPDEST 203B 60 PUSH1 0x00 203D 60 PUSH1 0x20 203F 82 DUP3 2040 84 DUP5 2041 03 SUB 2042 12 SLT 2043 15 ISZERO 2044 61 PUSH2 0x204c 2047 57 *JUMPI // Stack delta = +1 // Outputs[1] { @203B stack[0] = 0x00 } // Block ends with conditional jump to 0x204c, if !(stack[-2] - stack[-1] i< 0x20) label_2048: // Incoming jump from 0x2047, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @204B memory[0x00:0x00] } 2048 60 PUSH1 0x00 204A 80 DUP1 204B FD *REVERT // Stack delta = +0 // Outputs[1] { @204B revert(memory[0x00:0x00]); } // Block terminates label_204C: // Incoming jump from 0x2047, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @204D stack[-2] // @204E msg.data[stack[-2]:stack[-2] + 0x20] // } 204C 5B JUMPDEST 204D 81 DUP2 204E 35 CALLDATALOAD 204F 61 PUSH2 0x12f7 2052 81 DUP2 2053 61 PUSH2 0x2024 2056 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @204E stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @204F stack[1] = 0x12f7 // @2052 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2024, returns to 0x12F7 label_2057: // Incoming call from 0x209A, returns to 0x209B // Inputs[1] { @205B stack[-3] } 2057 5B JUMPDEST 2058 60 PUSH1 0x00 205A 5B JUMPDEST 205B 83 DUP4 205C 81 DUP2 205D 10 LT 205E 15 ISZERO 205F 61 PUSH2 0x2072 2062 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2058 stack[0] = 0x00 } // Block ends with conditional jump to 0x2072, if !(0x00 < stack[-3]) label_2063: // Incoming jump from 0x2062, if not !(0x00 < stack[-3]) // Incoming jump from 0x2062, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2063 stack[-2] // @2064 stack[-1] // @2066 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2067 stack[-3] // } 2063 81 DUP2 2064 81 DUP2 2065 01 ADD 2066 51 MLOAD 2067 83 DUP4 2068 82 DUP3 2069 01 ADD 206A 52 MSTORE 206B 60 PUSH1 0x20 206D 01 ADD 206E 61 PUSH2 0x205a 2071 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @206A memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @206D stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x205a label_2072: // Incoming jump from 0x2062, if !(0x00 < stack[-3]) // Incoming jump from 0x2062, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @2073 stack[-4] // @2074 stack[-1] // } 2072 5B JUMPDEST 2073 83 DUP4 2074 81 DUP2 2075 11 GT 2076 15 ISZERO 2077 61 PUSH2 0x1188 207A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1188, if !(stack[-1] > stack[-4]) label_207B: // Incoming jump from 0x207A, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @207F stack[-4] // @2080 stack[-3] // @2082 stack[-5] // } 207B 50 POP 207C 50 POP 207D 60 PUSH1 0x00 207F 91 SWAP2 2080 01 ADD 2081 52 MSTORE 2082 56 *JUMP // Stack delta = -5 // Outputs[1] { @2081 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_2083: // Incoming call from 0x20C1, returns to 0x12F7 // Incoming call from 0x2673, returns to 0x2674 // Inputs[3] // { // @2086 stack[-1] // @2087 memory[stack[-1]:stack[-1] + 0x20] // @2089 stack[-2] // } 2083 5B JUMPDEST 2084 60 PUSH1 0x00 2086 81 DUP2 2087 51 MLOAD 2088 80 DUP1 2089 84 DUP5 208A 52 MSTORE 208B 61 PUSH2 0x209b 208E 81 DUP2 208F 60 PUSH1 0x20 2091 86 DUP7 2092 01 ADD 2093 60 PUSH1 0x20 2095 86 DUP7 2096 01 ADD 2097 61 PUSH2 0x2057 209A 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @2084 stack[0] = 0x00 // @2087 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @208A memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @208B stack[2] = 0x209b // @208E stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @2092 stack[4] = stack[-2] + 0x20 // @2096 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x2057, returns to 0x209B label_209B: // Incoming return from call to 0x2057 at 0x209A // Inputs[4] // { // @209E stack[-1] // @20A3 stack[-4] // @20A4 stack[-2] // @20AA stack[-5] // } 209B 5B JUMPDEST 209C 60 PUSH1 0x1f 209E 01 ADD 209F 60 PUSH1 0x1f 20A1 19 NOT 20A2 16 AND 20A3 92 SWAP3 20A4 90 SWAP1 20A5 92 SWAP3 20A6 01 ADD 20A7 60 PUSH1 0x20 20A9 01 ADD 20AA 92 SWAP3 20AB 91 SWAP2 20AC 50 POP 20AD 50 POP 20AE 56 *JUMP // Stack delta = -4 // Outputs[1] { @20AA stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_20AF: // Incoming jump from 0x02B7 // Inputs[2] // { // @20B2 stack[-1] // @20BD stack[-2] // } 20AF 5B JUMPDEST 20B0 60 PUSH1 0x20 20B2 81 DUP2 20B3 52 MSTORE 20B4 60 PUSH1 0x00 20B6 61 PUSH2 0x12f7 20B9 60 PUSH1 0x20 20BB 83 DUP4 20BC 01 ADD 20BD 84 DUP5 20BE 61 PUSH2 0x2083 20C1 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @20B3 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @20B4 stack[0] = 0x00 // @20B6 stack[1] = 0x12f7 // @20BC stack[2] = stack[-1] + 0x20 // @20BD stack[3] = stack[-2] // } // Block ends with call to 0x2083, returns to 0x12F7 label_20C2: // Incoming call from 0x05DA, returns to 0x05DB // Incoming call from 0x04EA, returns to 0x04EB // Incoming call from 0x062F, returns to 0x0630 // Incoming call from 0x0446, returns to 0x0447 // Incoming call from 0x02D2, returns to 0x02D3 // Incoming call from 0x06BF, returns to 0x06C0 // Incoming call from 0x055E, returns to 0x055F // Inputs[2] // { // @20C7 stack[-1] // @20C8 stack[-2] // } 20C2 5B JUMPDEST 20C3 60 PUSH1 0x00 20C5 60 PUSH1 0x20 20C7 82 DUP3 20C8 84 DUP5 20C9 03 SUB 20CA 12 SLT 20CB 15 ISZERO 20CC 61 PUSH2 0x20d4 20CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20C3 stack[0] = 0x00 } // Block ends with conditional jump to 0x20d4, if !(stack[-2] - stack[-1] i< 0x20) label_20D0: // Incoming jump from 0x20CF, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @20D3 memory[0x00:0x00] } 20D0 60 PUSH1 0x00 20D2 80 DUP1 20D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @20D3 revert(memory[0x00:0x00]); } // Block terminates label_20D4: // Incoming jump from 0x20CF, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @20D6 stack[-2] // @20D6 msg.data[stack[-2]:stack[-2] + 0x20] // @20D7 stack[-4] // @20D8 stack[-3] // } 20D4 5B JUMPDEST 20D5 50 POP 20D6 35 CALLDATALOAD 20D7 91 SWAP2 20D8 90 SWAP1 20D9 50 POP 20DA 56 *JUMP // Stack delta = -3 // Outputs[1] { @20D7 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_20DB: // Incoming call from 0x2401, returns to 0x2402 // Incoming call from 0x223C, returns to 0x223D // Incoming call from 0x240F, returns to 0x22E4 // Incoming call from 0x2319, returns to 0x231A // Incoming call from 0x224A, returns to 0x224B // Incoming call from 0x22D5, returns to 0x22D6 // Incoming call from 0x2432, returns to 0x22E4 // Incoming call from 0x230B, returns to 0x230C // Incoming call from 0x2112, returns to 0x2113 // Incoming call from 0x2275, returns to 0x12F7 // Inputs[2] // { // @20DC stack[-1] // @20DD msg.data[stack[-1]:stack[-1] + 0x20] // } 20DB 5B JUMPDEST 20DC 80 DUP1 20DD 35 CALLDATALOAD 20DE 60 PUSH1 0x01 20E0 60 PUSH1 0x01 20E2 60 PUSH1 0xa0 20E4 1B SHL 20E5 03 SUB 20E6 81 DUP2 20E7 16 AND 20E8 81 DUP2 20E9 14 EQ 20EA 61 PUSH2 0x20f2 20ED 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20DD stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x20f2, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_20EE: // Incoming jump from 0x20ED, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @20F1 memory[0x00:0x00] } 20EE 60 PUSH1 0x00 20F0 80 DUP1 20F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @20F1 revert(memory[0x00:0x00]); } // Block terminates label_20F2: // Incoming jump from 0x21FF, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Incoming jump from 0x20ED, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @20F3 stack[-1] // @20F3 stack[-3] // @20F4 stack[-2] // } 20F2 5B JUMPDEST 20F3 91 SWAP2 20F4 90 SWAP1 20F5 50 POP 20F6 56 *JUMP // Stack delta = -2 // Outputs[1] { @20F3 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_20F7: // Incoming call from 0x030A, returns to 0x030B // Inputs[2] // { // @20FD stack[-1] // @20FE stack[-2] // } 20F7 5B JUMPDEST 20F8 60 PUSH1 0x00 20FA 80 DUP1 20FB 60 PUSH1 0x40 20FD 83 DUP4 20FE 85 DUP6 20FF 03 SUB 2100 12 SLT 2101 15 ISZERO 2102 61 PUSH2 0x210a 2105 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20F8 stack[0] = 0x00 // @20FA stack[1] = 0x00 // } // Block ends with conditional jump to 0x210a, if !(stack[-2] - stack[-1] i< 0x40) label_2106: // Incoming jump from 0x2105, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2109 memory[0x00:0x00] } 2106 60 PUSH1 0x00 2108 80 DUP1 2109 FD *REVERT // Stack delta = +0 // Outputs[1] { @2109 revert(memory[0x00:0x00]); } // Block terminates label_210A: // Incoming jump from 0x2105, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @210E stack[-3] } 210A 5B JUMPDEST 210B 61 PUSH2 0x2113 210E 83 DUP4 210F 61 PUSH2 0x20db 2112 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @210B stack[0] = 0x2113 // @210E stack[1] = stack[-3] // } // Block ends with call to 0x20db, returns to 0x2113 label_2113: // Incoming return from call to 0x20DB at 0x2112 // Inputs[5] // { // @2114 stack[-1] // @2114 stack[-6] // @2117 stack[-4] // @211B msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @211C stack[-5] // } 2113 5B JUMPDEST 2114 94 SWAP5 2115 60 PUSH1 0x20 2117 93 SWAP4 2118 90 SWAP1 2119 93 SWAP4 211A 01 ADD 211B 35 CALLDATALOAD 211C 93 SWAP4 211D 50 POP 211E 50 POP 211F 50 POP 2120 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2114 stack[-6] = stack[-1] // @211C stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_2121: // Incoming jump from 0x2150 // Incoming jump from 0x0B4D // Incoming jump from 0x2178 // Inputs[1] { @2136 memory[0x00:0x24] } 2121 5B JUMPDEST 2122 63 PUSH4 0x4e487b71 2127 60 PUSH1 0xe0 2129 1B SHL 212A 60 PUSH1 0x00 212C 52 MSTORE 212D 60 PUSH1 0x41 212F 60 PUSH1 0x04 2131 52 MSTORE 2132 60 PUSH1 0x24 2134 60 PUSH1 0x00 2136 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @212C memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2131 memory[0x04:0x24] = 0x41 // @2136 revert(memory[0x00:0x24]); // } // Block terminates label_2137: // Incoming call from 0x21F3, returns to 0x1C10 // Incoming call from 0x235B, returns to 0x235C // Inputs[1] { @2143 stack[-2] } 2137 5B JUMPDEST 2138 60 PUSH1 0x00 213A 60 PUSH1 0x01 213C 60 PUSH1 0x01 213E 60 PUSH1 0x40 2140 1B SHL 2141 03 SUB 2142 80 DUP1 2143 84 DUP5 2144 11 GT 2145 15 ISZERO 2146 61 PUSH2 0x2151 2149 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2138 stack[0] = 0x00 // @2141 stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x2151, if !(stack[-2] > (0x01 << 0x40) - 0x01) label_214A: // Incoming jump from 0x2149, if not !(stack[-2] > (0x01 << 0x40) - 0x01) 214A 61 PUSH2 0x2151 214D 61 PUSH2 0x2121 2150 56 *JUMP // Stack delta = +1 // Outputs[1] { @214A stack[0] = 0x2151 } // Block ends with unconditional jump to 0x2121 label_2151: // Incoming jump from 0x2149, if !(stack[-2] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2154 memory[0x40:0x60] // @2157 stack[-4] // @2166 stack[-1] // } 2151 5B JUMPDEST 2152 60 PUSH1 0x40 2154 51 MLOAD 2155 60 PUSH1 0x1f 2157 85 DUP6 2158 01 ADD 2159 60 PUSH1 0x1f 215B 19 NOT 215C 90 SWAP1 215D 81 DUP2 215E 16 AND 215F 60 PUSH1 0x3f 2161 01 ADD 2162 16 AND 2163 81 DUP2 2164 01 ADD 2165 90 SWAP1 2166 82 DUP3 2167 82 DUP3 2168 11 GT 2169 81 DUP2 216A 83 DUP4 216B 10 LT 216C 17 OR 216D 15 ISZERO 216E 61 PUSH2 0x2179 2171 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2165 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @2165 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x2179, 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_2172: // Incoming jump from 0x2171, 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])) 2172 61 PUSH2 0x2179 2175 61 PUSH2 0x2121 2178 56 *JUMP // Stack delta = +1 // Outputs[1] { @2172 stack[0] = 0x2179 } // Block ends with unconditional jump to 0x2121 label_2179: // Incoming jump from 0x2171, 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] // { // @217A stack[-2] // @217E stack[-1] // @217F stack[-4] // @2181 stack[-6] // @2184 stack[-7] // @2186 stack[-5] // } 2179 5B JUMPDEST 217A 81 DUP2 217B 60 PUSH1 0x40 217D 52 MSTORE 217E 80 DUP1 217F 93 SWAP4 2180 50 POP 2181 85 DUP6 2182 81 DUP2 2183 52 MSTORE 2184 86 DUP7 2185 86 DUP7 2186 86 DUP7 2187 01 ADD 2188 11 GT 2189 15 ISZERO 218A 61 PUSH2 0x2192 218D 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @217D memory[0x40:0x60] = stack[-2] // @217F stack[-4] = stack[-1] // @2183 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x2192, if !(stack[-5] + stack[-6] > stack[-7]) label_218E: // Incoming jump from 0x218D, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @2191 memory[0x00:0x00] } 218E 60 PUSH1 0x00 2190 80 DUP1 2191 FD *REVERT // Stack delta = +0 // Outputs[1] { @2191 revert(memory[0x00:0x00]); } // Block terminates label_2192: // Incoming jump from 0x218D, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @2193 stack[-6] // @2194 stack[-5] // @2197 stack[-1] // @2199 msg.data[stack[-5]:stack[-5] + stack[-6]] // @21A6 stack[-4] // @21A6 stack[-8] // @21A7 stack[-7] // } 2192 5B JUMPDEST 2193 85 DUP6 2194 85 DUP6 2195 60 PUSH1 0x20 2197 83 DUP4 2198 01 ADD 2199 37 CALLDATACOPY 219A 60 PUSH1 0x00 219C 60 PUSH1 0x20 219E 87 DUP8 219F 83 DUP4 21A0 01 ADD 21A1 01 ADD 21A2 52 MSTORE 21A3 50 POP 21A4 50 POP 21A5 50 POP 21A6 93 SWAP4 21A7 92 SWAP3 21A8 50 POP 21A9 50 POP 21AA 50 POP 21AB 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @2199 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @21A2 memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @21A6 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_21AC: // Incoming call from 0x057E, returns to 0x057F // Incoming call from 0x0466, returns to 0x0467 // Incoming call from 0x0350, returns to 0x0351 // Inputs[2] // { // @21B1 stack[-1] // @21B2 stack[-2] // } 21AC 5B JUMPDEST 21AD 60 PUSH1 0x00 21AF 60 PUSH1 0x20 21B1 82 DUP3 21B2 84 DUP5 21B3 03 SUB 21B4 12 SLT 21B5 15 ISZERO 21B6 61 PUSH2 0x21be 21B9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @21AD stack[0] = 0x00 } // Block ends with conditional jump to 0x21be, if !(stack[-2] - stack[-1] i< 0x20) label_21BA: // Incoming jump from 0x21B9, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @21BD memory[0x00:0x00] } 21BA 60 PUSH1 0x00 21BC 80 DUP1 21BD FD *REVERT // Stack delta = +0 // Outputs[1] { @21BD revert(memory[0x00:0x00]); } // Block terminates label_21BE: // Incoming jump from 0x21B9, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @21BF stack[-2] // @21C0 msg.data[stack[-2]:stack[-2] + 0x20] // } 21BE 5B JUMPDEST 21BF 81 DUP2 21C0 35 CALLDATALOAD 21C1 60 PUSH1 0x01 21C3 60 PUSH1 0x01 21C5 60 PUSH1 0x40 21C7 1B SHL 21C8 03 SUB 21C9 81 DUP2 21CA 11 GT 21CB 15 ISZERO 21CC 61 PUSH2 0x21d4 21CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @21C0 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x21d4, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_21D0: // Incoming jump from 0x21CF, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @21D3 memory[0x00:0x00] } 21D0 60 PUSH1 0x00 21D2 80 DUP1 21D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @21D3 revert(memory[0x00:0x00]); } // Block terminates label_21D4: // Incoming jump from 0x21CF, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @21D5 stack[-3] // @21D6 stack[-1] // @21DB stack[-4] // } 21D4 5B JUMPDEST 21D5 82 DUP3 21D6 01 ADD 21D7 60 PUSH1 0x1f 21D9 81 DUP2 21DA 01 ADD 21DB 84 DUP5 21DC 13 SGT 21DD 61 PUSH2 0x21e5 21E0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @21D6 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x21e5, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_21E1: // Incoming jump from 0x21E0, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @21E4 memory[0x00:0x00] } 21E1 60 PUSH1 0x00 21E3 80 DUP1 21E4 FD *REVERT // Stack delta = +0 // Outputs[1] { @21E4 revert(memory[0x00:0x00]); } // Block terminates label_21E5: // Incoming jump from 0x21E0, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @21E9 stack[-4] // @21EA stack[-1] // @21EB msg.data[stack[-1]:stack[-1] + 0x20] // } 21E5 5B JUMPDEST 21E6 61 PUSH2 0x1c10 21E9 84 DUP5 21EA 82 DUP3 21EB 35 CALLDATALOAD 21EC 60 PUSH1 0x20 21EE 84 DUP5 21EF 01 ADD 21F0 61 PUSH2 0x2137 21F3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @21E6 stack[0] = 0x1c10 // @21E9 stack[1] = stack[-4] // @21EB stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @21EF stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x2137, returns to 0x1C10 label_21F4: // Incoming call from 0x221E, returns to 0x12F7 // Incoming call from 0x22E3, returns to 0x22E4 // Inputs[2] // { // @21F5 stack[-1] // @21F6 msg.data[stack[-1]:stack[-1] + 0x20] // } 21F4 5B JUMPDEST 21F5 80 DUP1 21F6 35 CALLDATALOAD 21F7 80 DUP1 21F8 15 ISZERO 21F9 15 ISZERO 21FA 81 DUP2 21FB 14 EQ 21FC 61 PUSH2 0x20f2 21FF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @21F6 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x20f2, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_2200: // Incoming jump from 0x21FF, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @2203 memory[0x00:0x00] } 2200 60 PUSH1 0x00 2202 80 DUP1 2203 FD *REVERT // Stack delta = +0 // Outputs[1] { @2203 revert(memory[0x00:0x00]); } // Block terminates label_2204: // Incoming call from 0x0738, returns to 0x0739 // Incoming call from 0x0370, returns to 0x0371 // Incoming call from 0x067F, returns to 0x0680 // Inputs[2] // { // @2209 stack[-1] // @220A stack[-2] // } 2204 5B JUMPDEST 2205 60 PUSH1 0x00 2207 60 PUSH1 0x20 2209 82 DUP3 220A 84 DUP5 220B 03 SUB 220C 12 SLT 220D 15 ISZERO 220E 61 PUSH2 0x2216 2211 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2205 stack[0] = 0x00 } // Block ends with conditional jump to 0x2216, if !(stack[-2] - stack[-1] i< 0x20) label_2212: // Incoming jump from 0x2211, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2215 memory[0x00:0x00] } 2212 60 PUSH1 0x00 2214 80 DUP1 2215 FD *REVERT // Stack delta = +0 // Outputs[1] { @2215 revert(memory[0x00:0x00]); } // Block terminates label_2216: // Incoming jump from 0x2211, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @221A stack[-2] } 2216 5B JUMPDEST 2217 61 PUSH2 0x12f7 221A 82 DUP3 221B 61 PUSH2 0x21f4 221E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2217 stack[0] = 0x12f7 // @221A stack[1] = stack[-2] // } // Block ends with call to 0x21f4, returns to 0x12F7 label_221F: // Incoming call from 0x03F9, returns to 0x03FA // Incoming call from 0x03AE, returns to 0x03AF // Inputs[2] // { // @2227 stack[-1] // @2228 stack[-2] // } 221F 5B JUMPDEST 2220 60 PUSH1 0x00 2222 80 DUP1 2223 60 PUSH1 0x00 2225 60 PUSH1 0x60 2227 84 DUP5 2228 86 DUP7 2229 03 SUB 222A 12 SLT 222B 15 ISZERO 222C 61 PUSH2 0x2234 222F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2220 stack[0] = 0x00 // @2222 stack[1] = 0x00 // @2223 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2234, if !(stack[-2] - stack[-1] i< 0x60) label_2230: // Incoming jump from 0x222F, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2233 memory[0x00:0x00] } 2230 60 PUSH1 0x00 2232 80 DUP1 2233 FD *REVERT // Stack delta = +0 // Outputs[1] { @2233 revert(memory[0x00:0x00]); } // Block terminates label_2234: // Incoming jump from 0x222F, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2238 stack[-4] } 2234 5B JUMPDEST 2235 61 PUSH2 0x223d 2238 84 DUP5 2239 61 PUSH2 0x20db 223C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2235 stack[0] = 0x223d // @2238 stack[1] = stack[-4] // } // Block ends with call to 0x20db, returns to 0x223D label_223D: // Incoming return from call to 0x20DB at 0x223C // Inputs[3] // { // @223E stack[-1] // @223E stack[-4] // @2245 stack[-5] // } 223D 5B JUMPDEST 223E 92 SWAP3 223F 50 POP 2240 61 PUSH2 0x224b 2243 60 PUSH1 0x20 2245 85 DUP6 2246 01 ADD 2247 61 PUSH2 0x20db 224A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @223E stack[-4] = stack[-1] // @2240 stack[-1] = 0x224b // @2246 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x20db, returns to 0x224B label_224B: // Incoming return from call to 0x20DB at 0x224A // Inputs[8] // { // @224C stack[-3] // @224C stack[-1] // @2250 stack[-5] // @2252 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2253 stack[-2] // @2257 stack[-6] // @2259 stack[-7] // @2259 stack[-4] // } 224B 5B JUMPDEST 224C 91 SWAP2 224D 50 POP 224E 60 PUSH1 0x40 2250 84 DUP5 2251 01 ADD 2252 35 CALLDATALOAD 2253 90 SWAP1 2254 50 POP 2255 92 SWAP3 2256 50 POP 2257 92 SWAP3 2258 50 POP 2259 92 SWAP3 225A 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2255 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2257 stack[-6] = stack[-1] // @2259 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_225B: // Incoming call from 0x0529, returns to 0x052A // Incoming call from 0x07C1, returns to 0x07C2 // Incoming call from 0x064F, returns to 0x0650 // Incoming call from 0x0708, returns to 0x0709 // Incoming call from 0x0419, returns to 0x041A // Inputs[2] // { // @2260 stack[-1] // @2261 stack[-2] // } 225B 5B JUMPDEST 225C 60 PUSH1 0x00 225E 60 PUSH1 0x20 2260 82 DUP3 2261 84 DUP5 2262 03 SUB 2263 12 SLT 2264 15 ISZERO 2265 61 PUSH2 0x226d 2268 57 *JUMPI // Stack delta = +1 // Outputs[1] { @225C stack[0] = 0x00 } // Block ends with conditional jump to 0x226d, if !(stack[-2] - stack[-1] i< 0x20) label_2269: // Incoming jump from 0x2268, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @226C memory[0x00:0x00] } 2269 60 PUSH1 0x00 226B 80 DUP1 226C FD *REVERT // Stack delta = +0 // Outputs[1] { @226C revert(memory[0x00:0x00]); } // Block terminates label_226D: // Incoming jump from 0x2268, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2271 stack[-2] } 226D 5B JUMPDEST 226E 61 PUSH2 0x12f7 2271 82 DUP3 2272 61 PUSH2 0x20db 2275 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @226E stack[0] = 0x12f7 // @2271 stack[1] = stack[-2] // } // Block ends with call to 0x20db, returns to 0x12F7 label_2276: // Incoming call from 0x042B, returns to 0x028D // Inputs[3] // { // @227A stack[-1] // @227C stack[-2] // @227D memory[stack[-2]:stack[-2] + 0x20] // } 2276 5B JUMPDEST 2277 60 PUSH1 0x20 2279 80 DUP1 227A 82 DUP3 227B 52 MSTORE 227C 82 DUP3 227D 51 MLOAD 227E 82 DUP3 227F 82 DUP3 2280 01 ADD 2281 81 DUP2 2282 90 SWAP1 2283 52 MSTORE 2284 60 PUSH1 0x00 2286 91 SWAP2 2287 90 SWAP1 2288 84 DUP5 2289 82 DUP3 228A 01 ADD 228B 90 SWAP1 228C 60 PUSH1 0x40 228E 85 DUP6 228F 01 ADD 2290 90 SWAP1 2291 84 DUP5 2292 5B JUMPDEST 2293 81 DUP2 2294 81 DUP2 2295 10 LT 2296 15 ISZERO 2297 61 PUSH2 0x22ae 229A 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @227B memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2283 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @2286 stack[0] = 0x00 // @2287 stack[1] = 0x20 // @228B stack[2] = 0x20 + stack[-2] // @2290 stack[3] = stack[-1] + 0x40 // @2290 stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @2291 stack[5] = 0x00 // } // Block ends with conditional jump to 0x22ae, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_229B: // Incoming jump from 0x229A, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x229A, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[5] // { // @229B stack[-4] // @229C memory[stack[-4]:stack[-4] + 0x20] // @229D stack[-3] // @229F stack[-1] // @22A0 stack[-5] // } 229B 83 DUP4 229C 51 MLOAD 229D 83 DUP4 229E 52 MSTORE 229F 92 SWAP3 22A0 84 DUP5 22A1 01 ADD 22A2 92 SWAP3 22A3 91 SWAP2 22A4 84 DUP5 22A5 01 ADD 22A6 91 SWAP2 22A7 60 PUSH1 0x01 22A9 01 ADD 22AA 61 PUSH2 0x2292 22AD 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @229E memory[stack[-3]:stack[-3] + 0x20] = memory[stack[-4]:stack[-4] + 0x20] // @22A2 stack[-4] = stack[-5] + stack[-4] // @22A6 stack[-3] = stack[-5] + stack[-3] // @22A9 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2292 label_22AE: // Incoming jump from 0x229A, if !(stack[-1] < stack[-2]) // Incoming jump from 0x229A, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @22B0 stack[-3] // @22B0 stack[-2] // @22B1 stack[-9] // @22B2 stack[-8] // } 22AE 5B JUMPDEST 22AF 50 POP 22B0 90 SWAP1 22B1 96 SWAP7 22B2 95 SWAP6 22B3 50 POP 22B4 50 POP 22B5 50 POP 22B6 50 POP 22B7 50 POP 22B8 50 POP 22B9 56 *JUMP // Stack delta = -8 // Outputs[1] { @22B1 stack[-9] = stack[-3] } // Block ends with unconditional jump to stack[-9] label_22BA: // Incoming jump from 0x05FA // Inputs[2] // { // @22C0 stack[-1] // @22C1 stack[-2] // } 22BA 5B JUMPDEST 22BB 60 PUSH1 0x00 22BD 80 DUP1 22BE 60 PUSH1 0x40 22C0 83 DUP4 22C1 85 DUP6 22C2 03 SUB 22C3 12 SLT 22C4 15 ISZERO 22C5 61 PUSH2 0x22cd 22C8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @22BB stack[0] = 0x00 // @22BD stack[1] = 0x00 // } // Block ends with conditional jump to 0x22cd, if !(stack[-2] - stack[-1] i< 0x40) label_22C9: // Incoming jump from 0x22C8, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @22CC memory[0x00:0x00] } 22C9 60 PUSH1 0x00 22CB 80 DUP1 22CC FD *REVERT // Stack delta = +0 // Outputs[1] { @22CC revert(memory[0x00:0x00]); } // Block terminates label_22CD: // Incoming jump from 0x22C8, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @22D1 stack[-3] } 22CD 5B JUMPDEST 22CE 61 PUSH2 0x22d6 22D1 83 DUP4 22D2 61 PUSH2 0x20db 22D5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @22CE stack[0] = 0x22d6 // @22D1 stack[1] = stack[-3] // } // Block ends with call to 0x20db, returns to 0x22D6 label_22D6: // Incoming return from call to 0x20DB at 0x22D5 // Inputs[3] // { // @22D7 stack[-3] // @22D7 stack[-1] // @22DE stack[-4] // } 22D6 5B JUMPDEST 22D7 91 SWAP2 22D8 50 POP 22D9 61 PUSH2 0x22e4 22DC 60 PUSH1 0x20 22DE 84 DUP5 22DF 01 ADD 22E0 61 PUSH2 0x21f4 22E3 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @22D7 stack[-3] = stack[-1] // @22D9 stack[-1] = 0x22e4 // @22DF stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x21f4, returns to 0x22E4 label_22E4: // Incoming return from call to 0x21F4 at 0x22E3 // Incoming return from call to 0x20DB at 0x240F // Incoming return from call to 0x20DB at 0x2432 // Inputs[6] // { // @22E5 stack[-1] // @22E5 stack[-2] // @22E7 stack[-5] // @22E9 stack[-6] // @22E9 stack[-3] // @22EA stack[-4] // } 22E4 5B JUMPDEST 22E5 90 SWAP1 22E6 50 POP 22E7 92 SWAP3 22E8 50 POP 22E9 92 SWAP3 22EA 90 SWAP1 22EB 50 POP 22EC 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @22E7 stack[-5] = stack[-1] // @22E9 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_22ED: // Incoming call from 0x069F, returns to 0x06A0 // Inputs[2] // { // @22F6 stack[-1] // @22F7 stack[-2] // } 22ED 5B JUMPDEST 22EE 60 PUSH1 0x00 22F0 80 DUP1 22F1 60 PUSH1 0x00 22F3 80 DUP1 22F4 60 PUSH1 0x80 22F6 85 DUP6 22F7 87 DUP8 22F8 03 SUB 22F9 12 SLT 22FA 15 ISZERO 22FB 61 PUSH2 0x2303 22FE 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @22EE stack[0] = 0x00 // @22F0 stack[1] = 0x00 // @22F1 stack[2] = 0x00 // @22F3 stack[3] = 0x00 // } // Block ends with conditional jump to 0x2303, if !(stack[-2] - stack[-1] i< 0x80) label_22FF: // Incoming jump from 0x22FE, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2302 memory[0x00:0x00] } 22FF 60 PUSH1 0x00 2301 80 DUP1 2302 FD *REVERT // Stack delta = +0 // Outputs[1] { @2302 revert(memory[0x00:0x00]); } // Block terminates label_2303: // Incoming jump from 0x22FE, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2307 stack[-5] } 2303 5B JUMPDEST 2304 61 PUSH2 0x230c 2307 85 DUP6 2308 61 PUSH2 0x20db 230B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2304 stack[0] = 0x230c // @2307 stack[1] = stack[-5] // } // Block ends with call to 0x20db, returns to 0x230C label_230C: // Incoming return from call to 0x20DB at 0x230B // Inputs[3] // { // @230D stack[-1] // @230D stack[-5] // @2314 stack[-6] // } 230C 5B JUMPDEST 230D 93 SWAP4 230E 50 POP 230F 61 PUSH2 0x231a 2312 60 PUSH1 0x20 2314 86 DUP7 2315 01 ADD 2316 61 PUSH2 0x20db 2319 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @230D stack[-5] = stack[-1] // @230F stack[-1] = 0x231a // @2315 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x20db, returns to 0x231A label_231A: // Incoming return from call to 0x20DB at 0x2319 // Inputs[6] // { // @231B stack[-1] // @231B stack[-4] // @231F stack[-6] // @2321 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2322 stack[-3] // @2328 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 231A 5B JUMPDEST 231B 92 SWAP3 231C 50 POP 231D 60 PUSH1 0x40 231F 85 DUP6 2320 01 ADD 2321 35 CALLDATALOAD 2322 91 SWAP2 2323 50 POP 2324 60 PUSH1 0x60 2326 85 DUP6 2327 01 ADD 2328 35 CALLDATALOAD 2329 60 PUSH1 0x01 232B 60 PUSH1 0x01 232D 60 PUSH1 0x40 232F 1B SHL 2330 03 SUB 2331 81 DUP2 2332 11 GT 2333 15 ISZERO 2334 61 PUSH2 0x233c 2337 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @231B stack[-4] = stack[-1] // @2322 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2328 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x233c, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) label_2338: // Incoming jump from 0x2337, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @233B memory[0x00:0x00] } 2338 60 PUSH1 0x00 233A 80 DUP1 233B FD *REVERT // Stack delta = +0 // Outputs[1] { @233B revert(memory[0x00:0x00]); } // Block terminates label_233C: // Incoming jump from 0x2337, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @233D stack[-6] // @233E stack[-1] // @2343 stack[-7] // } 233C 5B JUMPDEST 233D 85 DUP6 233E 01 ADD 233F 60 PUSH1 0x1f 2341 81 DUP2 2342 01 ADD 2343 87 DUP8 2344 13 SGT 2345 61 PUSH2 0x234d 2348 57 *JUMPI // Stack delta = +0 // Outputs[1] { @233E stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x234d, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_2349: // Incoming jump from 0x2348, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @234C memory[0x00:0x00] } 2349 60 PUSH1 0x00 234B 80 DUP1 234C FD *REVERT // Stack delta = +0 // Outputs[1] { @234C revert(memory[0x00:0x00]); } // Block terminates label_234D: // Incoming jump from 0x2348, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @2351 stack[-7] // @2352 stack[-1] // @2353 msg.data[stack[-1]:stack[-1] + 0x20] // } 234D 5B JUMPDEST 234E 61 PUSH2 0x235c 2351 87 DUP8 2352 82 DUP3 2353 35 CALLDATALOAD 2354 60 PUSH1 0x20 2356 84 DUP5 2357 01 ADD 2358 61 PUSH2 0x2137 235B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @234E stack[0] = 0x235c // @2351 stack[1] = stack[-7] // @2353 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2357 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x2137, returns to 0x235C label_235C: // Incoming return from call to 0x2137 at 0x235B // Inputs[8] // { // @235D stack[-1] // @235D stack[-3] // @2360 stack[-6] // @2361 stack[-9] // @2362 stack[-5] // @2363 stack[-8] // @2365 stack[-7] // @2365 stack[-4] // } 235C 5B JUMPDEST 235D 91 SWAP2 235E 50 POP 235F 50 POP 2360 92 SWAP3 2361 95 SWAP6 2362 91 SWAP2 2363 94 SWAP5 2364 50 POP 2365 92 SWAP3 2366 50 POP 2367 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @2360 stack[-6] = stack[-1] // @2361 stack[-9] = stack[-6] // @2363 stack[-8] = stack[-5] // @2365 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_2368: // Incoming call from 0x06D2, returns to 0x06D3 // Inputs[2] // { // @2370 stack[-1] // @2371 stack[-2] // } 2368 5B JUMPDEST 2369 60 PUSH1 0x00 236B 80 DUP1 236C 60 PUSH1 0x00 236E 60 PUSH1 0x40 2370 84 DUP5 2371 86 DUP7 2372 03 SUB 2373 12 SLT 2374 15 ISZERO 2375 61 PUSH2 0x237d 2378 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2369 stack[0] = 0x00 // @236B stack[1] = 0x00 // @236C stack[2] = 0x00 // } // Block ends with conditional jump to 0x237d, if !(stack[-2] - stack[-1] i< 0x40) label_2379: // Incoming jump from 0x2378, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @237C memory[0x00:0x00] } 2379 60 PUSH1 0x00 237B 80 DUP1 237C FD *REVERT // Stack delta = +0 // Outputs[1] { @237C revert(memory[0x00:0x00]); } // Block terminates label_237D: // Incoming jump from 0x2378, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @237E stack[-4] // @237F msg.data[stack[-4]:stack[-4] + 0x20] // @2380 stack[-3] // @2386 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 237D 5B JUMPDEST 237E 83 DUP4 237F 35 CALLDATALOAD 2380 92 SWAP3 2381 50 POP 2382 60 PUSH1 0x20 2384 84 DUP5 2385 01 ADD 2386 35 CALLDATALOAD 2387 60 PUSH1 0x01 2389 60 PUSH1 0x01 238B 60 PUSH1 0x40 238D 1B SHL 238E 03 SUB 238F 80 DUP1 2390 82 DUP3 2391 11 GT 2392 15 ISZERO 2393 61 PUSH2 0x239b 2396 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2380 stack[-3] = msg.data[stack[-4]:stack[-4] + 0x20] // @2386 stack[0] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @238E stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x239b, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) label_2397: // Incoming jump from 0x2396, if not !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @239A memory[0x00:0x00] } 2397 60 PUSH1 0x00 2399 80 DUP1 239A FD *REVERT // Stack delta = +0 // Outputs[1] { @239A revert(memory[0x00:0x00]); } // Block terminates label_239B: // Incoming jump from 0x2396, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @239C stack[-2] // @239D stack[-6] // @23A1 stack[-7] // } 239B 5B JUMPDEST 239C 81 DUP2 239D 86 DUP7 239E 01 ADD 239F 91 SWAP2 23A0 50 POP 23A1 86 DUP7 23A2 60 PUSH1 0x1f 23A4 83 DUP4 23A5 01 ADD 23A6 12 SLT 23A7 61 PUSH2 0x23af 23AA 57 *JUMPI // Stack delta = +0 // Outputs[1] { @239F stack[-2] = stack[-6] + stack[-2] } // Block ends with conditional jump to 0x23af, if stack[-6] + stack[-2] + 0x1f i< stack[-7] label_23AB: // Incoming jump from 0x23AA, if not stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[1] { @23AE memory[0x00:0x00] } 23AB 60 PUSH1 0x00 23AD 80 DUP1 23AE FD *REVERT // Stack delta = +0 // Outputs[1] { @23AE revert(memory[0x00:0x00]); } // Block terminates label_23AF: // Incoming jump from 0x23AA, if stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[3] // { // @23B0 stack[-2] // @23B1 msg.data[stack[-2]:stack[-2] + 0x20] // @23B2 stack[-1] // } 23AF 5B JUMPDEST 23B0 81 DUP2 23B1 35 CALLDATALOAD 23B2 81 DUP2 23B3 81 DUP2 23B4 11 GT 23B5 15 ISZERO 23B6 61 PUSH2 0x23be 23B9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @23B1 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x23be, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_23BA: // Incoming jump from 0x23B9, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @23BD memory[0x00:0x00] } 23BA 60 PUSH1 0x00 23BC 80 DUP1 23BD FD *REVERT // Stack delta = +0 // Outputs[1] { @23BD revert(memory[0x00:0x00]); } // Block terminates label_23BE: // Incoming jump from 0x23B9, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @23BF stack[-8] // @23C2 stack[-1] // @23C6 stack[-3] // } 23BE 5B JUMPDEST 23BF 87 DUP8 23C0 60 PUSH1 0x20 23C2 82 DUP3 23C3 60 PUSH1 0x05 23C5 1B SHL 23C6 85 DUP6 23C7 01 ADD 23C8 01 ADD 23C9 11 GT 23CA 15 ISZERO 23CB 61 PUSH2 0x23d3 23CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x23d3, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-8]) label_23CF: // Incoming jump from 0x23CE, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-8]) // Inputs[1] { @23D2 memory[0x00:0x00] } 23CF 60 PUSH1 0x00 23D1 80 DUP1 23D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @23D2 revert(memory[0x00:0x00]); } // Block terminates label_23D3: // Incoming jump from 0x23CE, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-8]) // Inputs[8] // { // @23D6 stack[-3] // @23D8 stack[-5] // @23DA stack[-1] // @23DB stack[-4] // @23E0 stack[-7] // @23E2 stack[-8] // @23E4 stack[-9] // @23E4 stack[-6] // } 23D3 5B JUMPDEST 23D4 60 PUSH1 0x20 23D6 83 DUP4 23D7 01 ADD 23D8 94 SWAP5 23D9 50 POP 23DA 80 DUP1 23DB 93 SWAP4 23DC 50 POP 23DD 50 POP 23DE 50 POP 23DF 50 POP 23E0 92 SWAP3 23E1 50 POP 23E2 92 SWAP3 23E3 50 POP 23E4 92 SWAP3 23E5 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @23E0 stack[-7] = stack[-1] // @23E2 stack[-8] = stack[-3] + 0x20 // @23E4 stack[-9] = stack[-6] // } // Block ends with unconditional jump to stack[-9] label_23E6: // Incoming jump from 0x0758 // Inputs[2] // { // @23EC stack[-1] // @23ED stack[-2] // } 23E6 5B JUMPDEST 23E7 60 PUSH1 0x00 23E9 80 DUP1 23EA 60 PUSH1 0x40 23EC 83 DUP4 23ED 85 DUP6 23EE 03 SUB 23EF 12 SLT 23F0 15 ISZERO 23F1 61 PUSH2 0x23f9 23F4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @23E7 stack[0] = 0x00 // @23E9 stack[1] = 0x00 // } // Block ends with conditional jump to 0x23f9, if !(stack[-2] - stack[-1] i< 0x40) label_23F5: // Incoming jump from 0x23F4, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @23F8 memory[0x00:0x00] } 23F5 60 PUSH1 0x00 23F7 80 DUP1 23F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @23F8 revert(memory[0x00:0x00]); } // Block terminates label_23F9: // Incoming jump from 0x23F4, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @23FD stack[-3] } 23F9 5B JUMPDEST 23FA 61 PUSH2 0x2402 23FD 83 DUP4 23FE 61 PUSH2 0x20db 2401 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23FA stack[0] = 0x2402 // @23FD stack[1] = stack[-3] // } // Block ends with call to 0x20db, returns to 0x2402 label_2402: // Incoming return from call to 0x20DB at 0x2401 // Inputs[3] // { // @2403 stack[-1] // @2403 stack[-3] // @240A stack[-4] // } 2402 5B JUMPDEST 2403 91 SWAP2 2404 50 POP 2405 61 PUSH2 0x22e4 2408 60 PUSH1 0x20 240A 84 DUP5 240B 01 ADD 240C 61 PUSH2 0x20db 240F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2403 stack[-3] = stack[-1] // @2405 stack[-1] = 0x22e4 // @240B stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x20db, returns to 0x22E4 label_2410: // Incoming call from 0x07A1, returns to 0x07A2 // Inputs[2] // { // @2416 stack[-1] // @2417 stack[-2] // } 2410 5B JUMPDEST 2411 60 PUSH1 0x00 2413 80 DUP1 2414 60 PUSH1 0x40 2416 83 DUP4 2417 85 DUP6 2418 03 SUB 2419 12 SLT 241A 15 ISZERO 241B 61 PUSH2 0x2423 241E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2411 stack[0] = 0x00 // @2413 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2423, if !(stack[-2] - stack[-1] i< 0x40) label_241F: // Incoming jump from 0x241E, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2422 memory[0x00:0x00] } 241F 60 PUSH1 0x00 2421 80 DUP1 2422 FD *REVERT // Stack delta = +0 // Outputs[1] { @2422 revert(memory[0x00:0x00]); } // Block terminates label_2423: // Incoming jump from 0x241E, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[3] // { // @2424 stack[-3] // @2425 msg.data[stack[-3]:stack[-3] + 0x20] // @2426 stack[-2] // } 2423 5B JUMPDEST 2424 82 DUP3 2425 35 CALLDATALOAD 2426 91 SWAP2 2427 50 POP 2428 61 PUSH2 0x22e4 242B 60 PUSH1 0x20 242D 84 DUP5 242E 01 ADD 242F 61 PUSH2 0x20db 2432 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2426 stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @2428 stack[0] = 0x22e4 // @242E stack[1] = stack[-3] + 0x20 // } // Block ends with call to 0x20db, returns to 0x22E4 label_2433: // Incoming call from 0x0E83, returns to 0x0828 // Incoming call from 0x10C9, returns to 0x0CE5 // Incoming call from 0x0D72, returns to 0x0CE5 // Incoming call from 0x1245, returns to 0x1246 // Incoming call from 0x1C26, returns to 0x0828 // Incoming call from 0x0827, returns to 0x0828 // Incoming call from 0x1219, returns to 0x121A // Incoming call from 0x0853, returns to 0x0854 // Incoming call from 0x0D10, returns to 0x0D11 // Incoming call from 0x0CE4, returns to 0x0CE5 // Incoming call from 0x1F96, returns to 0x1F97 // Inputs[1] { @2436 stack[-1] } 2433 5B JUMPDEST 2434 60 PUSH1 0x01 2436 81 DUP2 2437 81 DUP2 2438 1C SHR 2439 90 SWAP1 243A 82 DUP3 243B 16 AND 243C 80 DUP1 243D 61 PUSH2 0x2447 2440 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2439 stack[0] = stack[-1] >> 0x01 // @243B stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2447, if stack[-1] & 0x01 label_2441: // Incoming jump from 0x2440, if not stack[-1] & 0x01 // Inputs[2] // { // @2443 stack[-2] // @244C stack[-1] // } 2441 60 PUSH1 0x7f 2443 82 DUP3 2444 16 AND 2445 91 SWAP2 2446 50 POP 2447 5B JUMPDEST 2448 60 PUSH1 0x20 244A 82 DUP3 244B 10 LT 244C 81 DUP2 244D 14 EQ 244E 15 ISZERO 244F 61 PUSH2 0x2468 2452 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2445 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x2468, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_2453: // Incoming jump from 0x2452, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x2452, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @2467 memory[0x00:0x24] } 2453 63 PUSH4 0x4e487b71 2458 60 PUSH1 0xe0 245A 1B SHL 245B 60 PUSH1 0x00 245D 52 MSTORE 245E 60 PUSH1 0x22 2460 60 PUSH1 0x04 2462 52 MSTORE 2463 60 PUSH1 0x24 2465 60 PUSH1 0x00 2467 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @245D memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2462 memory[0x04:0x24] = 0x22 // @2467 revert(memory[0x00:0x24]); // } // Block terminates label_2468: // Incoming jump from 0x2452, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x2452, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @246A stack[-4] // @246A stack[-2] // @246B stack[-3] // } 2468 5B JUMPDEST 2469 50 POP 246A 91 SWAP2 246B 90 SWAP1 246C 50 POP 246D 56 *JUMP // Stack delta = -3 // Outputs[1] { @246A stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_246E: // Incoming call from 0x0E61, returns to 0x09A7 // Incoming call from 0x163E, returns to 0x09A7 // Incoming call from 0x1672, returns to 0x09A7 // Incoming call from 0x09A6, returns to 0x09A7 // Incoming call from 0x158C, returns to 0x09A7 // Incoming call from 0x0E32, returns to 0x09A7 // Incoming call from 0x09F0, returns to 0x09A7 // Incoming call from 0x0C95, returns to 0x09A7 // Incoming call from 0x0DFC, returns to 0x09A7 // Incoming call from 0x0CC4, returns to 0x09A7 // Incoming call from 0x1122, returns to 0x09A7 // Incoming call from 0x10F3, returns to 0x09A7 // Incoming call from 0x0A38, returns to 0x09A7 // Inputs[2] // { // @2472 stack[-1] // @24A1 stack[-2] // } 246E 5B JUMPDEST 246F 60 PUSH1 0x20 2471 80 DUP1 2472 82 DUP3 2473 52 MSTORE 2474 81 DUP2 2475 81 DUP2 2476 01 ADD 2477 52 MSTORE 2478 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 2499 60 PUSH1 0x40 249B 82 DUP3 249C 01 ADD 249D 52 MSTORE 249E 60 PUSH1 0x60 24A0 01 ADD 24A1 90 SWAP1 24A2 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2473 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2477 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @249D memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @24A1 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_24A3: // Incoming jump from 0x0C34 // Incoming jump from 0x1D68 // Inputs[1] { @24B8 memory[0x00:0x24] } 24A3 5B JUMPDEST 24A4 63 PUSH4 0x4e487b71 24A9 60 PUSH1 0xe0 24AB 1B SHL 24AC 60 PUSH1 0x00 24AE 52 MSTORE 24AF 60 PUSH1 0x32 24B1 60 PUSH1 0x04 24B3 52 MSTORE 24B4 60 PUSH1 0x24 24B6 60 PUSH1 0x00 24B8 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @24AE memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @24B3 memory[0x04:0x24] = 0x32 // @24B8 revert(memory[0x00:0x24]); // } // Block terminates label_24B9: // Incoming jump from 0x24E2 // Incoming jump from 0x252A // Incoming jump from 0x2577 // Inputs[1] { @24CE memory[0x00:0x24] } 24B9 5B JUMPDEST 24BA 63 PUSH4 0x4e487b71 24BF 60 PUSH1 0xe0 24C1 1B SHL 24C2 60 PUSH1 0x00 24C4 52 MSTORE 24C5 60 PUSH1 0x11 24C7 60 PUSH1 0x04 24C9 52 MSTORE 24CA 60 PUSH1 0x24 24CC 60 PUSH1 0x00 24CE FD *REVERT // Stack delta = +0 // Outputs[3] // { // @24C4 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @24C9 memory[0x04:0x24] = 0x11 // @24CE revert(memory[0x00:0x24]); // } // Block terminates label_24CF: // Incoming call from 0x0C57, returns to 0x0C58 // Incoming call from 0x1DAA, returns to 0x1DAB // Incoming call from 0x1DAA, returns to 0x1DAB // Incoming call from 0x0C49, returns to 0x0C4A // Inputs[1] { @24D5 stack[-1] } 24CF 5B JUMPDEST 24D0 60 PUSH1 0x00 24D2 60 PUSH1 0x00 24D4 19 NOT 24D5 82 DUP3 24D6 14 EQ 24D7 15 ISZERO 24D8 61 PUSH2 0x24e3 24DB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24D0 stack[0] = 0x00 } // Block ends with conditional jump to 0x24e3, if !(stack[-1] == ~0x00) label_24DC: // Incoming jump from 0x24DB, if not !(stack[-1] == ~0x00) 24DC 61 PUSH2 0x24e3 24DF 61 PUSH2 0x24b9 24E2 56 *JUMP // Stack delta = +1 // Outputs[1] { @24DC stack[0] = 0x24e3 } // Block ends with unconditional jump to 0x24b9 label_24E3: // Incoming jump from 0x24DB, if !(stack[-1] == ~0x00) // Inputs[2] // { // @24E7 stack[-2] // @24E8 stack[-3] // } 24E3 5B JUMPDEST 24E4 50 POP 24E5 60 PUSH1 0x01 24E7 01 ADD 24E8 90 SWAP1 24E9 56 *JUMP // Stack delta = -2 // Outputs[1] { @24E8 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_24EA: // Incoming call from 0x15D7, returns to 0x09A7 // Incoming call from 0x0EB2, returns to 0x09A7 // Incoming call from 0x132C, returns to 0x09A7 // Inputs[2] // { // @24EE stack[-1] // @2516 stack[-2] // } 24EA 5B JUMPDEST 24EB 60 PUSH1 0x20 24ED 80 DUP1 24EE 82 DUP3 24EF 52 MSTORE 24F0 60 PUSH1 0x14 24F2 90 SWAP1 24F3 82 DUP3 24F4 01 ADD 24F5 52 MSTORE 24F6 73 PUSH20 0x496e76616c6964206d696e7420616d6f756e7421 250B 60 PUSH1 0x60 250D 1B SHL 250E 60 PUSH1 0x40 2510 82 DUP3 2511 01 ADD 2512 52 MSTORE 2513 60 PUSH1 0x60 2515 01 ADD 2516 90 SWAP1 2517 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @24EF memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @24F5 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x14 // @2512 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x496e76616c6964206d696e7420616d6f756e7421 << 0x60 // @2516 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2518: // Incoming call from 0x15F6, returns to 0x15F7 // Incoming call from 0x0ED1, returns to 0x0ED2 // Incoming call from 0x134B, returns to 0x134C // Inputs[2] // { // @251B stack[-2] // @251D stack[-1] // } 2518 5B JUMPDEST 2519 60 PUSH1 0x00 251B 82 DUP3 251C 19 NOT 251D 82 DUP3 251E 11 GT 251F 15 ISZERO 2520 61 PUSH2 0x252b 2523 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2519 stack[0] = 0x00 } // Block ends with conditional jump to 0x252b, if !(stack[-1] > ~stack[-2]) label_2524: // Incoming jump from 0x2523, if not !(stack[-1] > ~stack[-2]) 2524 61 PUSH2 0x252b 2527 61 PUSH2 0x24b9 252A 56 *JUMP // Stack delta = +1 // Outputs[1] { @2524 stack[0] = 0x252b } // Block ends with unconditional jump to 0x24b9 label_252B: // Incoming jump from 0x2523, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @252D stack[-3] // @252D stack[-2] // @252E stack[-4] // } 252B 5B JUMPDEST 252C 50 POP 252D 01 ADD 252E 90 SWAP1 252F 56 *JUMP // Stack delta = -3 // Outputs[1] { @252E stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_2530: // Incoming call from 0x0EEF, returns to 0x09A7 // Incoming call from 0x1369, returns to 0x09A7 // Incoming call from 0x1614, returns to 0x09A7 // Inputs[2] // { // @2534 stack[-1] // @255C stack[-2] // } 2530 5B JUMPDEST 2531 60 PUSH1 0x20 2533 80 DUP1 2534 82 DUP3 2535 52 MSTORE 2536 60 PUSH1 0x14 2538 90 SWAP1 2539 82 DUP3 253A 01 ADD 253B 52 MSTORE 253C 73 PUSH20 0x4d617820737570706c7920657863656564656421 2551 60 PUSH1 0x60 2553 1B SHL 2554 60 PUSH1 0x40 2556 82 DUP3 2557 01 ADD 2558 52 MSTORE 2559 60 PUSH1 0x60 255B 01 ADD 255C 90 SWAP1 255D 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2535 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @253B memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x14 // @2558 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4d617820737570706c7920657863656564656421 << 0x60 // @255C stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_255E: // Incoming call from 0x1378, returns to 0x1379 // Incoming call from 0x0EFE, returns to 0x0EFF // Inputs[2] // { // @2561 stack[-1] // @2566 stack[-2] // } 255E 5B JUMPDEST 255F 60 PUSH1 0x00 2561 81 DUP2 2562 60 PUSH1 0x00 2564 19 NOT 2565 04 DIV 2566 83 DUP4 2567 11 GT 2568 82 DUP3 2569 15 ISZERO 256A 15 ISZERO 256B 16 AND 256C 15 ISZERO 256D 61 PUSH2 0x2578 2570 57 *JUMPI // Stack delta = +1 // Outputs[1] { @255F stack[0] = 0x00 } // Block ends with conditional jump to 0x2578, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_2571: // Incoming jump from 0x2570, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 2571 61 PUSH2 0x2578 2574 61 PUSH2 0x24b9 2577 56 *JUMP // Stack delta = +1 // Outputs[1] { @2571 stack[0] = 0x2578 } // Block ends with unconditional jump to 0x24b9 label_2578: // Incoming jump from 0x2570, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @257A stack[-3] // @257A stack[-2] // @257B stack[-4] // } 2578 5B JUMPDEST 2579 50 POP 257A 02 MUL 257B 90 SWAP1 257C 56 *JUMP // Stack delta = -3 // Outputs[1] { @257B stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] 257D 5B JUMPDEST 257E 60 PUSH1 0x00 2580 84 DUP5 2581 51 MLOAD 2582 60 PUSH1 0x20 2584 61 PUSH2 0x2590 2587 82 DUP3 2588 85 DUP6 2589 83 DUP4 258A 8A DUP11 258B 01 ADD 258C 61 PUSH2 0x2057 258F 56 *JUMP 2590 5B JUMPDEST 2591 85 DUP6 2592 51 MLOAD 2593 91 SWAP2 2594 84 DUP5 2595 01 ADD 2596 91 SWAP2 2597 61 PUSH2 0x25a3 259A 81 DUP2 259B 84 DUP5 259C 84 DUP5 259D 8A DUP11 259E 01 ADD 259F 61 PUSH2 0x2057 25A2 56 *JUMP 25A3 5B JUMPDEST 25A4 85 DUP6 25A5 54 SLOAD 25A6 92 SWAP3 25A7 01 ADD 25A8 91 SWAP2 25A9 60 PUSH1 0x00 25AB 90 SWAP1 25AC 60 PUSH1 0x01 25AE 81 DUP2 25AF 81 DUP2 25B0 1C SHR 25B1 90 SWAP1 25B2 80 DUP1 25B3 83 DUP4 25B4 16 AND 25B5 80 DUP1 25B6 61 PUSH2 0x25c0 25B9 57 *JUMPI 25BA 60 PUSH1 0x7f 25BC 83 DUP4 25BD 16 AND 25BE 92 SWAP3 25BF 50 POP 25C0 5B JUMPDEST 25C1 85 DUP6 25C2 83 DUP4 25C3 10 LT 25C4 81 DUP2 25C5 14 EQ 25C6 15 ISZERO 25C7 61 PUSH2 0x25de 25CA 57 *JUMPI 25CB 63 PUSH4 0x4e487b71 25D0 60 PUSH1 0xe0 25D2 1B SHL 25D3 85 DUP6 25D4 52 MSTORE 25D5 60 PUSH1 0x22 25D7 60 PUSH1 0x04 25D9 52 MSTORE 25DA 60 PUSH1 0x24 25DC 85 DUP6 25DD FD *REVERT 25DE 5B JUMPDEST 25DF 80 DUP1 25E0 80 DUP1 25E1 15 ISZERO 25E2 61 PUSH2 0x25f2 25E5 57 *JUMPI 25E6 60 PUSH1 0x01 25E8 81 DUP2 25E9 14 EQ 25EA 61 PUSH2 0x2603 25ED 57 *JUMPI 25EE 61 PUSH2 0x2630 25F1 56 *JUMP 25F2 5B JUMPDEST 25F3 60 PUSH1 0xff 25F5 19 NOT 25F6 85 DUP6 25F7 16 AND 25F8 88 DUP9 25F9 52 MSTORE 25FA 83 DUP4 25FB 88 DUP9 25FC 01 ADD 25FD 95 SWAP6 25FE 50 POP 25FF 61 PUSH2 0x2630 2602 56 *JUMP 2603 5B JUMPDEST 2604 60 PUSH1 0x00 2606 8B DUP12 2607 81 DUP2 2608 52 MSTORE 2609 60 PUSH1 0x20 260B 90 SWAP1 260C 20 SHA3 260D 60 PUSH1 0x00 260F 5B JUMPDEST 2610 85 DUP6 2611 81 DUP2 2612 10 LT 2613 15 ISZERO 2614 61 PUSH2 0x2628 2617 57 *JUMPI 2618 81 DUP2 2619 54 SLOAD 261A 8A DUP11 261B 82 DUP3 261C 01 ADD 261D 52 MSTORE 261E 90 SWAP1 261F 84 DUP5 2620 01 ADD 2621 90 SWAP1 2622 88 DUP9 2623 01 ADD 2624 61 PUSH2 0x260f 2627 56 *JUMP 2628 5B JUMPDEST 2629 50 POP 262A 50 POP 262B 83 DUP4 262C 88 DUP9 262D 01 ADD 262E 95 SWAP6 262F 50 POP 2630 5B JUMPDEST 2631 50 POP 2632 93 SWAP4 2633 9B SWAP12 2634 9A SWAP11 2635 50 POP 2636 50 POP 2637 50 POP 2638 50 POP 2639 50 POP 263A 50 POP 263B 50 POP 263C 50 POP 263D 50 POP 263E 50 POP 263F 50 POP 2640 56 *JUMP label_2641: // Incoming call from 0x1B54, returns to 0x1B55 // Inputs[5] // { // @264A stack[-5] // @264D stack[-1] // @264F stack[-4] // @265A stack[-3] // @266F stack[-2] // } 2641 5B JUMPDEST 2642 60 PUSH1 0x01 2644 60 PUSH1 0x01 2646 60 PUSH1 0xa0 2648 1B SHL 2649 03 SUB 264A 85 DUP6 264B 81 DUP2 264C 16 AND 264D 82 DUP3 264E 52 MSTORE 264F 84 DUP5 2650 16 AND 2651 60 PUSH1 0x20 2653 82 DUP3 2654 01 ADD 2655 52 MSTORE 2656 60 PUSH1 0x40 2658 81 DUP2 2659 01 ADD 265A 83 DUP4 265B 90 SWAP1 265C 52 MSTORE 265D 60 PUSH1 0x80 265F 60 PUSH1 0x60 2661 82 DUP3 2662 01 ADD 2663 81 DUP2 2664 90 SWAP1 2665 52 MSTORE 2666 60 PUSH1 0x00 2668 90 SWAP1 2669 61 PUSH2 0x2674 266C 90 SWAP1 266D 83 DUP4 266E 01 ADD 266F 84 DUP5 2670 61 PUSH2 0x2083 2673 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @264E memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @2655 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @265C memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @2665 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @2668 stack[0] = 0x00 // @266C stack[1] = 0x2674 // @266E stack[2] = stack[-1] + 0x80 // @266F stack[3] = stack[-2] // } // Block ends with call to 0x2083, returns to 0x2674 label_2674: // Incoming return from call to 0x2083 at 0x2673 // Inputs[3] // { // @2675 stack[-8] // @2675 stack[-1] // @2676 stack[-7] // } 2674 5B JUMPDEST 2675 96 SWAP7 2676 95 SWAP6 2677 50 POP 2678 50 POP 2679 50 POP 267A 50 POP 267B 50 POP 267C 50 POP 267D 56 *JUMP // Stack delta = -7 // Outputs[1] { @2675 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_267E: // Incoming jump from 0x1B9B // Inputs[2] // { // @2683 stack[-1] // @2684 stack[-2] // } 267E 5B JUMPDEST 267F 60 PUSH1 0x00 2681 60 PUSH1 0x20 2683 82 DUP3 2684 84 DUP5 2685 03 SUB 2686 12 SLT 2687 15 ISZERO 2688 61 PUSH2 0x2690 268B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @267F stack[0] = 0x00 } // Block ends with conditional jump to 0x2690, if !(stack[-2] - stack[-1] i< 0x20) label_268C: // Incoming jump from 0x268B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @268F memory[0x00:0x00] } 268C 60 PUSH1 0x00 268E 80 DUP1 268F FD *REVERT // Stack delta = +0 // Outputs[1] { @268F revert(memory[0x00:0x00]); } // Block terminates label_2690: // Incoming jump from 0x268B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2691 stack[-2] // @2692 memory[stack[-2]:stack[-2] + 0x20] // } 2690 5B JUMPDEST 2691 81 DUP2 2692 51 MLOAD 2693 61 PUSH2 0x12f7 2696 81 DUP2 2697 61 PUSH2 0x2024 269A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2692 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2693 stack[1] = 0x12f7 // @2696 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2024, returns to 0x12F7 269B 5B JUMPDEST 269C 63 PUSH4 0x4e487b71 26A1 60 PUSH1 0xe0 26A3 1B SHL 26A4 60 PUSH1 0x00 26A6 52 MSTORE 26A7 60 PUSH1 0x12 26A9 60 PUSH1 0x04 26AB 52 MSTORE 26AC 60 PUSH1 0x24 26AE 60 PUSH1 0x00 26B0 FD *REVERT 26B1 5B JUMPDEST 26B2 60 PUSH1 0x00 26B4 82 DUP3 26B5 61 PUSH2 0x26c0 26B8 57 *JUMPI 26B9 61 PUSH2 0x26c0 26BC 61 PUSH2 0x269b 26BF 56 *JUMP 26C0 5B JUMPDEST 26C1 50 POP 26C2 04 DIV 26C3 90 SWAP1 26C4 56 *JUMP 26C5 5B JUMPDEST 26C6 60 PUSH1 0x00 26C8 82 DUP3 26C9 82 DUP3 26CA 10 LT 26CB 15 ISZERO 26CC 61 PUSH2 0x26d7 26CF 57 *JUMPI 26D0 61 PUSH2 0x26d7 26D3 61 PUSH2 0x24b9 26D6 56 *JUMP 26D7 5B JUMPDEST 26D8 50 POP 26D9 03 SUB 26DA 90 SWAP1 26DB 56 *JUMP 26DC 5B JUMPDEST 26DD 60 PUSH1 0x00 26DF 82 DUP3 26E0 61 PUSH2 0x26eb 26E3 57 *JUMPI 26E4 61 PUSH2 0x26eb 26E7 61 PUSH2 0x269b 26EA 56 *JUMP 26EB 5B JUMPDEST 26EC 50 POP 26ED 06 MOD 26EE 90 SWAP1 26EF 56 *JUMP 26F0 FE *ASSERT 26F1 A2 LOG2 26F2 64 PUSH5 0x6970667358 26F8 22 22 26F9 12 SLT 26FA 20 SHA3 26FB 4F 4F 26FC 61 PUSH2 0x1bbe 26FF 48 BASEFEE 2700 A6 A6 2701 AF AF 2702 09 MULMOD 2703 19 NOT 2704 E4 E4 2705 FC FC 2706 48 BASEFEE 2707 90 SWAP1 2708 88 DUP9 2709 E0 E0 270A 50 POP 270B 70 PUSH17 0x4b0f6214631d9ff75f18c8d27189fe6473 271D 6F PUSH16 0x6c63430008090033