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 0x0267 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0267, 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 0x66cb24a5 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 0x66cb24a5 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x66cb24a5 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xc6682862 0024 11 GT 0025 61 PUSH2 0x00b6 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b6, if 0xc6682862 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xc6682862 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xdb4bec44 002F 11 GT 0030 61 PUSH2 0x007a 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007a, if 0xdb4bec44 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xdb4bec44 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xdb4bec44 003A 14 EQ 003B 61 PUSH2 0x06ca 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06ca, if 0xdb4bec44 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xdb4bec44 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe7b99ec7 0045 14 EQ 0046 61 PUSH2 0x06fa 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06fa, if 0xe7b99ec7 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe7b99ec7 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe985e9c5 0050 14 EQ 0051 61 PUSH2 0x0710 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0710, if 0xe985e9c5 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2c4ce1e 005B 14 EQ 005C 61 PUSH2 0x0759 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0759, if 0xf2c4ce1e == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2c4ce1e == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf2fde38b 0066 14 EQ 0067 61 PUSH2 0x0779 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0779, if 0xf2fde38b == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf2fde38b == stack[-1] // Inputs[1] { @006B stack[-1] } 006B 80 DUP1 006C 63 PUSH4 0xf5aa406d 0071 14 EQ 0072 61 PUSH2 0x0799 0075 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0799, if 0xf5aa406d == stack[-1] label_0076: // Incoming jump from 0x0075, if not 0xf5aa406d == 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 0xdb4bec44 > stack[-1] // Inputs[1] { @007B stack[-1] } 007A 5B JUMPDEST 007B 80 DUP1 007C 63 PUSH4 0xc6682862 0081 14 EQ 0082 61 PUSH2 0x063f 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x063f, if 0xc6682862 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xc6682862 == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xc87b56dd 008C 14 EQ 008D 61 PUSH2 0x0654 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0654, if 0xc87b56dd == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xd49479eb 0097 14 EQ 0098 61 PUSH2 0x0674 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0674, if 0xd49479eb == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xd49479eb == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0xd5abeb01 00A2 14 EQ 00A3 61 PUSH2 0x0694 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0694, if 0xd5abeb01 == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xd5abeb01 == stack[-1] // Inputs[1] { @00A7 stack[-1] } 00A7 80 DUP1 00A8 63 PUSH4 0xda3ef23f 00AD 14 EQ 00AE 61 PUSH2 0x06aa 00B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06aa, if 0xda3ef23f == stack[-1] label_00B2: // Incoming jump from 0x00B1, if not 0xda3ef23f == 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 0xc6682862 > stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B6 5B JUMPDEST 00B7 80 DUP1 00B8 63 PUSH4 0x940cd05b 00BD 11 GT 00BE 61 PUSH2 0x0108 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0108, if 0x940cd05b > stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x940cd05b > stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x940cd05b 00C8 14 EQ 00C9 61 PUSH2 0x05a4 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a4, if 0x940cd05b == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x940cd05b == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0x95d89b41 00D3 14 EQ 00D4 61 PUSH2 0x05c4 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c4, 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 0x05d9 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d9, 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 0x05ec 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05ec, 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 0xa6d612f9 00F4 14 EQ 00F5 61 PUSH2 0x060c 00F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x060c, if 0xa6d612f9 == stack[-1] label_00F9: // Incoming jump from 0x00F8, if not 0xa6d612f9 == stack[-1] // Inputs[1] { @00F9 stack[-1] } 00F9 80 DUP1 00FA 63 PUSH4 0xb88d4fde 00FF 14 EQ 0100 61 PUSH2 0x061f 0103 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x061f, if 0xb88d4fde == stack[-1] label_0104: // Incoming jump from 0x0103, if not 0xb88d4fde == 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 0x940cd05b > stack[-1] // Inputs[1] { @0109 stack[-1] } 0108 5B JUMPDEST 0109 80 DUP1 010A 63 PUSH4 0x66cb24a5 010F 14 EQ 0110 61 PUSH2 0x0511 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0511, if 0x66cb24a5 == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x66cb24a5 == stack[-1] // Inputs[1] { @0114 stack[-1] } 0114 80 DUP1 0115 63 PUSH4 0x6f8b44b0 011A 14 EQ 011B 61 PUSH2 0x0531 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0531, if 0x6f8b44b0 == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x6f8b44b0 == stack[-1] // Inputs[1] { @011F stack[-1] } 011F 80 DUP1 0120 63 PUSH4 0x70a08231 0125 14 EQ 0126 61 PUSH2 0x0551 0129 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0551, if 0x70a08231 == stack[-1] label_012A: // Incoming jump from 0x0129, if not 0x70a08231 == stack[-1] // Inputs[1] { @012A stack[-1] } 012A 80 DUP1 012B 63 PUSH4 0x715018a6 0130 14 EQ 0131 61 PUSH2 0x0571 0134 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0571, if 0x715018a6 == stack[-1] label_0135: // Incoming jump from 0x0134, if not 0x715018a6 == stack[-1] // Inputs[1] { @0135 stack[-1] } 0135 80 DUP1 0136 63 PUSH4 0x8da5cb5b 013B 14 EQ 013C 61 PUSH2 0x0586 013F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0586, 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 0x66cb24a5 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0145 stack[-1] } 0144 5B JUMPDEST 0145 80 DUP1 0146 63 PUSH4 0x23b872dd 014B 11 GT 014C 61 PUSH2 0x01dd 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01dd, if 0x23b872dd > stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x23b872dd > stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x488caa73 0156 11 GT 0157 61 PUSH2 0x01a1 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a1, if 0x488caa73 > stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x488caa73 > stack[-1] // Inputs[1] { @015B stack[-1] } 015B 80 DUP1 015C 63 PUSH4 0x488caa73 0161 14 EQ 0162 61 PUSH2 0x0463 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0463, if 0x488caa73 == stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x488caa73 == stack[-1] // Inputs[1] { @0166 stack[-1] } 0166 80 DUP1 0167 63 PUSH4 0x51830227 016C 14 EQ 016D 61 PUSH2 0x0483 0170 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0483, if 0x51830227 == stack[-1] label_0171: // Incoming jump from 0x0170, if not 0x51830227 == stack[-1] // Inputs[1] { @0171 stack[-1] } 0171 80 DUP1 0172 63 PUSH4 0x55f804b3 0177 14 EQ 0178 61 PUSH2 0x049d 017B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x049d, if 0x55f804b3 == stack[-1] label_017C: // Incoming jump from 0x017B, if not 0x55f804b3 == stack[-1] // Inputs[1] { @017C stack[-1] } 017C 80 DUP1 017D 63 PUSH4 0x5c975abb 0182 14 EQ 0183 61 PUSH2 0x04bd 0186 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04bd, if 0x5c975abb == stack[-1] label_0187: // Incoming jump from 0x0186, if not 0x5c975abb == stack[-1] // Inputs[1] { @0187 stack[-1] } 0187 80 DUP1 0188 63 PUSH4 0x61e61a25 018D 14 EQ 018E 61 PUSH2 0x04d7 0191 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d7, if 0x61e61a25 == stack[-1] label_0192: // Incoming jump from 0x0191, if not 0x61e61a25 == stack[-1] // Inputs[1] { @0192 stack[-1] } 0192 80 DUP1 0193 63 PUSH4 0x6352211e 0198 14 EQ 0199 61 PUSH2 0x04f1 019C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f1, if 0x6352211e == stack[-1] label_019D: // Incoming jump from 0x019C, if not 0x6352211e == 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 0x488caa73 > stack[-1] // Inputs[1] { @01A2 stack[-1] } 01A1 5B JUMPDEST 01A2 80 DUP1 01A3 63 PUSH4 0x23b872dd 01A8 14 EQ 01A9 61 PUSH2 0x03e5 01AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e5, if 0x23b872dd == stack[-1] label_01AD: // Incoming jump from 0x01AC, if not 0x23b872dd == stack[-1] // Inputs[1] { @01AD stack[-1] } 01AD 80 DUP1 01AE 63 PUSH4 0x386bfc98 01B3 14 EQ 01B4 61 PUSH2 0x0405 01B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0405, if 0x386bfc98 == stack[-1] label_01B8: // Incoming jump from 0x01B7, if not 0x386bfc98 == stack[-1] // Inputs[1] { @01B8 stack[-1] } 01B8 80 DUP1 01B9 63 PUSH4 0x3ccfd60b 01BE 14 EQ 01BF 61 PUSH2 0x041b 01C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x041b, if 0x3ccfd60b == stack[-1] label_01C3: // Incoming jump from 0x01C2, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @01C3 stack[-1] } 01C3 80 DUP1 01C4 63 PUSH4 0x42842e0e 01C9 14 EQ 01CA 61 PUSH2 0x0423 01CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0423, if 0x42842e0e == stack[-1] label_01CE: // Incoming jump from 0x01CD, if not 0x42842e0e == stack[-1] // Inputs[1] { @01CE stack[-1] } 01CE 80 DUP1 01CF 63 PUSH4 0x44a0d68a 01D4 14 EQ 01D5 61 PUSH2 0x0443 01D8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0443, if 0x44a0d68a == stack[-1] label_01D9: // Incoming jump from 0x01D8, if not 0x44a0d68a == 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 0x23b872dd > stack[-1] // Inputs[1] { @01DE stack[-1] } 01DD 5B JUMPDEST 01DE 80 DUP1 01DF 63 PUSH4 0x088a4ed0 01E4 11 GT 01E5 61 PUSH2 0x022f 01E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x022f, if 0x088a4ed0 > stack[-1] label_01E9: // Incoming jump from 0x01E8, if not 0x088a4ed0 > stack[-1] // Inputs[1] { @01E9 stack[-1] } 01E9 80 DUP1 01EA 63 PUSH4 0x088a4ed0 01EF 14 EQ 01F0 61 PUSH2 0x0332 01F3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0332, if 0x088a4ed0 == stack[-1] label_01F4: // Incoming jump from 0x01F3, if not 0x088a4ed0 == stack[-1] // Inputs[1] { @01F4 stack[-1] } 01F4 80 DUP1 01F5 63 PUSH4 0x095ea7b3 01FA 14 EQ 01FB 61 PUSH2 0x0352 01FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0352, if 0x095ea7b3 == stack[-1] label_01FF: // Incoming jump from 0x01FE, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @01FF stack[-1] } 01FF 80 DUP1 0200 63 PUSH4 0x13faede6 0205 14 EQ 0206 61 PUSH2 0x0372 0209 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0372, if 0x13faede6 == stack[-1] label_020A: // Incoming jump from 0x0209, if not 0x13faede6 == stack[-1] // Inputs[1] { @020A stack[-1] } 020A 80 DUP1 020B 63 PUSH4 0x18160ddd 0210 14 EQ 0211 61 PUSH2 0x0396 0214 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0396, if 0x18160ddd == stack[-1] label_0215: // Incoming jump from 0x0214, if not 0x18160ddd == stack[-1] // Inputs[1] { @0215 stack[-1] } 0215 80 DUP1 0216 63 PUSH4 0x21b8092e 021B 14 EQ 021C 61 PUSH2 0x03af 021F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03af, if 0x21b8092e == stack[-1] label_0220: // Incoming jump from 0x021F, if not 0x21b8092e == stack[-1] // Inputs[1] { @0220 stack[-1] } 0220 80 DUP1 0221 63 PUSH4 0x239c70ae 0226 14 EQ 0227 61 PUSH2 0x03cf 022A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03cf, if 0x239c70ae == stack[-1] label_022B: // Incoming jump from 0x022A, if not 0x239c70ae == stack[-1] // Inputs[1] { @022E memory[0x00:0x00] } 022B 60 PUSH1 0x00 022D 80 DUP1 022E FD *REVERT // Stack delta = +0 // Outputs[1] { @022E revert(memory[0x00:0x00]); } // Block terminates label_022F: // Incoming jump from 0x01E8, if 0x088a4ed0 > stack[-1] // Inputs[1] { @0230 stack[-1] } 022F 5B JUMPDEST 0230 80 DUP1 0231 63 PUSH4 0x01ffc9a7 0236 14 EQ 0237 61 PUSH2 0x026c 023A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026c, if 0x01ffc9a7 == stack[-1] label_023B: // Incoming jump from 0x023A, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @023B stack[-1] } 023B 80 DUP1 023C 63 PUSH4 0x02329a29 0241 14 EQ 0242 61 PUSH2 0x02a1 0245 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a1, if 0x02329a29 == stack[-1] label_0246: // Incoming jump from 0x0245, if not 0x02329a29 == stack[-1] // Inputs[1] { @0246 stack[-1] } 0246 80 DUP1 0247 63 PUSH4 0x06fdde03 024C 14 EQ 024D 61 PUSH2 0x02c3 0250 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c3, if 0x06fdde03 == stack[-1] label_0251: // Incoming jump from 0x0250, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0251 stack[-1] } 0251 80 DUP1 0252 63 PUSH4 0x081812fc 0257 14 EQ 0258 61 PUSH2 0x02e5 025B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e5, if 0x081812fc == stack[-1] label_025C: // Incoming jump from 0x025B, if not 0x081812fc == stack[-1] // Inputs[1] { @025C stack[-1] } 025C 80 DUP1 025D 63 PUSH4 0x081c8c44 0262 14 EQ 0263 61 PUSH2 0x031d 0266 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x031d, if 0x081c8c44 == stack[-1] label_0267: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x0266, if not 0x081c8c44 == stack[-1] // Inputs[1] { @026B memory[0x00:0x00] } 0267 5B JUMPDEST 0268 60 PUSH1 0x00 026A 80 DUP1 026B FD *REVERT // Stack delta = +0 // Outputs[1] { @026B revert(memory[0x00:0x00]); } // Block terminates label_026C: // Incoming jump from 0x023A, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @026D msg.value } 026C 5B JUMPDEST 026D 34 CALLVALUE 026E 80 DUP1 026F 15 ISZERO 0270 61 PUSH2 0x0278 0273 57 *JUMPI // Stack delta = +1 // Outputs[1] { @026D stack[0] = msg.value } // Block ends with conditional jump to 0x0278, if !msg.value label_0274: // Incoming jump from 0x0273, if not !msg.value // Inputs[1] { @0277 memory[0x00:0x00] } 0274 60 PUSH1 0x00 0276 80 DUP1 0277 FD *REVERT // Stack delta = +0 // Outputs[1] { @0277 revert(memory[0x00:0x00]); } // Block terminates label_0278: // Incoming jump from 0x0273, if !msg.value // Inputs[1] { @0280 msg.data.length } 0278 5B JUMPDEST 0279 50 POP 027A 61 PUSH2 0x028c 027D 61 PUSH2 0x0287 0280 36 CALLDATASIZE 0281 60 PUSH1 0x04 0283 61 PUSH2 0x2344 0286 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @027A stack[-1] = 0x028c // @027D stack[0] = 0x0287 // @0280 stack[1] = msg.data.length // @0281 stack[2] = 0x04 // } // Block ends with call to 0x2344, returns to 0x0287 label_0287: // Incoming return from call to 0x2344 at 0x0286 0287 5B JUMPDEST 0288 61 PUSH2 0x07b9 028B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07b9 label_028C: // Incoming jump from 0x049C // Incoming return from call to 0x072B at 0x072A // Incoming jump from 0x04F0 // Incoming return from call to 0x06E5 at 0x06E4 // Incoming return from call to 0x0287 at 0x0286 // Incoming jump from 0x04D6 // Inputs[2] // { // @028F memory[0x40:0x60] // @0290 stack[-1] // } 028C 5B JUMPDEST 028D 60 PUSH1 0x40 028F 51 MLOAD 0290 90 SWAP1 0291 15 ISZERO 0292 15 ISZERO 0293 81 DUP2 0294 52 MSTORE 0295 60 PUSH1 0x20 0297 01 ADD // Stack delta = +0 // Outputs[2] // { // @0294 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0297 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_0298: // Incoming jump from 0x031C // Incoming jump from 0x0395 // Incoming jump from 0x0297 // Inputs[3] // { // @029B memory[0x40:0x60] // @029D stack[-1] // @02A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0298 5B JUMPDEST 0299 60 PUSH1 0x40 029B 51 MLOAD 029C 80 DUP1 029D 91 SWAP2 029E 03 SUB 029F 90 SWAP1 02A0 F3 *RETURN // Stack delta = -1 // Outputs[1] { @02A0 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02A1: // Incoming jump from 0x0245, if 0x02329a29 == stack[-1] // Inputs[1] { @02A2 msg.value } 02A1 5B JUMPDEST 02A2 34 CALLVALUE 02A3 80 DUP1 02A4 15 ISZERO 02A5 61 PUSH2 0x02ad 02A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02A2 stack[0] = msg.value } // Block ends with conditional jump to 0x02ad, if !msg.value label_02A9: // Incoming jump from 0x02A8, if not !msg.value // Inputs[1] { @02AC memory[0x00:0x00] } 02A9 60 PUSH1 0x00 02AB 80 DUP1 02AC FD *REVERT // Stack delta = +0 // Outputs[1] { @02AC revert(memory[0x00:0x00]); } // Block terminates label_02AD: // Incoming jump from 0x02A8, if !msg.value // Inputs[1] { @02B5 msg.data.length } 02AD 5B JUMPDEST 02AE 50 POP 02AF 61 PUSH2 0x02c1 02B2 61 PUSH2 0x02bc 02B5 36 CALLDATASIZE 02B6 60 PUSH1 0x04 02B8 61 PUSH2 0x2312 02BB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02AF stack[-1] = 0x02c1 // @02B2 stack[0] = 0x02bc // @02B5 stack[1] = msg.data.length // @02B6 stack[2] = 0x04 // } // Block ends with call to 0x2312, returns to 0x02BC label_02BC: // Incoming return from call to 0x2312 at 0x02BB 02BC 5B JUMPDEST 02BD 61 PUSH2 0x080b 02C0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x080b label_02C1: // Incoming return from call to 0x061A at 0x0619 // Incoming return from call to 0x05E7 at 0x05E6 // Incoming return from call to 0x052C at 0x052B // Incoming return from call to 0x0E21 at 0x0585 // Incoming return from call to 0x054C at 0x054B // Incoming return from call to 0x068F at 0x068E // Incoming return from call to 0x05BF at 0x05BE // Incoming return from call to 0x02BC at 0x02BB // Incoming return from call to 0x045E at 0x045D // Incoming return from call to 0x03CA at 0x03C9 // Incoming return from call to 0x0B5A at 0x0422 // Incoming return from call to 0x07B4 at 0x07B3 // Incoming return from call to 0x034D at 0x034C // Incoming return from call to 0x0607 at 0x0606 02C1 5B JUMPDEST 02C2 00 *STOP // Stack delta = +0 // Outputs[1] { @02C2 stop(); } // Block terminates label_02C3: // Incoming jump from 0x0250, if 0x06fdde03 == stack[-1] // Inputs[1] { @02C4 msg.value } 02C3 5B JUMPDEST 02C4 34 CALLVALUE 02C5 80 DUP1 02C6 15 ISZERO 02C7 61 PUSH2 0x02cf 02CA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C4 stack[0] = msg.value } // Block ends with conditional jump to 0x02cf, if !msg.value label_02CB: // Incoming jump from 0x02CA, if not !msg.value // Inputs[1] { @02CE memory[0x00:0x00] } 02CB 60 PUSH1 0x00 02CD 80 DUP1 02CE FD *REVERT // Stack delta = +0 // Outputs[1] { @02CE revert(memory[0x00:0x00]); } // Block terminates label_02CF: // Incoming jump from 0x02CA, if !msg.value 02CF 5B JUMPDEST 02D0 50 POP 02D1 61 PUSH2 0x02d8 02D4 61 PUSH2 0x0886 02D7 56 *JUMP // Stack delta = +0 // Outputs[1] { @02D1 stack[-1] = 0x02d8 } // Block ends with call to 0x0886, returns to 0x02D8 label_02D8: // Incoming return from call to 0x0EC2 at 0x05D8 // Incoming return from call to 0x095C at 0x0331 // Incoming return from call to 0x13D9 at 0x0653 // Incoming return from call to 0x0886 at 0x02D7 // Incoming return from call to 0x066F at 0x066E // Inputs[2] // { // @02DB memory[0x40:0x60] // @02DF stack[-1] // } 02D8 5B JUMPDEST 02D9 60 PUSH1 0x40 02DB 51 MLOAD 02DC 61 PUSH2 0x0298 02DF 91 SWAP2 02E0 90 SWAP1 02E1 61 PUSH2 0x252d 02E4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02DF stack[-1] = 0x0298 // @02E0 stack[1] = memory[0x40:0x60] // @02E0 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x252d label_02E5: // Incoming jump from 0x025B, if 0x081812fc == stack[-1] // Inputs[1] { @02E6 msg.value } 02E5 5B JUMPDEST 02E6 34 CALLVALUE 02E7 80 DUP1 02E8 15 ISZERO 02E9 61 PUSH2 0x02f1 02EC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02E6 stack[0] = msg.value } // Block ends with conditional jump to 0x02f1, if !msg.value label_02ED: // Incoming jump from 0x02EC, if not !msg.value // Inputs[1] { @02F0 memory[0x00:0x00] } 02ED 60 PUSH1 0x00 02EF 80 DUP1 02F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @02F0 revert(memory[0x00:0x00]); } // Block terminates label_02F1: // Incoming jump from 0x02EC, if !msg.value // Inputs[1] { @02F9 msg.data.length } 02F1 5B JUMPDEST 02F2 50 POP 02F3 61 PUSH2 0x0305 02F6 61 PUSH2 0x0300 02F9 36 CALLDATASIZE 02FA 60 PUSH1 0x04 02FC 61 PUSH2 0x232c 02FF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02F3 stack[-1] = 0x0305 // @02F6 stack[0] = 0x0300 // @02F9 stack[1] = msg.data.length // @02FA stack[2] = 0x04 // } // Block ends with call to 0x232c, returns to 0x0300 label_0300: // Incoming return from call to 0x232C at 0x02FF 0300 5B JUMPDEST 0301 61 PUSH2 0x0918 0304 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0918 label_0305: // Incoming jump from 0x05A3 // Incoming jump from 0x0482 // Incoming return from call to 0x050C at 0x050B // Incoming return from call to 0x0300 at 0x02FF // Inputs[2] // { // @0308 memory[0x40:0x60] // @0312 stack[-1] // } 0305 5B JUMPDEST 0306 60 PUSH1 0x40 0308 51 MLOAD 0309 60 PUSH1 0x01 030B 60 PUSH1 0x01 030D 60 PUSH1 0xa0 030F 1B SHL 0310 03 SUB 0311 90 SWAP1 0312 91 SWAP2 0313 16 AND 0314 81 DUP2 0315 52 MSTORE 0316 60 PUSH1 0x20 0318 01 ADD 0319 61 PUSH2 0x0298 031C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0315 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0318 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0298 label_031D: // Incoming jump from 0x0266, if 0x081c8c44 == stack[-1] // Inputs[1] { @031E msg.value } 031D 5B JUMPDEST 031E 34 CALLVALUE 031F 80 DUP1 0320 15 ISZERO 0321 61 PUSH2 0x0329 0324 57 *JUMPI // Stack delta = +1 // Outputs[1] { @031E stack[0] = msg.value } // Block ends with conditional jump to 0x0329, if !msg.value label_0325: // Incoming jump from 0x0324, if not !msg.value // Inputs[1] { @0328 memory[0x00:0x00] } 0325 60 PUSH1 0x00 0327 80 DUP1 0328 FD *REVERT // Stack delta = +0 // Outputs[1] { @0328 revert(memory[0x00:0x00]); } // Block terminates label_0329: // Incoming jump from 0x0324, if !msg.value 0329 5B JUMPDEST 032A 50 POP 032B 61 PUSH2 0x02d8 032E 61 PUSH2 0x095c 0331 56 *JUMP // Stack delta = +0 // Outputs[1] { @032B stack[-1] = 0x02d8 } // Block ends with call to 0x095c, returns to 0x02D8 label_0332: // Incoming jump from 0x01F3, if 0x088a4ed0 == stack[-1] // Inputs[1] { @0333 msg.value } 0332 5B JUMPDEST 0333 34 CALLVALUE 0334 80 DUP1 0335 15 ISZERO 0336 61 PUSH2 0x033e 0339 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0333 stack[0] = msg.value } // Block ends with conditional jump to 0x033e, if !msg.value label_033A: // Incoming jump from 0x0339, if not !msg.value // Inputs[1] { @033D memory[0x00:0x00] } 033A 60 PUSH1 0x00 033C 80 DUP1 033D FD *REVERT // Stack delta = +0 // Outputs[1] { @033D revert(memory[0x00:0x00]); } // Block terminates label_033E: // Incoming jump from 0x0339, if !msg.value // Inputs[1] { @0346 msg.data.length } 033E 5B JUMPDEST 033F 50 POP 0340 61 PUSH2 0x02c1 0343 61 PUSH2 0x034d 0346 36 CALLDATASIZE 0347 60 PUSH1 0x04 0349 61 PUSH2 0x232c 034C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0340 stack[-1] = 0x02c1 // @0343 stack[0] = 0x034d // @0346 stack[1] = msg.data.length // @0347 stack[2] = 0x04 // } // Block ends with call to 0x232c, returns to 0x034D label_034D: // Incoming return from call to 0x232C at 0x034C 034D 5B JUMPDEST 034E 61 PUSH2 0x09ea 0351 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09ea label_0352: // Incoming jump from 0x01FE, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0353 msg.value } 0352 5B JUMPDEST 0353 34 CALLVALUE 0354 80 DUP1 0355 15 ISZERO 0356 61 PUSH2 0x035e 0359 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0353 stack[0] = msg.value } // Block ends with conditional jump to 0x035e, if !msg.value label_035A: // Incoming jump from 0x0359, if not !msg.value // Inputs[1] { @035D memory[0x00:0x00] } 035A 60 PUSH1 0x00 035C 80 DUP1 035D FD *REVERT // Stack delta = +0 // Outputs[1] { @035D revert(memory[0x00:0x00]); } // Block terminates label_035E: // Incoming jump from 0x0359, if !msg.value // Inputs[1] { @0366 msg.data.length } 035E 5B JUMPDEST 035F 50 POP 0360 61 PUSH2 0x02c1 0363 61 PUSH2 0x036d 0366 36 CALLDATASIZE 0367 60 PUSH1 0x04 0369 61 PUSH2 0x2274 036C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0360 stack[-1] = 0x02c1 // @0363 stack[0] = 0x036d // @0366 stack[1] = msg.data.length // @0367 stack[2] = 0x04 // } // Block ends with call to 0x2274, returns to 0x036D label_036D: // Incoming return from call to 0x2274 at 0x036C 036D 5B JUMPDEST 036E 61 PUSH2 0x0a49 0371 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a49 label_0372: // Incoming jump from 0x0209, if 0x13faede6 == stack[-1] // Inputs[1] { @0373 msg.value } 0372 5B JUMPDEST 0373 34 CALLVALUE 0374 80 DUP1 0375 15 ISZERO 0376 61 PUSH2 0x037e 0379 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0373 stack[0] = msg.value } // Block ends with conditional jump to 0x037e, if !msg.value label_037A: // Incoming jump from 0x0379, if not !msg.value // Inputs[1] { @037D memory[0x00:0x00] } 037A 60 PUSH1 0x00 037C 80 DUP1 037D FD *REVERT // Stack delta = +0 // Outputs[1] { @037D revert(memory[0x00:0x00]); } // Block terminates label_037E: // Incoming jump from 0x0379, if !msg.value // Inputs[1] { @0385 storage[0x0d] } 037E 5B JUMPDEST 037F 50 POP 0380 61 PUSH2 0x0388 0383 60 PUSH1 0x0d 0385 54 SLOAD 0386 81 DUP2 0387 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0380 stack[-1] = 0x0388 // @0385 stack[0] = storage[0x0d] // } // Block ends with unconditional jump to 0x0388 label_0388: // Incoming jump from 0x03E4 // Incoming jump from 0x070F // Incoming jump from 0x06A9 // Incoming return from call to 0x056C at 0x056B // Incoming jump from 0x0387 // Incoming jump from 0x041A // Incoming jump from 0x03AE // Inputs[2] // { // @038B memory[0x40:0x60] // @038C stack[-1] // } 0388 5B JUMPDEST 0389 60 PUSH1 0x40 038B 51 MLOAD 038C 90 SWAP1 038D 81 DUP2 038E 52 MSTORE 038F 60 PUSH1 0x20 0391 01 ADD 0392 61 PUSH2 0x0298 0395 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @038E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0391 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0298 label_0396: // Incoming jump from 0x0214, if 0x18160ddd == stack[-1] // Inputs[1] { @0397 msg.value } 0396 5B JUMPDEST 0397 34 CALLVALUE 0398 80 DUP1 0399 15 ISZERO 039A 61 PUSH2 0x03a2 039D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0397 stack[0] = msg.value } // Block ends with conditional jump to 0x03a2, if !msg.value label_039E: // Incoming jump from 0x039D, if not !msg.value // Inputs[1] { @03A1 memory[0x00:0x00] } 039E 60 PUSH1 0x00 03A0 80 DUP1 03A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A1 revert(memory[0x00:0x00]); } // Block terminates label_03A2: // Incoming jump from 0x039D, if !msg.value // Inputs[2] // { // @03A6 storage[0x01] // @03A9 storage[0x00] // } 03A2 5B JUMPDEST 03A3 50 POP 03A4 60 PUSH1 0x01 03A6 54 SLOAD 03A7 60 PUSH1 0x00 03A9 54 SLOAD 03AA 03 SUB 03AB 61 PUSH2 0x0388 03AE 56 *JUMP // Stack delta = +0 // Outputs[1] { @03AA stack[-1] = storage[0x00] - storage[0x01] } // Block ends with unconditional jump to 0x0388 label_03AF: // Incoming jump from 0x021F, if 0x21b8092e == stack[-1] // Inputs[1] { @03B0 msg.value } 03AF 5B JUMPDEST 03B0 34 CALLVALUE 03B1 80 DUP1 03B2 15 ISZERO 03B3 61 PUSH2 0x03bb 03B6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03B0 stack[0] = msg.value } // Block ends with conditional jump to 0x03bb, if !msg.value label_03B7: // Incoming jump from 0x03B6, if not !msg.value // Inputs[1] { @03BA memory[0x00:0x00] } 03B7 60 PUSH1 0x00 03B9 80 DUP1 03BA FD *REVERT // Stack delta = +0 // Outputs[1] { @03BA revert(memory[0x00:0x00]); } // Block terminates label_03BB: // Incoming jump from 0x03B6, if !msg.value // Inputs[1] { @03C3 msg.data.length } 03BB 5B JUMPDEST 03BC 50 POP 03BD 61 PUSH2 0x02c1 03C0 61 PUSH2 0x03ca 03C3 36 CALLDATASIZE 03C4 60 PUSH1 0x04 03C6 61 PUSH2 0x214c 03C9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03BD stack[-1] = 0x02c1 // @03C0 stack[0] = 0x03ca // @03C3 stack[1] = msg.data.length // @03C4 stack[2] = 0x04 // } // Block ends with call to 0x214c, returns to 0x03CA label_03CA: // Incoming return from call to 0x214C at 0x03C9 03CA 5B JUMPDEST 03CB 61 PUSH2 0x0ad7 03CE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ad7 label_03CF: // Incoming jump from 0x022A, if 0x239c70ae == stack[-1] // Inputs[1] { @03D0 msg.value } 03CF 5B JUMPDEST 03D0 34 CALLVALUE 03D1 80 DUP1 03D2 15 ISZERO 03D3 61 PUSH2 0x03db 03D6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03D0 stack[0] = msg.value } // Block ends with conditional jump to 0x03db, if !msg.value label_03D7: // Incoming jump from 0x03D6, if not !msg.value // Inputs[1] { @03DA memory[0x00:0x00] } 03D7 60 PUSH1 0x00 03D9 80 DUP1 03DA FD *REVERT // Stack delta = +0 // Outputs[1] { @03DA revert(memory[0x00:0x00]); } // Block terminates label_03DB: // Incoming jump from 0x03D6, if !msg.value // Inputs[1] { @03E2 storage[0x10] } 03DB 5B JUMPDEST 03DC 50 POP 03DD 61 PUSH2 0x0388 03E0 60 PUSH1 0x10 03E2 54 SLOAD 03E3 81 DUP2 03E4 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03DD stack[-1] = 0x0388 // @03E2 stack[0] = storage[0x10] // } // Block ends with unconditional jump to 0x0388 label_03E5: // Incoming jump from 0x01AC, if 0x23b872dd == stack[-1] // Inputs[1] { @03E6 msg.value } 03E5 5B JUMPDEST 03E6 34 CALLVALUE 03E7 80 DUP1 03E8 15 ISZERO 03E9 61 PUSH2 0x03f1 03EC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E6 stack[0] = msg.value } // Block ends with conditional jump to 0x03f1, if !msg.value label_03ED: // Incoming jump from 0x03EC, if not !msg.value // Inputs[1] { @03F0 memory[0x00:0x00] } 03ED 60 PUSH1 0x00 03EF 80 DUP1 03F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F0 revert(memory[0x00:0x00]); } // Block terminates label_03F1: // Incoming jump from 0x03EC, if !msg.value // Inputs[1] { @03F9 msg.data.length } 03F1 5B JUMPDEST 03F2 50 POP 03F3 61 PUSH2 0x02c1 03F6 61 PUSH2 0x0400 03F9 36 CALLDATASIZE 03FA 60 PUSH1 0x04 03FC 61 PUSH2 0x2198 03FF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03F3 stack[-1] = 0x02c1 // @03F6 stack[0] = 0x0400 // @03F9 stack[1] = msg.data.length // @03FA stack[2] = 0x04 // } // Block ends with call to 0x2198, returns to 0x0400 label_0400: // Incoming return from call to 0x2198 at 0x03FF 0400 5B JUMPDEST 0401 61 PUSH2 0x0b4f 0404 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b4f label_0405: // Incoming jump from 0x01B7, if 0x386bfc98 == stack[-1] // Inputs[1] { @0406 msg.value } 0405 5B JUMPDEST 0406 34 CALLVALUE 0407 80 DUP1 0408 15 ISZERO 0409 61 PUSH2 0x0411 040C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0406 stack[0] = msg.value } // Block ends with conditional jump to 0x0411, if !msg.value label_040D: // Incoming jump from 0x040C, if not !msg.value // Inputs[1] { @0410 memory[0x00:0x00] } 040D 60 PUSH1 0x00 040F 80 DUP1 0410 FD *REVERT // Stack delta = +0 // Outputs[1] { @0410 revert(memory[0x00:0x00]); } // Block terminates label_0411: // Incoming jump from 0x040C, if !msg.value // Inputs[1] { @0418 storage[0x13] } 0411 5B JUMPDEST 0412 50 POP 0413 61 PUSH2 0x0388 0416 60 PUSH1 0x13 0418 54 SLOAD 0419 81 DUP2 041A 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0413 stack[-1] = 0x0388 // @0418 stack[0] = storage[0x13] // } // Block ends with unconditional jump to 0x0388 label_041B: // Incoming jump from 0x01C2, if 0x3ccfd60b == stack[-1] 041B 5B JUMPDEST 041C 61 PUSH2 0x02c1 041F 61 PUSH2 0x0b5a 0422 56 *JUMP // Stack delta = +1 // Outputs[1] { @041C stack[0] = 0x02c1 } // Block ends with call to 0x0b5a, returns to 0x02C1 label_0423: // Incoming jump from 0x01CD, if 0x42842e0e == stack[-1] // Inputs[1] { @0424 msg.value } 0423 5B JUMPDEST 0424 34 CALLVALUE 0425 80 DUP1 0426 15 ISZERO 0427 61 PUSH2 0x042f 042A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0424 stack[0] = msg.value } // Block ends with conditional jump to 0x042f, if !msg.value label_042B: // Incoming jump from 0x042A, if not !msg.value // Inputs[1] { @042E memory[0x00:0x00] } 042B 60 PUSH1 0x00 042D 80 DUP1 042E FD *REVERT // Stack delta = +0 // Outputs[1] { @042E revert(memory[0x00:0x00]); } // Block terminates label_042F: // Incoming jump from 0x042A, if !msg.value // Inputs[1] { @0437 msg.data.length } 042F 5B JUMPDEST 0430 50 POP 0431 61 PUSH2 0x02c1 0434 61 PUSH2 0x043e 0437 36 CALLDATASIZE 0438 60 PUSH1 0x04 043A 61 PUSH2 0x2198 043D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0431 stack[-1] = 0x02c1 // @0434 stack[0] = 0x043e // @0437 stack[1] = msg.data.length // @0438 stack[2] = 0x04 // } // Block ends with call to 0x2198, returns to 0x043E label_043E: // Incoming return from call to 0x2198 at 0x043D 043E 5B JUMPDEST 043F 61 PUSH2 0x0c10 0442 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c10 label_0443: // Incoming jump from 0x01D8, if 0x44a0d68a == stack[-1] // Inputs[1] { @0444 msg.value } 0443 5B JUMPDEST 0444 34 CALLVALUE 0445 80 DUP1 0446 15 ISZERO 0447 61 PUSH2 0x044f 044A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0444 stack[0] = msg.value } // Block ends with conditional jump to 0x044f, if !msg.value label_044B: // Incoming jump from 0x044A, if not !msg.value // Inputs[1] { @044E memory[0x00:0x00] } 044B 60 PUSH1 0x00 044D 80 DUP1 044E FD *REVERT // Stack delta = +0 // Outputs[1] { @044E revert(memory[0x00:0x00]); } // Block terminates label_044F: // Incoming jump from 0x044A, if !msg.value // Inputs[1] { @0457 msg.data.length } 044F 5B JUMPDEST 0450 50 POP 0451 61 PUSH2 0x02c1 0454 61 PUSH2 0x045e 0457 36 CALLDATASIZE 0458 60 PUSH1 0x04 045A 61 PUSH2 0x232c 045D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0451 stack[-1] = 0x02c1 // @0454 stack[0] = 0x045e // @0457 stack[1] = msg.data.length // @0458 stack[2] = 0x04 // } // Block ends with call to 0x232c, returns to 0x045E label_045E: // Incoming return from call to 0x232C at 0x045D 045E 5B JUMPDEST 045F 61 PUSH2 0x0c2b 0462 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c2b label_0463: // Incoming jump from 0x0165, if 0x488caa73 == stack[-1] // Inputs[1] { @0464 msg.value } 0463 5B JUMPDEST 0464 34 CALLVALUE 0465 80 DUP1 0466 15 ISZERO 0467 61 PUSH2 0x046f 046A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0464 stack[0] = msg.value } // Block ends with conditional jump to 0x046f, if !msg.value label_046B: // Incoming jump from 0x046A, if not !msg.value // Inputs[1] { @046E memory[0x00:0x00] } 046B 60 PUSH1 0x00 046D 80 DUP1 046E FD *REVERT // Stack delta = +0 // Outputs[1] { @046E revert(memory[0x00:0x00]); } // Block terminates label_046F: // Incoming jump from 0x046A, if !msg.value // Inputs[1] { @0473 storage[0x09] } 046F 5B JUMPDEST 0470 50 POP 0471 60 PUSH1 0x09 0473 54 SLOAD 0474 61 PUSH2 0x0305 0477 90 SWAP1 0478 60 PUSH1 0x01 047A 60 PUSH1 0x01 047C 60 PUSH1 0xa0 047E 1B SHL 047F 03 SUB 0480 16 AND 0481 81 DUP2 0482 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0477 stack[-1] = 0x0305 // @0480 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x09] // } // Block ends with unconditional jump to 0x0305 label_0483: // Incoming jump from 0x0170, if 0x51830227 == stack[-1] // Inputs[1] { @0484 msg.value } 0483 5B JUMPDEST 0484 34 CALLVALUE 0485 80 DUP1 0486 15 ISZERO 0487 61 PUSH2 0x048f 048A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0484 stack[0] = msg.value } // Block ends with conditional jump to 0x048f, if !msg.value label_048B: // Incoming jump from 0x048A, if not !msg.value // Inputs[1] { @048E memory[0x00:0x00] } 048B 60 PUSH1 0x00 048D 80 DUP1 048E FD *REVERT // Stack delta = +0 // Outputs[1] { @048E revert(memory[0x00:0x00]); } // Block terminates label_048F: // Incoming jump from 0x048A, if !msg.value // Inputs[1] { @0493 storage[0x15] } 048F 5B JUMPDEST 0490 50 POP 0491 60 PUSH1 0x15 0493 54 SLOAD 0494 61 PUSH2 0x028c 0497 90 SWAP1 0498 60 PUSH1 0xff 049A 16 AND 049B 81 DUP2 049C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0497 stack[-1] = 0x028c // @049A stack[0] = 0xff & storage[0x15] // } // Block ends with unconditional jump to 0x028c label_049D: // Incoming jump from 0x017B, if 0x55f804b3 == stack[-1] // Inputs[1] { @049E msg.value } 049D 5B JUMPDEST 049E 34 CALLVALUE 049F 80 DUP1 04A0 15 ISZERO 04A1 61 PUSH2 0x04a9 04A4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @049E stack[0] = msg.value } // Block ends with conditional jump to 0x04a9, if !msg.value label_04A5: // Incoming jump from 0x04A4, if not !msg.value // Inputs[1] { @04A8 memory[0x00:0x00] } 04A5 60 PUSH1 0x00 04A7 80 DUP1 04A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A8 revert(memory[0x00:0x00]); } // Block terminates label_04A9: // Incoming jump from 0x04A4, if !msg.value // Inputs[1] { @04B1 msg.data.length } 04A9 5B JUMPDEST 04AA 50 POP 04AB 61 PUSH2 0x02c1 04AE 61 PUSH2 0x04b8 04B1 36 CALLDATASIZE 04B2 60 PUSH1 0x04 04B4 61 PUSH2 0x237c 04B7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04AB stack[-1] = 0x02c1 // @04AE stack[0] = 0x04b8 // @04B1 stack[1] = msg.data.length // @04B2 stack[2] = 0x04 // } // Block ends with call to 0x237c, returns to 0x04B8 label_04B8: // Incoming return from call to 0x237C at 0x04B7 04B8 5B JUMPDEST 04B9 61 PUSH2 0x0c8a 04BC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c8a label_04BD: // Incoming jump from 0x0186, if 0x5c975abb == stack[-1] // Inputs[1] { @04BE msg.value } 04BD 5B JUMPDEST 04BE 34 CALLVALUE 04BF 80 DUP1 04C0 15 ISZERO 04C1 61 PUSH2 0x04c9 04C4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04BE stack[0] = msg.value } // Block ends with conditional jump to 0x04c9, if !msg.value label_04C5: // Incoming jump from 0x04C4, if not !msg.value // Inputs[1] { @04C8 memory[0x00:0x00] } 04C5 60 PUSH1 0x00 04C7 80 DUP1 04C8 FD *REVERT // Stack delta = +0 // Outputs[1] { @04C8 revert(memory[0x00:0x00]); } // Block terminates label_04C9: // Incoming jump from 0x04C4, if !msg.value // Inputs[1] { @04CD storage[0x0e] } 04C9 5B JUMPDEST 04CA 50 POP 04CB 60 PUSH1 0x0e 04CD 54 SLOAD 04CE 61 PUSH2 0x028c 04D1 90 SWAP1 04D2 60 PUSH1 0xff 04D4 16 AND 04D5 81 DUP2 04D6 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04D1 stack[-1] = 0x028c // @04D4 stack[0] = 0xff & storage[0x0e] // } // Block ends with unconditional jump to 0x028c label_04D7: // Incoming jump from 0x0191, if 0x61e61a25 == stack[-1] // Inputs[1] { @04D8 msg.value } 04D7 5B JUMPDEST 04D8 34 CALLVALUE 04D9 80 DUP1 04DA 15 ISZERO 04DB 61 PUSH2 0x04e3 04DE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D8 stack[0] = msg.value } // Block ends with conditional jump to 0x04e3, if !msg.value label_04DF: // Incoming jump from 0x04DE, if not !msg.value // Inputs[1] { @04E2 memory[0x00:0x00] } 04DF 60 PUSH1 0x00 04E1 80 DUP1 04E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @04E2 revert(memory[0x00:0x00]); } // Block terminates label_04E3: // Incoming jump from 0x04DE, if !msg.value // Inputs[1] { @04E7 storage[0x12] } 04E3 5B JUMPDEST 04E4 50 POP 04E5 60 PUSH1 0x12 04E7 54 SLOAD 04E8 61 PUSH2 0x028c 04EB 90 SWAP1 04EC 60 PUSH1 0xff 04EE 16 AND 04EF 81 DUP2 04F0 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04EB stack[-1] = 0x028c // @04EE stack[0] = 0xff & storage[0x12] // } // Block ends with unconditional jump to 0x028c label_04F1: // Incoming jump from 0x019C, if 0x6352211e == stack[-1] // Inputs[1] { @04F2 msg.value } 04F1 5B JUMPDEST 04F2 34 CALLVALUE 04F3 80 DUP1 04F4 15 ISZERO 04F5 61 PUSH2 0x04fd 04F8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04F2 stack[0] = msg.value } // Block ends with conditional jump to 0x04fd, if !msg.value label_04F9: // Incoming jump from 0x04F8, if not !msg.value // Inputs[1] { @04FC memory[0x00:0x00] } 04F9 60 PUSH1 0x00 04FB 80 DUP1 04FC FD *REVERT // Stack delta = +0 // Outputs[1] { @04FC revert(memory[0x00:0x00]); } // Block terminates label_04FD: // Incoming jump from 0x04F8, if !msg.value // Inputs[1] { @0505 msg.data.length } 04FD 5B JUMPDEST 04FE 50 POP 04FF 61 PUSH2 0x0305 0502 61 PUSH2 0x050c 0505 36 CALLDATASIZE 0506 60 PUSH1 0x04 0508 61 PUSH2 0x232c 050B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04FF stack[-1] = 0x0305 // @0502 stack[0] = 0x050c // @0505 stack[1] = msg.data.length // @0506 stack[2] = 0x04 // } // Block ends with call to 0x232c, returns to 0x050C label_050C: // Incoming return from call to 0x232C at 0x050B 050C 5B JUMPDEST 050D 61 PUSH2 0x0cf7 0510 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cf7 label_0511: // Incoming jump from 0x0113, if 0x66cb24a5 == stack[-1] // Inputs[1] { @0512 msg.value } 0511 5B JUMPDEST 0512 34 CALLVALUE 0513 80 DUP1 0514 15 ISZERO 0515 61 PUSH2 0x051d 0518 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0512 stack[0] = msg.value } // Block ends with conditional jump to 0x051d, if !msg.value label_0519: // Incoming jump from 0x0518, if not !msg.value // Inputs[1] { @051C memory[0x00:0x00] } 0519 60 PUSH1 0x00 051B 80 DUP1 051C FD *REVERT // Stack delta = +0 // Outputs[1] { @051C revert(memory[0x00:0x00]); } // Block terminates label_051D: // Incoming jump from 0x0518, if !msg.value // Inputs[1] { @0525 msg.data.length } 051D 5B JUMPDEST 051E 50 POP 051F 61 PUSH2 0x02c1 0522 61 PUSH2 0x052c 0525 36 CALLDATASIZE 0526 60 PUSH1 0x04 0528 61 PUSH2 0x2312 052B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @051F stack[-1] = 0x02c1 // @0522 stack[0] = 0x052c // @0525 stack[1] = msg.data.length // @0526 stack[2] = 0x04 // } // Block ends with call to 0x2312, returns to 0x052C label_052C: // Incoming return from call to 0x2312 at 0x052B 052C 5B JUMPDEST 052D 61 PUSH2 0x0d09 0530 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d09 label_0531: // Incoming jump from 0x011E, if 0x6f8b44b0 == stack[-1] // Inputs[1] { @0532 msg.value } 0531 5B JUMPDEST 0532 34 CALLVALUE 0533 80 DUP1 0534 15 ISZERO 0535 61 PUSH2 0x053d 0538 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0532 stack[0] = msg.value } // Block ends with conditional jump to 0x053d, if !msg.value label_0539: // Incoming jump from 0x0538, if not !msg.value // Inputs[1] { @053C memory[0x00:0x00] } 0539 60 PUSH1 0x00 053B 80 DUP1 053C FD *REVERT // Stack delta = +0 // Outputs[1] { @053C revert(memory[0x00:0x00]); } // Block terminates label_053D: // Incoming jump from 0x0538, if !msg.value // Inputs[1] { @0545 msg.data.length } 053D 5B JUMPDEST 053E 50 POP 053F 61 PUSH2 0x02c1 0542 61 PUSH2 0x054c 0545 36 CALLDATASIZE 0546 60 PUSH1 0x04 0548 61 PUSH2 0x232c 054B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @053F stack[-1] = 0x02c1 // @0542 stack[0] = 0x054c // @0545 stack[1] = msg.data.length // @0546 stack[2] = 0x04 // } // Block ends with call to 0x232c, returns to 0x054C label_054C: // Incoming return from call to 0x232C at 0x054B 054C 5B JUMPDEST 054D 61 PUSH2 0x0d74 0550 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d74 label_0551: // Incoming jump from 0x0129, if 0x70a08231 == stack[-1] // Inputs[1] { @0552 msg.value } 0551 5B JUMPDEST 0552 34 CALLVALUE 0553 80 DUP1 0554 15 ISZERO 0555 61 PUSH2 0x055d 0558 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0552 stack[0] = msg.value } // Block ends with conditional jump to 0x055d, if !msg.value label_0559: // Incoming jump from 0x0558, if not !msg.value // Inputs[1] { @055C memory[0x00:0x00] } 0559 60 PUSH1 0x00 055B 80 DUP1 055C FD *REVERT // Stack delta = +0 // Outputs[1] { @055C revert(memory[0x00:0x00]); } // Block terminates label_055D: // Incoming jump from 0x0558, if !msg.value // Inputs[1] { @0565 msg.data.length } 055D 5B JUMPDEST 055E 50 POP 055F 61 PUSH2 0x0388 0562 61 PUSH2 0x056c 0565 36 CALLDATASIZE 0566 60 PUSH1 0x04 0568 61 PUSH2 0x214c 056B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @055F stack[-1] = 0x0388 // @0562 stack[0] = 0x056c // @0565 stack[1] = msg.data.length // @0566 stack[2] = 0x04 // } // Block ends with call to 0x214c, returns to 0x056C label_056C: // Incoming return from call to 0x214C at 0x056B 056C 5B JUMPDEST 056D 61 PUSH2 0x0dd3 0570 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dd3 label_0571: // Incoming jump from 0x0134, if 0x715018a6 == stack[-1] // Inputs[1] { @0572 msg.value } 0571 5B JUMPDEST 0572 34 CALLVALUE 0573 80 DUP1 0574 15 ISZERO 0575 61 PUSH2 0x057d 0578 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0572 stack[0] = msg.value } // Block ends with conditional jump to 0x057d, if !msg.value label_0579: // Incoming jump from 0x0578, if not !msg.value // Inputs[1] { @057C memory[0x00:0x00] } 0579 60 PUSH1 0x00 057B 80 DUP1 057C FD *REVERT // Stack delta = +0 // Outputs[1] { @057C revert(memory[0x00:0x00]); } // Block terminates label_057D: // Incoming jump from 0x0578, if !msg.value 057D 5B JUMPDEST 057E 50 POP 057F 61 PUSH2 0x02c1 0582 61 PUSH2 0x0e21 0585 56 *JUMP // Stack delta = +0 // Outputs[1] { @057F stack[-1] = 0x02c1 } // Block ends with call to 0x0e21, returns to 0x02C1 label_0586: // Incoming jump from 0x013F, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0587 msg.value } 0586 5B JUMPDEST 0587 34 CALLVALUE 0588 80 DUP1 0589 15 ISZERO 058A 61 PUSH2 0x0592 058D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0587 stack[0] = msg.value } // Block ends with conditional jump to 0x0592, if !msg.value label_058E: // Incoming jump from 0x058D, if not !msg.value // Inputs[1] { @0591 memory[0x00:0x00] } 058E 60 PUSH1 0x00 0590 80 DUP1 0591 FD *REVERT // Stack delta = +0 // Outputs[1] { @0591 revert(memory[0x00:0x00]); } // Block terminates label_0592: // Incoming jump from 0x058D, if !msg.value // Inputs[1] { @0596 storage[0x08] } 0592 5B JUMPDEST 0593 50 POP 0594 60 PUSH1 0x08 0596 54 SLOAD 0597 60 PUSH1 0x01 0599 60 PUSH1 0x01 059B 60 PUSH1 0xa0 059D 1B SHL 059E 03 SUB 059F 16 AND 05A0 61 PUSH2 0x0305 05A3 56 *JUMP // Stack delta = +0 // Outputs[1] { @059F stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x08] } // Block ends with unconditional jump to 0x0305 label_05A4: // Incoming jump from 0x00CC, if 0x940cd05b == stack[-1] // Inputs[1] { @05A5 msg.value } 05A4 5B JUMPDEST 05A5 34 CALLVALUE 05A6 80 DUP1 05A7 15 ISZERO 05A8 61 PUSH2 0x05b0 05AB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05A5 stack[0] = msg.value } // Block ends with conditional jump to 0x05b0, if !msg.value label_05AC: // Incoming jump from 0x05AB, if not !msg.value // Inputs[1] { @05AF memory[0x00:0x00] } 05AC 60 PUSH1 0x00 05AE 80 DUP1 05AF FD *REVERT // Stack delta = +0 // Outputs[1] { @05AF revert(memory[0x00:0x00]); } // Block terminates label_05B0: // Incoming jump from 0x05AB, if !msg.value // Inputs[1] { @05B8 msg.data.length } 05B0 5B JUMPDEST 05B1 50 POP 05B2 61 PUSH2 0x02c1 05B5 61 PUSH2 0x05bf 05B8 36 CALLDATASIZE 05B9 60 PUSH1 0x04 05BB 61 PUSH2 0x2312 05BE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05B2 stack[-1] = 0x02c1 // @05B5 stack[0] = 0x05bf // @05B8 stack[1] = msg.data.length // @05B9 stack[2] = 0x04 // } // Block ends with call to 0x2312, returns to 0x05BF label_05BF: // Incoming return from call to 0x2312 at 0x05BE 05BF 5B JUMPDEST 05C0 61 PUSH2 0x0e57 05C3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e57 label_05C4: // Incoming jump from 0x00D7, if 0x95d89b41 == stack[-1] // Inputs[1] { @05C5 msg.value } 05C4 5B JUMPDEST 05C5 34 CALLVALUE 05C6 80 DUP1 05C7 15 ISZERO 05C8 61 PUSH2 0x05d0 05CB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05C5 stack[0] = msg.value } // Block ends with conditional jump to 0x05d0, if !msg.value label_05CC: // Incoming jump from 0x05CB, if not !msg.value // Inputs[1] { @05CF memory[0x00:0x00] } 05CC 60 PUSH1 0x00 05CE 80 DUP1 05CF FD *REVERT // Stack delta = +0 // Outputs[1] { @05CF revert(memory[0x00:0x00]); } // Block terminates label_05D0: // Incoming jump from 0x05CB, if !msg.value 05D0 5B JUMPDEST 05D1 50 POP 05D2 61 PUSH2 0x02d8 05D5 61 PUSH2 0x0ec2 05D8 56 *JUMP // Stack delta = +0 // Outputs[1] { @05D2 stack[-1] = 0x02d8 } // Block ends with call to 0x0ec2, returns to 0x02D8 label_05D9: // Incoming jump from 0x00E2, if 0xa0712d68 == stack[-1] // Inputs[1] { @05E0 msg.data.length } 05D9 5B JUMPDEST 05DA 61 PUSH2 0x02c1 05DD 61 PUSH2 0x05e7 05E0 36 CALLDATASIZE 05E1 60 PUSH1 0x04 05E3 61 PUSH2 0x232c 05E6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05DA stack[0] = 0x02c1 // @05DD stack[1] = 0x05e7 // @05E0 stack[2] = msg.data.length // @05E1 stack[3] = 0x04 // } // Block ends with call to 0x232c, returns to 0x05E7 label_05E7: // Incoming return from call to 0x232C at 0x05E6 05E7 5B JUMPDEST 05E8 61 PUSH2 0x0ed1 05EB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ed1 label_05EC: // Incoming jump from 0x00ED, if 0xa22cb465 == stack[-1] // Inputs[1] { @05ED msg.value } 05EC 5B JUMPDEST 05ED 34 CALLVALUE 05EE 80 DUP1 05EF 15 ISZERO 05F0 61 PUSH2 0x05f8 05F3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05ED stack[0] = msg.value } // Block ends with conditional jump to 0x05f8, if !msg.value label_05F4: // Incoming jump from 0x05F3, if not !msg.value // Inputs[1] { @05F7 memory[0x00:0x00] } 05F4 60 PUSH1 0x00 05F6 80 DUP1 05F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @05F7 revert(memory[0x00:0x00]); } // Block terminates label_05F8: // Incoming jump from 0x05F3, if !msg.value // Inputs[1] { @0600 msg.data.length } 05F8 5B JUMPDEST 05F9 50 POP 05FA 61 PUSH2 0x02c1 05FD 61 PUSH2 0x0607 0600 36 CALLDATASIZE 0601 60 PUSH1 0x04 0603 61 PUSH2 0x224b 0606 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05FA stack[-1] = 0x02c1 // @05FD stack[0] = 0x0607 // @0600 stack[1] = msg.data.length // @0601 stack[2] = 0x04 // } // Block ends with call to 0x224b, returns to 0x0607 label_0607: // Incoming return from call to 0x224B at 0x0606 0607 5B JUMPDEST 0608 61 PUSH2 0x1032 060B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1032 label_060C: // Incoming jump from 0x00F8, if 0xa6d612f9 == stack[-1] // Inputs[1] { @0613 msg.data.length } 060C 5B JUMPDEST 060D 61 PUSH2 0x02c1 0610 61 PUSH2 0x061a 0613 36 CALLDATASIZE 0614 60 PUSH1 0x04 0616 61 PUSH2 0x229d 0619 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @060D stack[0] = 0x02c1 // @0610 stack[1] = 0x061a // @0613 stack[2] = msg.data.length // @0614 stack[3] = 0x04 // } // Block ends with call to 0x229d, returns to 0x061A label_061A: // Incoming return from call to 0x229D at 0x0619 061A 5B JUMPDEST 061B 61 PUSH2 0x10c8 061E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10c8 label_061F: // Incoming jump from 0x0103, if 0xb88d4fde == stack[-1] // Inputs[1] { @0620 msg.value } 061F 5B JUMPDEST 0620 34 CALLVALUE 0621 80 DUP1 0622 15 ISZERO 0623 61 PUSH2 0x062b 0626 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0620 stack[0] = msg.value } // Block ends with conditional jump to 0x062b, if !msg.value label_0627: // Incoming jump from 0x0626, if not !msg.value // Inputs[1] { @062A memory[0x00:0x00] } 0627 60 PUSH1 0x00 0629 80 DUP1 062A FD *REVERT // Stack delta = +0 // Outputs[1] { @062A revert(memory[0x00:0x00]); } // Block terminates label_062B: // Incoming jump from 0x0626, if !msg.value // Inputs[1] { @0633 msg.data.length } 062B 5B JUMPDEST 062C 50 POP 062D 61 PUSH2 0x02c1 0630 61 PUSH2 0x063a 0633 36 CALLDATASIZE 0634 60 PUSH1 0x04 0636 61 PUSH2 0x21d3 0639 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @062D stack[-1] = 0x02c1 // @0630 stack[0] = 0x063a // @0633 stack[1] = msg.data.length // @0634 stack[2] = 0x04 // } // Block ends with call to 0x21d3, returns to 0x063A label_063A: // Incoming return from call to 0x21D3 at 0x0639 063A 5B JUMPDEST 063B 61 PUSH2 0x1388 063E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1388 label_063F: // Incoming jump from 0x0085, if 0xc6682862 == stack[-1] // Inputs[1] { @0640 msg.value } 063F 5B JUMPDEST 0640 34 CALLVALUE 0641 80 DUP1 0642 15 ISZERO 0643 61 PUSH2 0x064b 0646 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0640 stack[0] = msg.value } // Block ends with conditional jump to 0x064b, if !msg.value label_0647: // Incoming jump from 0x0646, if not !msg.value // Inputs[1] { @064A memory[0x00:0x00] } 0647 60 PUSH1 0x00 0649 80 DUP1 064A FD *REVERT // Stack delta = +0 // Outputs[1] { @064A revert(memory[0x00:0x00]); } // Block terminates label_064B: // Incoming jump from 0x0646, if !msg.value 064B 5B JUMPDEST 064C 50 POP 064D 61 PUSH2 0x02d8 0650 61 PUSH2 0x13d9 0653 56 *JUMP // Stack delta = +0 // Outputs[1] { @064D stack[-1] = 0x02d8 } // Block ends with call to 0x13d9, returns to 0x02D8 label_0654: // Incoming jump from 0x0090, if 0xc87b56dd == stack[-1] // Inputs[1] { @0655 msg.value } 0654 5B JUMPDEST 0655 34 CALLVALUE 0656 80 DUP1 0657 15 ISZERO 0658 61 PUSH2 0x0660 065B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0655 stack[0] = msg.value } // Block ends with conditional jump to 0x0660, if !msg.value label_065C: // Incoming jump from 0x065B, if not !msg.value // Inputs[1] { @065F memory[0x00:0x00] } 065C 60 PUSH1 0x00 065E 80 DUP1 065F FD *REVERT // Stack delta = +0 // Outputs[1] { @065F revert(memory[0x00:0x00]); } // Block terminates label_0660: // Incoming jump from 0x065B, if !msg.value // Inputs[1] { @0668 msg.data.length } 0660 5B JUMPDEST 0661 50 POP 0662 61 PUSH2 0x02d8 0665 61 PUSH2 0x066f 0668 36 CALLDATASIZE 0669 60 PUSH1 0x04 066B 61 PUSH2 0x232c 066E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0662 stack[-1] = 0x02d8 // @0665 stack[0] = 0x066f // @0668 stack[1] = msg.data.length // @0669 stack[2] = 0x04 // } // Block ends with call to 0x232c, returns to 0x066F label_066F: // Incoming return from call to 0x232C at 0x066E 066F 5B JUMPDEST 0670 61 PUSH2 0x13e6 0673 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x13e6 label_0674: // Incoming jump from 0x009B, if 0xd49479eb == stack[-1] // Inputs[1] { @0675 msg.value } 0674 5B JUMPDEST 0675 34 CALLVALUE 0676 80 DUP1 0677 15 ISZERO 0678 61 PUSH2 0x0680 067B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0675 stack[0] = msg.value } // Block ends with conditional jump to 0x0680, if !msg.value label_067C: // Incoming jump from 0x067B, if not !msg.value // Inputs[1] { @067F memory[0x00:0x00] } 067C 60 PUSH1 0x00 067E 80 DUP1 067F FD *REVERT // Stack delta = +0 // Outputs[1] { @067F revert(memory[0x00:0x00]); } // Block terminates label_0680: // Incoming jump from 0x067B, if !msg.value // Inputs[1] { @0688 msg.data.length } 0680 5B JUMPDEST 0681 50 POP 0682 61 PUSH2 0x02c1 0685 61 PUSH2 0x068f 0688 36 CALLDATASIZE 0689 60 PUSH1 0x04 068B 61 PUSH2 0x232c 068E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0682 stack[-1] = 0x02c1 // @0685 stack[0] = 0x068f // @0688 stack[1] = msg.data.length // @0689 stack[2] = 0x04 // } // Block ends with call to 0x232c, returns to 0x068F label_068F: // Incoming return from call to 0x232C at 0x068E 068F 5B JUMPDEST 0690 61 PUSH2 0x1550 0693 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1550 label_0694: // Incoming jump from 0x00A6, if 0xd5abeb01 == stack[-1] // Inputs[1] { @0695 msg.value } 0694 5B JUMPDEST 0695 34 CALLVALUE 0696 80 DUP1 0697 15 ISZERO 0698 61 PUSH2 0x06a0 069B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0695 stack[0] = msg.value } // Block ends with conditional jump to 0x06a0, if !msg.value label_069C: // Incoming jump from 0x069B, if not !msg.value // Inputs[1] { @069F memory[0x00:0x00] } 069C 60 PUSH1 0x00 069E 80 DUP1 069F FD *REVERT // Stack delta = +0 // Outputs[1] { @069F revert(memory[0x00:0x00]); } // Block terminates label_06A0: // Incoming jump from 0x069B, if !msg.value // Inputs[1] { @06A7 storage[0x0f] } 06A0 5B JUMPDEST 06A1 50 POP 06A2 61 PUSH2 0x0388 06A5 60 PUSH1 0x0f 06A7 54 SLOAD 06A8 81 DUP2 06A9 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @06A2 stack[-1] = 0x0388 // @06A7 stack[0] = storage[0x0f] // } // Block ends with unconditional jump to 0x0388 label_06AA: // Incoming jump from 0x00B1, if 0xda3ef23f == stack[-1] // Inputs[1] { @06AB msg.value } 06AA 5B JUMPDEST 06AB 34 CALLVALUE 06AC 80 DUP1 06AD 15 ISZERO 06AE 61 PUSH2 0x06b6 06B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06AB stack[0] = msg.value } // Block ends with conditional jump to 0x06b6, if !msg.value label_06B2: // Incoming jump from 0x06B1, if not !msg.value // Inputs[1] { @06B5 memory[0x00:0x00] } 06B2 60 PUSH1 0x00 06B4 80 DUP1 06B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @06B5 revert(memory[0x00:0x00]); } // Block terminates label_06B6: // Incoming jump from 0x06B1, if !msg.value // Inputs[1] { @06BE msg.data.length } 06B6 5B JUMPDEST 06B7 50 POP 06B8 61 PUSH2 0x02c1 06BB 61 PUSH2 0x06c5 06BE 36 CALLDATASIZE 06BF 60 PUSH1 0x04 06C1 61 PUSH2 0x237c 06C4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06B8 stack[-1] = 0x02c1 // @06BB stack[0] = 0x06c5 // @06BE stack[1] = msg.data.length // @06BF stack[2] = 0x04 // } // Block ends with call to 0x237c, returns to 0x06C5 label_06C5: // Incoming return from call to 0x237C at 0x06C4 06C5 5B JUMPDEST 06C6 61 PUSH2 0x15af 06C9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x15af label_06CA: // Incoming jump from 0x003E, if 0xdb4bec44 == stack[-1] // Inputs[1] { @06CB msg.value } 06CA 5B JUMPDEST 06CB 34 CALLVALUE 06CC 80 DUP1 06CD 15 ISZERO 06CE 61 PUSH2 0x06d6 06D1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06CB stack[0] = msg.value } // Block ends with conditional jump to 0x06d6, if !msg.value label_06D2: // Incoming jump from 0x06D1, if not !msg.value // Inputs[1] { @06D5 memory[0x00:0x00] } 06D2 60 PUSH1 0x00 06D4 80 DUP1 06D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @06D5 revert(memory[0x00:0x00]); } // Block terminates label_06D6: // Incoming jump from 0x06D1, if !msg.value // Inputs[1] { @06DE msg.data.length } 06D6 5B JUMPDEST 06D7 50 POP 06D8 61 PUSH2 0x028c 06DB 61 PUSH2 0x06e5 06DE 36 CALLDATASIZE 06DF 60 PUSH1 0x04 06E1 61 PUSH2 0x214c 06E4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06D8 stack[-1] = 0x028c // @06DB stack[0] = 0x06e5 // @06DE stack[1] = msg.data.length // @06DF stack[2] = 0x04 // } // Block ends with call to 0x214c, returns to 0x06E5 label_06E5: // Incoming return from call to 0x214C at 0x06E4 // Inputs[4] // { // @06ED stack[-1] // @06F3 memory[0x00:0x40] // @06F4 storage[keccak256(memory[0x00:0x40])] // @06F8 stack[-2] // } 06E5 5B JUMPDEST 06E6 60 PUSH1 0x14 06E8 60 PUSH1 0x20 06EA 52 MSTORE 06EB 60 PUSH1 0x00 06ED 90 SWAP1 06EE 81 DUP2 06EF 52 MSTORE 06F0 60 PUSH1 0x40 06F2 90 SWAP1 06F3 20 SHA3 06F4 54 SLOAD 06F5 60 PUSH1 0xff 06F7 16 AND 06F8 81 DUP2 06F9 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @06EA memory[0x20:0x40] = 0x14 // @06EF memory[0x00:0x20] = stack[-1] // @06F7 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_06FA: // Incoming jump from 0x0049, if 0xe7b99ec7 == stack[-1] // Inputs[1] { @06FB msg.value } 06FA 5B JUMPDEST 06FB 34 CALLVALUE 06FC 80 DUP1 06FD 15 ISZERO 06FE 61 PUSH2 0x0706 0701 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06FB stack[0] = msg.value } // Block ends with conditional jump to 0x0706, if !msg.value label_0702: // Incoming jump from 0x0701, if not !msg.value // Inputs[1] { @0705 memory[0x00:0x00] } 0702 60 PUSH1 0x00 0704 80 DUP1 0705 FD *REVERT // Stack delta = +0 // Outputs[1] { @0705 revert(memory[0x00:0x00]); } // Block terminates label_0706: // Incoming jump from 0x0701, if !msg.value // Inputs[1] { @070D storage[0x11] } 0706 5B JUMPDEST 0707 50 POP 0708 61 PUSH2 0x0388 070B 60 PUSH1 0x11 070D 54 SLOAD 070E 81 DUP2 070F 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0708 stack[-1] = 0x0388 // @070D stack[0] = storage[0x11] // } // Block ends with unconditional jump to 0x0388 label_0710: // Incoming jump from 0x0054, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0711 msg.value } 0710 5B JUMPDEST 0711 34 CALLVALUE 0712 80 DUP1 0713 15 ISZERO 0714 61 PUSH2 0x071c 0717 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0711 stack[0] = msg.value } // Block ends with conditional jump to 0x071c, if !msg.value label_0718: // Incoming jump from 0x0717, if not !msg.value // Inputs[1] { @071B memory[0x00:0x00] } 0718 60 PUSH1 0x00 071A 80 DUP1 071B FD *REVERT // Stack delta = +0 // Outputs[1] { @071B revert(memory[0x00:0x00]); } // Block terminates label_071C: // Incoming jump from 0x0717, if !msg.value // Inputs[1] { @0724 msg.data.length } 071C 5B JUMPDEST 071D 50 POP 071E 61 PUSH2 0x028c 0721 61 PUSH2 0x072b 0724 36 CALLDATASIZE 0725 60 PUSH1 0x04 0727 61 PUSH2 0x2166 072A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @071E stack[-1] = 0x028c // @0721 stack[0] = 0x072b // @0724 stack[1] = msg.data.length // @0725 stack[2] = 0x04 // } // Block ends with call to 0x2166, returns to 0x072B label_072B: // Incoming call from 0x0AA6, returns to 0x0AA7 // Incoming return from call to 0x2166 at 0x072A // Incoming call from 0x1869, returns to 0x186A // Inputs[6] // { // @0734 stack[-2] // @0747 memory[0x00:0x40] // @0748 stack[-1] // @0752 memory[0x00:0x40] // @0753 storage[keccak256(memory[0x00:0x40])] // @0757 stack[-3] // } 072B 5B JUMPDEST 072C 60 PUSH1 0x01 072E 60 PUSH1 0x01 0730 60 PUSH1 0xa0 0732 1B SHL 0733 03 SUB 0734 91 SWAP2 0735 82 DUP3 0736 16 AND 0737 60 PUSH1 0x00 0739 90 SWAP1 073A 81 DUP2 073B 52 MSTORE 073C 60 PUSH1 0x07 073E 60 PUSH1 0x20 0740 90 SWAP1 0741 81 DUP2 0742 52 MSTORE 0743 60 PUSH1 0x40 0745 80 DUP1 0746 83 DUP4 0747 20 SHA3 0748 93 SWAP4 0749 90 SWAP1 074A 94 SWAP5 074B 16 AND 074C 82 DUP3 074D 52 MSTORE 074E 91 SWAP2 074F 90 SWAP1 0750 91 SWAP2 0751 52 MSTORE 0752 20 SHA3 0753 54 SLOAD 0754 60 PUSH1 0xff 0756 16 AND 0757 90 SWAP1 0758 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @073B memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0742 memory[0x20:0x40] = 0x07 // @074D memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0751 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0757 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0759: // Incoming jump from 0x005F, if 0xf2c4ce1e == stack[-1] // Inputs[1] { @075A msg.value } 0759 5B JUMPDEST 075A 34 CALLVALUE 075B 80 DUP1 075C 15 ISZERO 075D 61 PUSH2 0x0765 0760 57 *JUMPI // Stack delta = +1 // Outputs[1] { @075A stack[0] = msg.value } // Block ends with conditional jump to 0x0765, if !msg.value label_0761: // Incoming jump from 0x0760, if not !msg.value // Inputs[1] { @0764 memory[0x00:0x00] } 0761 60 PUSH1 0x00 0763 80 DUP1 0764 FD *REVERT // Stack delta = +0 // Outputs[1] { @0764 revert(memory[0x00:0x00]); } // Block terminates label_0765: // Incoming jump from 0x0760, if !msg.value // Inputs[1] { @076D msg.data.length } 0765 5B JUMPDEST 0766 50 POP 0767 61 PUSH2 0x02c1 076A 61 PUSH2 0x0774 076D 36 CALLDATASIZE 076E 60 PUSH1 0x04 0770 61 PUSH2 0x237c 0773 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0767 stack[-1] = 0x02c1 // @076A stack[0] = 0x0774 // @076D stack[1] = msg.data.length // @076E stack[2] = 0x04 // } // Block ends with call to 0x237c, returns to 0x0774 label_0774: // Incoming return from call to 0x237C at 0x0773 0774 5B JUMPDEST 0775 61 PUSH2 0x161c 0778 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x161c label_0779: // Incoming jump from 0x006A, if 0xf2fde38b == stack[-1] // Inputs[1] { @077A msg.value } 0779 5B JUMPDEST 077A 34 CALLVALUE 077B 80 DUP1 077C 15 ISZERO 077D 61 PUSH2 0x0785 0780 57 *JUMPI // Stack delta = +1 // Outputs[1] { @077A stack[0] = msg.value } // Block ends with conditional jump to 0x0785, if !msg.value label_0781: // Incoming jump from 0x0780, if not !msg.value // Inputs[1] { @0784 memory[0x00:0x00] } 0781 60 PUSH1 0x00 0783 80 DUP1 0784 FD *REVERT // Stack delta = +0 // Outputs[1] { @0784 revert(memory[0x00:0x00]); } // Block terminates label_0785: // Incoming jump from 0x0780, if !msg.value // Inputs[1] { @078D msg.data.length } 0785 5B JUMPDEST 0786 50 POP 0787 61 PUSH2 0x02c1 078A 61 PUSH2 0x0794 078D 36 CALLDATASIZE 078E 60 PUSH1 0x04 0790 61 PUSH2 0x214c 0793 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0787 stack[-1] = 0x02c1 // @078A stack[0] = 0x0794 // @078D stack[1] = msg.data.length // @078E stack[2] = 0x04 // } // Block ends with call to 0x214c, returns to 0x0794 label_0794: // Incoming return from call to 0x214C at 0x0793 0794 5B JUMPDEST 0795 61 PUSH2 0x1689 0798 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1689 label_0799: // Incoming jump from 0x0075, if 0xf5aa406d == stack[-1] // Inputs[1] { @079A msg.value } 0799 5B JUMPDEST 079A 34 CALLVALUE 079B 80 DUP1 079C 15 ISZERO 079D 61 PUSH2 0x07a5 07A0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @079A stack[0] = msg.value } // Block ends with conditional jump to 0x07a5, if !msg.value label_07A1: // Incoming jump from 0x07A0, if not !msg.value // Inputs[1] { @07A4 memory[0x00:0x00] } 07A1 60 PUSH1 0x00 07A3 80 DUP1 07A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @07A4 revert(memory[0x00:0x00]); } // Block terminates label_07A5: // Incoming jump from 0x07A0, if !msg.value // Inputs[1] { @07AD msg.data.length } 07A5 5B JUMPDEST 07A6 50 POP 07A7 61 PUSH2 0x02c1 07AA 61 PUSH2 0x07b4 07AD 36 CALLDATASIZE 07AE 60 PUSH1 0x04 07B0 61 PUSH2 0x232c 07B3 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @07A7 stack[-1] = 0x02c1 // @07AA stack[0] = 0x07b4 // @07AD stack[1] = msg.data.length // @07AE stack[2] = 0x04 // } // Block ends with call to 0x232c, returns to 0x07B4 label_07B4: // Incoming return from call to 0x232C at 0x07B3 07B4 5B JUMPDEST 07B5 61 PUSH2 0x1724 07B8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1724 label_07B9: // Incoming jump from 0x028B // Inputs[1] { @07C5 stack[-1] } 07B9 5B JUMPDEST 07BA 60 PUSH1 0x00 07BC 60 PUSH1 0x01 07BE 60 PUSH1 0x01 07C0 60 PUSH1 0xe0 07C2 1B SHL 07C3 03 SUB 07C4 19 NOT 07C5 82 DUP3 07C6 16 AND 07C7 63 PUSH4 0x80ac58cd 07CC 60 PUSH1 0xe0 07CE 1B SHL 07CF 14 EQ 07D0 80 DUP1 07D1 61 PUSH2 0x07ea 07D4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @07BA stack[0] = 0x00 // @07CF stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x07ea, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_07D5: // Incoming jump from 0x07D4, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @07DF stack[-3] } 07D5 50 POP 07D6 60 PUSH1 0x01 07D8 60 PUSH1 0x01 07DA 60 PUSH1 0xe0 07DC 1B SHL 07DD 03 SUB 07DE 19 NOT 07DF 82 DUP3 07E0 16 AND 07E1 63 PUSH4 0x5b5e139f 07E6 60 PUSH1 0xe0 07E8 1B SHL 07E9 14 EQ 07EA 5B JUMPDEST 07EB 80 DUP1 07EC 61 PUSH2 0x0805 07EF 57 *JUMPI // Stack delta = +0 // Outputs[1] { @07E9 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0805, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_07F0: // Incoming jump from 0x07EF, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x07EF, if not stack[-1] // Inputs[1] { @0802 stack[-3] } 07F0 50 POP 07F1 63 PUSH4 0x01ffc9a7 07F6 60 PUSH1 0xe0 07F8 1B SHL 07F9 60 PUSH1 0x01 07FB 60 PUSH1 0x01 07FD 60 PUSH1 0xe0 07FF 1B SHL 0800 03 SUB 0801 19 NOT 0802 83 DUP4 0803 16 AND 0804 14 EQ // Stack delta = +0 // Outputs[1] { @0804 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block continues label_0805: // Incoming jump from 0x178F, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x0804 // Incoming jump from 0x07EF, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x07EF, if stack[-1] // Inputs[3] // { // @0806 stack[-1] // @0806 stack[-4] // @0807 stack[-3] // } 0805 5B JUMPDEST 0806 92 SWAP3 0807 91 SWAP2 0808 50 POP 0809 50 POP 080A 56 *JUMP // Stack delta = -3 // Outputs[1] { @0806 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_080B: // Incoming jump from 0x02C0 // Inputs[2] // { // @080E storage[0x08] // @0818 msg.sender // } 080B 5B JUMPDEST 080C 60 PUSH1 0x08 080E 54 SLOAD 080F 60 PUSH1 0x01 0811 60 PUSH1 0x01 0813 60 PUSH1 0xa0 0815 1B SHL 0816 03 SUB 0817 16 AND 0818 33 CALLER 0819 14 EQ 081A 61 PUSH2 0x083e 081D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x083e, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_081E: // Incoming jump from 0x081D, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0820 memory[0x40:0x60] } 081E 60 PUSH1 0x40 0820 51 MLOAD 0821 62 PUSH3 0x461bcd 0825 60 PUSH1 0xe5 0827 1B SHL 0828 81 DUP2 0829 52 MSTORE 082A 60 PUSH1 0x04 082C 01 ADD 082D 61 PUSH2 0x0835 0830 90 SWAP1 0831 61 PUSH2 0x2540 0834 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0829 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0830 stack[0] = 0x0835 // @0830 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2540, returns to 0x0835 label_0835: // Incoming return from call to 0x2540 at 0x0D9D // Incoming return from call to 0x2540 at 0x0B83 // Incoming return from call to 0x2540 at 0x1645 // Incoming return from call to 0x2540 at 0x1579 // Incoming return from call to 0x2540 at 0x0A13 // Incoming return from call to 0x2540 at 0x0B00 // Incoming jump from 0x1251 // Incoming jump from 0x0F23 // Incoming return from call to 0x2540 at 0x0CB3 // Incoming jump from 0x1128 // Incoming return from call to 0x2540 at 0x15D8 // Incoming jump from 0x1307 // Incoming jump from 0x11CA // Incoming return from call to 0x2540 at 0x0E4A // Incoming jump from 0x0FDD // Incoming return from call to 0x2540 at 0x174D // Incoming jump from 0x1454 // Incoming return from call to 0x2540 at 0x16B2 // Incoming return from call to 0x2540 at 0x0834 // Incoming return from call to 0x2540 at 0x0D32 // Incoming jump from 0x1717 // Incoming return from call to 0x2540 at 0x0E80 // Incoming return from call to 0x2540 at 0x0C54 // Inputs[3] // { // @0838 memory[0x40:0x60] // @083A stack[-1] // @083D memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0835 5B JUMPDEST 0836 60 PUSH1 0x40 0838 51 MLOAD 0839 80 DUP1 083A 91 SWAP2 083B 03 SUB 083C 90 SWAP1 083D FD *REVERT // Stack delta = -1 // Outputs[1] { @083D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_083E: // Incoming jump from 0x081D, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0842 storage[0x0e] // @0847 stack[-1] // @0852 memory[0x40:0x60] // } 083E 5B JUMPDEST 083F 60 PUSH1 0x0e 0841 80 DUP1 0842 54 SLOAD 0843 60 PUSH1 0xff 0845 19 NOT 0846 16 AND 0847 82 DUP3 0848 15 ISZERO 0849 15 ISZERO 084A 90 SWAP1 084B 81 DUP2 084C 17 OR 084D 90 SWAP1 084E 91 SWAP2 084F 55 SSTORE 0850 60 PUSH1 0x40 0852 51 MLOAD 0853 90 SWAP1 0854 81 DUP2 0855 52 MSTORE 0856 7F PUSH32 0x67f4224f6117d25310ef3a7c494aef25faf1a438799b4218af7abebb19acdb14 0877 90 SWAP1 0878 60 PUSH1 0x20 087A 01 ADD // Stack delta = +2 // Outputs[4] // { // @084F storage[0x0e] = !!stack[-1] | (~0xff & storage[0x0e]) // @0855 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0877 stack[0] = 0x67f4224f6117d25310ef3a7c494aef25faf1a438799b4218af7abebb19acdb14 // @087A stack[1] = 0x20 + memory[0x40:0x60] // } // Block continues label_087B: // Incoming jump from 0x0C89 // Incoming jump from 0x087A // Incoming jump from 0x0B4E // Incoming jump from 0x0DD2 // Incoming jump from 0x0EC1 // Incoming jump from 0x1782 // Incoming jump from 0x1031 // Incoming jump from 0x15AE // Incoming jump from 0x0A48 // Incoming jump from 0x0D73 // Inputs[5] // { // @087E memory[0x40:0x60] // @0880 stack[-1] // @0883 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0883 stack[-2] // @0885 stack[-4] // } 087B 5B JUMPDEST 087C 60 PUSH1 0x40 087E 51 MLOAD 087F 80 DUP1 0880 91 SWAP2 0881 03 SUB 0882 90 SWAP1 0883 A1 LOG1 0884 50 POP 0885 56 *JUMP // Stack delta = -4 // Outputs[1] { @0883 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2]]); } // Block ends with unconditional jump to stack[-4] label_0886: // Incoming call from 0x02D7, returns to 0x02D8 // Inputs[1] { @088C storage[0x02] } 0886 5B JUMPDEST 0887 60 PUSH1 0x60 0889 60 PUSH1 0x02 088B 80 DUP1 088C 54 SLOAD 088D 61 PUSH2 0x0895 0890 90 SWAP1 0891 61 PUSH2 0x2603 0894 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0887 stack[0] = 0x60 // @0889 stack[1] = 0x02 // @0890 stack[2] = 0x0895 // @0890 stack[3] = storage[0x02] // } // Block ends with call to 0x2603, returns to 0x0895 label_0895: // Incoming return from call to 0x2603 at 0x0ED0 // Incoming return from call to 0x2603 at 0x1C9E // Incoming return from call to 0x2603 at 0x0894 // Inputs[4] // { // @0896 stack[-1] // @08A5 memory[0x40:0x60] // @08AD stack[-2] // @08B8 storage[stack[-2]] // } 0895 5B JUMPDEST 0896 80 DUP1 0897 60 PUSH1 0x1f 0899 01 ADD 089A 60 PUSH1 0x20 089C 80 DUP1 089D 91 SWAP2 089E 04 DIV 089F 02 MUL 08A0 60 PUSH1 0x20 08A2 01 ADD 08A3 60 PUSH1 0x40 08A5 51 MLOAD 08A6 90 SWAP1 08A7 81 DUP2 08A8 01 ADD 08A9 60 PUSH1 0x40 08AB 52 MSTORE 08AC 80 DUP1 08AD 92 SWAP3 08AE 91 SWAP2 08AF 90 SWAP1 08B0 81 DUP2 08B1 81 DUP2 08B2 52 MSTORE 08B3 60 PUSH1 0x20 08B5 01 ADD 08B6 82 DUP3 08B7 80 DUP1 08B8 54 SLOAD 08B9 61 PUSH2 0x08c1 08BC 90 SWAP1 08BD 61 PUSH2 0x2603 08C0 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @08AB memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @08AD stack[-2] = memory[0x40:0x60] // @08AE stack[-1] = stack[-2] // @08AF stack[0] = stack[-1] // @08B2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @08B5 stack[1] = 0x20 + memory[0x40:0x60] // @08B6 stack[2] = stack[-2] // @08BC stack[4] = storage[stack[-2]] // @08BC stack[3] = 0x08c1 // } // Block ends with call to 0x2603, returns to 0x08C1 label_08C1: // Incoming return from call to 0x2603 at 0x08C0 // Inputs[1] { @08C2 stack[-1] } 08C1 5B JUMPDEST 08C2 80 DUP1 08C3 15 ISZERO 08C4 61 PUSH2 0x090e 08C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x090e, if !stack[-1] label_08C8: // Incoming jump from 0x08C7, if not !stack[-1] // Inputs[1] { @08C8 stack[-1] } 08C8 80 DUP1 08C9 60 PUSH1 0x1f 08CB 10 LT 08CC 61 PUSH2 0x08e3 08CF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08e3, if 0x1f < stack[-1] label_08D0: // Incoming jump from 0x08CF, if not 0x1f < stack[-1] // Inputs[4] // { // @08D4 stack[-2] // @08D5 storage[stack[-2]] // @08D8 stack[-3] // @08DA stack[-1] // } 08D0 61 PUSH2 0x0100 08D3 80 DUP1 08D4 83 DUP4 08D5 54 SLOAD 08D6 04 DIV 08D7 02 MUL 08D8 83 DUP4 08D9 52 MSTORE 08DA 91 SWAP2 08DB 60 PUSH1 0x20 08DD 01 ADD 08DE 91 SWAP2 08DF 61 PUSH2 0x090e 08E2 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @08D9 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @08DE stack[-1] = stack[-1] // @08DE stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x090e label_08E3: // Incoming jump from 0x08CF, if 0x1f < stack[-1] // Inputs[5] // { // @08E4 stack[-3] // @08E5 stack[-1] // @08E7 stack[-2] // @08EF memory[0x00:0x20] // @08F3 storage[keccak256(memory[0x00:0x20])] // } 08E3 5B JUMPDEST 08E4 82 DUP3 08E5 01 ADD 08E6 91 SWAP2 08E7 90 SWAP1 08E8 60 PUSH1 0x00 08EA 52 MSTORE 08EB 60 PUSH1 0x20 08ED 60 PUSH1 0x00 08EF 20 SHA3 08F0 90 SWAP1 08F1 5B JUMPDEST 08F2 81 DUP2 08F3 54 SLOAD 08F4 81 DUP2 08F5 52 MSTORE 08F6 90 SWAP1 08F7 60 PUSH1 0x01 08F9 01 ADD 08FA 90 SWAP1 08FB 60 PUSH1 0x20 08FD 01 ADD 08FE 80 DUP1 08FF 83 DUP4 0900 11 GT 0901 61 PUSH2 0x08f1 0904 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @08E6 stack[-3] = stack[-3] + stack[-1] // @08EA memory[0x00:0x20] = stack[-2] // @08F5 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @08FA stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @08FD stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x08f1, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0905: // Incoming jump from 0x0904, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0904, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0905 stack[-3] // @0906 stack[-1] // } 0905 82 DUP3 0906 90 SWAP1 0907 03 SUB 0908 60 PUSH1 0x1f 090A 16 AND 090B 82 DUP3 090C 01 ADD 090D 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @090D stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @090D stack[-1] = stack[-3] // } // Block continues label_090E: // Incoming jump from 0x08E2 // Incoming jump from 0x090D // Incoming jump from 0x08C7, if !stack[-1] // Inputs[3] // { // @0914 stack[-7] // @0914 stack[-6] // @0916 stack[-8] // } 090E 5B JUMPDEST 090F 50 POP 0910 50 POP 0911 50 POP 0912 50 POP 0913 50 POP 0914 90 SWAP1 0915 50 POP 0916 90 SWAP1 0917 56 *JUMP // Stack delta = -7 // Outputs[1] { @0916 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0918: // Incoming jump from 0x0304 // Incoming call from 0x1879, returns to 0x187A // Inputs[1] { @091E stack[-1] } 0918 5B JUMPDEST 0919 60 PUSH1 0x00 091B 61 PUSH2 0x0923 091E 82 DUP3 091F 61 PUSH2 0x1783 0922 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0919 stack[0] = 0x00 // @091B stack[1] = 0x0923 // @091E stack[2] = stack[-1] // } // Block ends with call to 0x1783, returns to 0x0923 label_0923: // Incoming return from call to 0x1783 at 0x0922 // Inputs[1] { @0927 stack[-1] } 0923 5B JUMPDEST 0924 61 PUSH2 0x0940 0927 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0940, if stack[-1] label_0928: // Incoming jump from 0x0927, if not stack[-1] // Inputs[3] // { // @092A memory[0x40:0x60] // @093A memory[0x40:0x60] // @093F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0928 60 PUSH1 0x40 092A 51 MLOAD 092B 63 PUSH4 0x33d1c039 0930 60 PUSH1 0xe2 0932 1B SHL 0933 81 DUP2 0934 52 MSTORE 0935 60 PUSH1 0x04 0937 01 ADD 0938 60 PUSH1 0x40 093A 51 MLOAD 093B 80 DUP1 093C 91 SWAP2 093D 03 SUB 093E 90 SWAP1 093F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0934 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x33d1c039 << 0xe2 // @093F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0940: // Incoming jump from 0x0927, if stack[-1] // Inputs[4] // { // @0944 stack[-2] // @094F memory[0x00:0x40] // @0950 storage[keccak256(memory[0x00:0x40])] // @095A stack[-3] // } 0940 5B JUMPDEST 0941 50 POP 0942 60 PUSH1 0x00 0944 90 SWAP1 0945 81 DUP2 0946 52 MSTORE 0947 60 PUSH1 0x06 0949 60 PUSH1 0x20 094B 52 MSTORE 094C 60 PUSH1 0x40 094E 90 SWAP1 094F 20 SHA3 0950 54 SLOAD 0951 60 PUSH1 0x01 0953 60 PUSH1 0x01 0955 60 PUSH1 0xa0 0957 1B SHL 0958 03 SUB 0959 16 AND 095A 90 SWAP1 095B 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0946 memory[0x00:0x20] = stack[-2] // @094B memory[0x20:0x40] = 0x06 // @095A stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_095C: // Incoming call from 0x0331, returns to 0x02D8 // Inputs[1] { @0960 storage[0x0b] } 095C 5B JUMPDEST 095D 60 PUSH1 0x0b 095F 80 DUP1 0960 54 SLOAD 0961 61 PUSH2 0x0969 0964 90 SWAP1 0965 61 PUSH2 0x2603 0968 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @095D stack[0] = 0x0b // @0964 stack[1] = 0x0969 // @0964 stack[2] = storage[0x0b] // } // Block ends with call to 0x2603, returns to 0x0969 label_0969: // Incoming return from call to 0x2603 at 0x0968 // Incoming return from call to 0x2603 at 0x13E5 // Inputs[4] // { // @096A stack[-1] // @0979 memory[0x40:0x60] // @0981 stack[-2] // @098C storage[stack[-2]] // } 0969 5B JUMPDEST 096A 80 DUP1 096B 60 PUSH1 0x1f 096D 01 ADD 096E 60 PUSH1 0x20 0970 80 DUP1 0971 91 SWAP2 0972 04 DIV 0973 02 MUL 0974 60 PUSH1 0x20 0976 01 ADD 0977 60 PUSH1 0x40 0979 51 MLOAD 097A 90 SWAP1 097B 81 DUP2 097C 01 ADD 097D 60 PUSH1 0x40 097F 52 MSTORE 0980 80 DUP1 0981 92 SWAP3 0982 91 SWAP2 0983 90 SWAP1 0984 81 DUP2 0985 81 DUP2 0986 52 MSTORE 0987 60 PUSH1 0x20 0989 01 ADD 098A 82 DUP3 098B 80 DUP1 098C 54 SLOAD 098D 61 PUSH2 0x0995 0990 90 SWAP1 0991 61 PUSH2 0x2603 0994 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @097F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0981 stack[-2] = memory[0x40:0x60] // @0982 stack[-1] = stack[-2] // @0983 stack[0] = stack[-1] // @0986 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0989 stack[1] = 0x20 + memory[0x40:0x60] // @098A stack[2] = stack[-2] // @0990 stack[4] = storage[stack[-2]] // @0990 stack[3] = 0x0995 // } // Block ends with call to 0x2603, returns to 0x0995 label_0995: // Incoming return from call to 0x2603 at 0x0994 // Inputs[1] { @0996 stack[-1] } 0995 5B JUMPDEST 0996 80 DUP1 0997 15 ISZERO 0998 61 PUSH2 0x09e2 099B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09e2, if !stack[-1] label_099C: // Incoming jump from 0x099B, if not !stack[-1] // Inputs[1] { @099C stack[-1] } 099C 80 DUP1 099D 60 PUSH1 0x1f 099F 10 LT 09A0 61 PUSH2 0x09b7 09A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09b7, if 0x1f < stack[-1] label_09A4: // Incoming jump from 0x09A3, if not 0x1f < stack[-1] // Inputs[4] // { // @09A8 stack[-2] // @09A9 storage[stack[-2]] // @09AC stack[-3] // @09AE stack[-1] // } 09A4 61 PUSH2 0x0100 09A7 80 DUP1 09A8 83 DUP4 09A9 54 SLOAD 09AA 04 DIV 09AB 02 MUL 09AC 83 DUP4 09AD 52 MSTORE 09AE 91 SWAP2 09AF 60 PUSH1 0x20 09B1 01 ADD 09B2 91 SWAP2 09B3 61 PUSH2 0x09e2 09B6 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @09AD memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @09B2 stack[-1] = stack[-1] // @09B2 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x09e2 label_09B7: // Incoming jump from 0x09A3, if 0x1f < stack[-1] // Inputs[5] // { // @09B8 stack[-3] // @09B9 stack[-1] // @09BB stack[-2] // @09C3 memory[0x00:0x20] // @09C7 storage[keccak256(memory[0x00:0x20])] // } 09B7 5B JUMPDEST 09B8 82 DUP3 09B9 01 ADD 09BA 91 SWAP2 09BB 90 SWAP1 09BC 60 PUSH1 0x00 09BE 52 MSTORE 09BF 60 PUSH1 0x20 09C1 60 PUSH1 0x00 09C3 20 SHA3 09C4 90 SWAP1 09C5 5B JUMPDEST 09C6 81 DUP2 09C7 54 SLOAD 09C8 81 DUP2 09C9 52 MSTORE 09CA 90 SWAP1 09CB 60 PUSH1 0x01 09CD 01 ADD 09CE 90 SWAP1 09CF 60 PUSH1 0x20 09D1 01 ADD 09D2 80 DUP1 09D3 83 DUP4 09D4 11 GT 09D5 61 PUSH2 0x09c5 09D8 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @09BA stack[-3] = stack[-3] + stack[-1] // @09BE memory[0x00:0x20] = stack[-2] // @09C9 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @09CE stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @09D1 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x09c5, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_09D9: // Incoming jump from 0x09D8, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x09D8, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @09D9 stack[-3] // @09DA stack[-1] // } 09D9 82 DUP3 09DA 90 SWAP1 09DB 03 SUB 09DC 60 PUSH1 0x1f 09DE 16 AND 09DF 82 DUP3 09E0 01 ADD 09E1 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @09E1 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @09E1 stack[-1] = stack[-3] // } // Block continues label_09E2: // Incoming jump from 0x099B, if !stack[-1] // Incoming jump from 0x09B6 // Incoming jump from 0x09E1 // Inputs[1] { @09E8 stack[-7] } 09E2 5B JUMPDEST 09E3 50 POP 09E4 50 POP 09E5 50 POP 09E6 50 POP 09E7 50 POP 09E8 81 DUP2 09E9 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_09EA: // Incoming jump from 0x0351 // Inputs[2] // { // @09ED storage[0x08] // @09F7 msg.sender // } 09EA 5B JUMPDEST 09EB 60 PUSH1 0x08 09ED 54 SLOAD 09EE 60 PUSH1 0x01 09F0 60 PUSH1 0x01 09F2 60 PUSH1 0xa0 09F4 1B SHL 09F5 03 SUB 09F6 16 AND 09F7 33 CALLER 09F8 14 EQ 09F9 61 PUSH2 0x0a14 09FC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a14, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_09FD: // Incoming jump from 0x09FC, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @09FF memory[0x40:0x60] } 09FD 60 PUSH1 0x40 09FF 51 MLOAD 0A00 62 PUSH3 0x461bcd 0A04 60 PUSH1 0xe5 0A06 1B SHL 0A07 81 DUP2 0A08 52 MSTORE 0A09 60 PUSH1 0x04 0A0B 01 ADD 0A0C 61 PUSH2 0x0835 0A0F 90 SWAP1 0A10 61 PUSH2 0x2540 0A13 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A08 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A0F stack[0] = 0x0835 // @0A0F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2540, returns to 0x0835 label_0A14: // Incoming jump from 0x09FC, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0A17 stack[-1] // @0A1C memory[0x40:0x60] // } 0A14 5B JUMPDEST 0A15 60 PUSH1 0x10 0A17 81 DUP2 0A18 90 SWAP1 0A19 55 SSTORE 0A1A 60 PUSH1 0x40 0A1C 51 MLOAD 0A1D 81 DUP2 0A1E 81 DUP2 0A1F 52 MSTORE 0A20 7F PUSH32 0xb505c02ee160e3ad6f9faf50a528b2aded2d886d3d71eaf4aa118d7a4ddf0bc5 0A41 90 SWAP1 0A42 60 PUSH1 0x20 0A44 01 ADD 0A45 61 PUSH2 0x087b 0A48 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0A19 storage[0x10] = stack[-1] // @0A1F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0A41 stack[0] = 0xb505c02ee160e3ad6f9faf50a528b2aded2d886d3d71eaf4aa118d7a4ddf0bc5 // @0A44 stack[1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x087b label_0A49: // Incoming jump from 0x0371 // Inputs[1] { @0A4F stack[-1] } 0A49 5B JUMPDEST 0A4A 60 PUSH1 0x00 0A4C 61 PUSH2 0x0a54 0A4F 82 DUP3 0A50 61 PUSH2 0x0cf7 0A53 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A4A stack[0] = 0x00 // @0A4C stack[1] = 0x0a54 // @0A4F stack[2] = stack[-1] // } // Block ends with call to 0x0cf7, returns to 0x0A54 label_0A54: // Incoming return from call to 0x0CF7 at 0x0A53 // Inputs[3] // { // @0A55 stack[-1] // @0A55 stack[-2] // @0A61 stack[-4] // } 0A54 5B JUMPDEST 0A55 90 SWAP1 0A56 50 POP 0A57 80 DUP1 0A58 60 PUSH1 0x01 0A5A 60 PUSH1 0x01 0A5C 60 PUSH1 0xa0 0A5E 1B SHL 0A5F 03 SUB 0A60 16 AND 0A61 83 DUP4 0A62 60 PUSH1 0x01 0A64 60 PUSH1 0x01 0A66 60 PUSH1 0xa0 0A68 1B SHL 0A69 03 SUB 0A6A 16 AND 0A6B 14 EQ 0A6C 15 ISZERO 0A6D 61 PUSH2 0x0a89 0A70 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0A55 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0a89, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0A71: // Incoming jump from 0x0A70, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @0A73 memory[0x40:0x60] // @0A83 memory[0x40:0x60] // @0A88 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A71 60 PUSH1 0x40 0A73 51 MLOAD 0A74 63 PUSH4 0x250fdee3 0A79 60 PUSH1 0xe2 0A7B 1B SHL 0A7C 81 DUP2 0A7D 52 MSTORE 0A7E 60 PUSH1 0x04 0A80 01 ADD 0A81 60 PUSH1 0x40 0A83 51 MLOAD 0A84 80 DUP1 0A85 91 SWAP2 0A86 03 SUB 0A87 90 SWAP1 0A88 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A7D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x250fdee3 << 0xe2 // @0A88 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0A89: // Incoming jump from 0x0A70, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @0A8A msg.sender // @0A93 stack[-1] // } 0A89 5B JUMPDEST 0A8A 33 CALLER 0A8B 60 PUSH1 0x01 0A8D 60 PUSH1 0x01 0A8F 60 PUSH1 0xa0 0A91 1B SHL 0A92 03 SUB 0A93 82 DUP3 0A94 16 AND 0A95 14 EQ 0A96 80 DUP1 0A97 15 ISZERO 0A98 90 SWAP1 0A99 61 PUSH2 0x0aa9 0A9C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A98 stack[0] = !(stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender) } // Block ends with conditional jump to 0x0aa9, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_0A9D: // Incoming jump from 0x0A9C, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0AA1 stack[-2] // @0AA2 msg.sender // } 0A9D 50 POP 0A9E 61 PUSH2 0x0aa7 0AA1 81 DUP2 0AA2 33 CALLER 0AA3 61 PUSH2 0x072b 0AA6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A9E stack[-1] = 0x0aa7 // @0AA1 stack[0] = stack[-2] // @0AA2 stack[1] = msg.sender // } // Block ends with call to 0x072b, returns to 0x0AA7 label_0AA7: // Incoming return from call to 0x072B at 0x0AA6 // Inputs[1] { @0AA8 stack[-1] } 0AA7 5B JUMPDEST 0AA8 15 ISZERO // Stack delta = +0 // Outputs[1] { @0AA8 stack[-1] = !stack[-1] } // Block continues label_0AA9: // Incoming jump from 0x0A9C, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming jump from 0x0AA8 // Inputs[1] { @0AAA stack[-1] } 0AA9 5B JUMPDEST 0AAA 15 ISZERO 0AAB 61 PUSH2 0x0ac7 0AAE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ac7, if !stack[-1] label_0AAF: // Incoming jump from 0x0AAE, if not !stack[-1] // Inputs[3] // { // @0AB1 memory[0x40:0x60] // @0AC1 memory[0x40:0x60] // @0AC6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0AAF 60 PUSH1 0x40 0AB1 51 MLOAD 0AB2 63 PUSH4 0x67d9dca1 0AB7 60 PUSH1 0xe1 0AB9 1B SHL 0ABA 81 DUP2 0ABB 52 MSTORE 0ABC 60 PUSH1 0x04 0ABE 01 ADD 0ABF 60 PUSH1 0x40 0AC1 51 MLOAD 0AC2 80 DUP1 0AC3 91 SWAP2 0AC4 03 SUB 0AC5 90 SWAP1 0AC6 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0ABB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x67d9dca1 << 0xe1 // @0AC6 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0AC7: // Incoming jump from 0x0AAE, if !stack[-1] // Inputs[3] // { // @0ACB stack[-3] // @0ACC stack[-2] // @0ACD stack[-1] // } 0AC7 5B JUMPDEST 0AC8 61 PUSH2 0x0ad2 0ACB 83 DUP4 0ACC 83 DUP4 0ACD 83 DUP4 0ACE 61 PUSH2 0x17ae 0AD1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0AC8 stack[0] = 0x0ad2 // @0ACB stack[1] = stack[-3] // @0ACC stack[2] = stack[-2] // @0ACD stack[3] = stack[-1] // } // Block ends with call to 0x17ae, returns to 0x0AD2 label_0AD2: // Incoming return from call to 0x1E47 at 0x1DC4 // Incoming return from call to 0x17AE at 0x0AD1 // Inputs[1] { @0AD6 stack[-4] } 0AD2 5B JUMPDEST 0AD3 50 POP 0AD4 50 POP 0AD5 50 POP 0AD6 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0AD7: // Incoming jump from 0x03CE // Inputs[2] // { // @0ADA storage[0x08] // @0AE4 msg.sender // } 0AD7 5B JUMPDEST 0AD8 60 PUSH1 0x08 0ADA 54 SLOAD 0ADB 60 PUSH1 0x01 0ADD 60 PUSH1 0x01 0ADF 60 PUSH1 0xa0 0AE1 1B SHL 0AE2 03 SUB 0AE3 16 AND 0AE4 33 CALLER 0AE5 14 EQ 0AE6 61 PUSH2 0x0b01 0AE9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b01, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0AEA: // Incoming jump from 0x0AE9, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0AEC memory[0x40:0x60] } 0AEA 60 PUSH1 0x40 0AEC 51 MLOAD 0AED 62 PUSH3 0x461bcd 0AF1 60 PUSH1 0xe5 0AF3 1B SHL 0AF4 81 DUP2 0AF5 52 MSTORE 0AF6 60 PUSH1 0x04 0AF8 01 ADD 0AF9 61 PUSH2 0x0835 0AFC 90 SWAP1 0AFD 61 PUSH2 0x2540 0B00 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0AF5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AFC stack[0] = 0x0835 // @0AFC stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2540, returns to 0x0835 label_0B01: // Incoming jump from 0x0AE9, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0B05 storage[0x09] // @0B18 stack[-1] // @0B22 memory[0x40:0x60] // } 0B01 5B JUMPDEST 0B02 60 PUSH1 0x09 0B04 80 DUP1 0B05 54 SLOAD 0B06 60 PUSH1 0x01 0B08 60 PUSH1 0x01 0B0A 60 PUSH1 0xa0 0B0C 1B SHL 0B0D 03 SUB 0B0E 19 NOT 0B0F 16 AND 0B10 60 PUSH1 0x01 0B12 60 PUSH1 0x01 0B14 60 PUSH1 0xa0 0B16 1B SHL 0B17 03 SUB 0B18 83 DUP4 0B19 16 AND 0B1A 90 SWAP1 0B1B 81 DUP2 0B1C 17 OR 0B1D 90 SWAP1 0B1E 91 SWAP2 0B1F 55 SSTORE 0B20 60 PUSH1 0x40 0B22 51 MLOAD 0B23 90 SWAP1 0B24 81 DUP2 0B25 52 MSTORE 0B26 7F PUSH32 0x7b3f26f5735eda85390123a65f4b4bfb898d595d98e2f96fea39a94f27331dae 0B47 90 SWAP1 0B48 60 PUSH1 0x20 0B4A 01 ADD 0B4B 61 PUSH2 0x087b 0B4E 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0B1F storage[0x09] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[0x09]) // @0B25 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0B47 stack[0] = 0x7b3f26f5735eda85390123a65f4b4bfb898d595d98e2f96fea39a94f27331dae // @0B4A stack[1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x087b label_0B4F: // Incoming jump from 0x0404 // Inputs[3] // { // @0B53 stack[-3] // @0B54 stack[-2] // @0B55 stack[-1] // } 0B4F 5B JUMPDEST 0B50 61 PUSH2 0x0ad2 0B53 83 DUP4 0B54 83 DUP4 0B55 83 DUP4 0B56 61 PUSH2 0x180a 0B59 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B50 stack[0] = 0x0ad2 // @0B53 stack[1] = stack[-3] // @0B54 stack[2] = stack[-2] // @0B55 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x180a label_0B5A: // Incoming call from 0x0422, returns to 0x02C1 // Inputs[2] // { // @0B5D storage[0x08] // @0B67 msg.sender // } 0B5A 5B JUMPDEST 0B5B 60 PUSH1 0x08 0B5D 54 SLOAD 0B5E 60 PUSH1 0x01 0B60 60 PUSH1 0x01 0B62 60 PUSH1 0xa0 0B64 1B SHL 0B65 03 SUB 0B66 16 AND 0B67 33 CALLER 0B68 14 EQ 0B69 61 PUSH2 0x0b84 0B6C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b84, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0B6D: // Incoming jump from 0x0B6C, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0B6F memory[0x40:0x60] } 0B6D 60 PUSH1 0x40 0B6F 51 MLOAD 0B70 62 PUSH3 0x461bcd 0B74 60 PUSH1 0xe5 0B76 1B SHL 0B77 81 DUP2 0B78 52 MSTORE 0B79 60 PUSH1 0x04 0B7B 01 ADD 0B7C 61 PUSH2 0x0835 0B7F 90 SWAP1 0B80 61 PUSH2 0x2540 0B83 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B78 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B7F stack[0] = 0x0835 // @0B7F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2540, returns to 0x0835 label_0B84: // Incoming jump from 0x0B6C, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[8] // { // @0B87 storage[0x09] // @0B8A memory[0x40:0x60] // @0B98 address(this) // @0B98 address(this).balance // @0BA0 msg.gas // @0BA1 address((0x01 << 0xa0) - 0x01 & storage[0x09]).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0BA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0BA6 returndata.length // } 0B84 5B JUMPDEST 0B85 60 PUSH1 0x09 0B87 54 SLOAD 0B88 60 PUSH1 0x40 0B8A 51 MLOAD 0B8B 60 PUSH1 0x00 0B8D 91 SWAP2 0B8E 60 PUSH1 0x01 0B90 60 PUSH1 0x01 0B92 60 PUSH1 0xa0 0B94 1B SHL 0B95 03 SUB 0B96 16 AND 0B97 90 SWAP1 0B98 47 SELFBALANCE 0B99 90 SWAP1 0B9A 83 DUP4 0B9B 81 DUP2 0B9C 81 DUP2 0B9D 81 DUP2 0B9E 85 DUP6 0B9F 87 DUP8 0BA0 5A GAS 0BA1 F1 CALL 0BA2 92 SWAP3 0BA3 50 POP 0BA4 50 POP 0BA5 50 POP 0BA6 3D RETURNDATASIZE 0BA7 80 DUP1 0BA8 60 PUSH1 0x00 0BAA 81 DUP2 0BAB 14 EQ 0BAC 61 PUSH2 0x0bd1 0BAF 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @0B8D stack[0] = 0x00 // @0BA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address((0x01 << 0xa0) - 0x01 & storage[0x09]).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0BA2 stack[1] = address((0x01 << 0xa0) - 0x01 & storage[0x09]).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0BA6 stack[2] = returndata.length // @0BA7 stack[3] = returndata.length // } // Block ends with conditional jump to 0x0bd1, if returndata.length == 0x00 label_0BB0: // Incoming jump from 0x0BAF, if not returndata.length == 0x00 // Inputs[6] // { // @0BB2 memory[0x40:0x60] // @0BB3 stack[-2] // @0BBA returndata.length // @0BC2 returndata.length // @0BC5 returndata.length // @0BCC returndata[0x00:0x00 + returndata.length] // } 0BB0 60 PUSH1 0x40 0BB2 51 MLOAD 0BB3 91 SWAP2 0BB4 50 POP 0BB5 60 PUSH1 0x1f 0BB7 19 NOT 0BB8 60 PUSH1 0x3f 0BBA 3D RETURNDATASIZE 0BBB 01 ADD 0BBC 16 AND 0BBD 82 DUP3 0BBE 01 ADD 0BBF 60 PUSH1 0x40 0BC1 52 MSTORE 0BC2 3D RETURNDATASIZE 0BC3 82 DUP3 0BC4 52 MSTORE 0BC5 3D RETURNDATASIZE 0BC6 60 PUSH1 0x00 0BC8 60 PUSH1 0x20 0BCA 84 DUP5 0BCB 01 ADD 0BCC 3E RETURNDATACOPY 0BCD 61 PUSH2 0x0bd6 0BD0 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0BB3 stack[-2] = memory[0x40:0x60] // @0BC1 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0BC4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0BCC memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0bd6 label_0BD1: // Incoming jump from 0x0BAF, if returndata.length == 0x00 // Inputs[3] // { // @0BD4 stack[-2] // @0BD9 stack[-4] // @0BD9 stack[-3] // } 0BD1 5B JUMPDEST 0BD2 60 PUSH1 0x60 0BD4 91 SWAP2 0BD5 50 POP 0BD6 5B JUMPDEST 0BD7 50 POP 0BD8 50 POP 0BD9 90 SWAP1 0BDA 50 POP 0BDB 80 DUP1 0BDC 61 PUSH2 0x0be4 0BDF 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0BD9 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x0be4, if stack[-3] label_0BE0: // Incoming jump from 0x0BDF, if not stack[-3] // Incoming jump from 0x0BDF, if not stack[-3] // Inputs[1] { @0BE3 memory[0x00:0x00] } 0BE0 60 PUSH1 0x00 0BE2 80 DUP1 0BE3 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BE3 revert(memory[0x00:0x00]); } // Block terminates label_0BE4: // Incoming jump from 0x0BDF, if stack[-3] // Incoming jump from 0x0BDF, if stack[-3] // Inputs[3] // { // @0BE7 memory[0x40:0x60] // @0C0D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0C0F stack[-2] // } 0BE4 5B JUMPDEST 0BE5 60 PUSH1 0x40 0BE7 51 MLOAD 0BE8 7F PUSH32 0xb88755970a5171e2e6cd3a4629e010611aa1096c3f742ec5705c564fe23d8a81 0C09 90 SWAP1 0C0A 60 PUSH1 0x00 0C0C 90 SWAP1 0C0D A1 LOG1 0C0E 50 POP 0C0F 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C0D log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xb88755970a5171e2e6cd3a4629e010611aa1096c3f742ec5705c564fe23d8a81]); } // Block ends with unconditional jump to stack[-2] label_0C10: // Incoming jump from 0x0442 // Inputs[4] // { // @0C14 stack[-3] // @0C15 stack[-2] // @0C16 stack[-1] // @0C19 memory[0x40:0x60] // } 0C10 5B JUMPDEST 0C11 61 PUSH2 0x0ad2 0C14 83 DUP4 0C15 83 DUP4 0C16 83 DUP4 0C17 60 PUSH1 0x40 0C19 51 MLOAD 0C1A 80 DUP1 0C1B 60 PUSH1 0x20 0C1D 01 ADD 0C1E 60 PUSH1 0x40 0C20 52 MSTORE 0C21 80 DUP1 0C22 60 PUSH1 0x00 0C24 81 DUP2 0C25 52 MSTORE 0C26 50 POP 0C27 61 PUSH2 0x1388 0C2A 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0C11 stack[0] = 0x0ad2 // @0C14 stack[1] = stack[-3] // @0C15 stack[2] = stack[-2] // @0C16 stack[3] = stack[-1] // @0C19 stack[4] = memory[0x40:0x60] // @0C20 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0C25 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x1388 label_0C2B: // Incoming jump from 0x0462 // Inputs[2] // { // @0C2E storage[0x08] // @0C38 msg.sender // } 0C2B 5B JUMPDEST 0C2C 60 PUSH1 0x08 0C2E 54 SLOAD 0C2F 60 PUSH1 0x01 0C31 60 PUSH1 0x01 0C33 60 PUSH1 0xa0 0C35 1B SHL 0C36 03 SUB 0C37 16 AND 0C38 33 CALLER 0C39 14 EQ 0C3A 61 PUSH2 0x0c55 0C3D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c55, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0C3E: // Incoming jump from 0x0C3D, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0C40 memory[0x40:0x60] } 0C3E 60 PUSH1 0x40 0C40 51 MLOAD 0C41 62 PUSH3 0x461bcd 0C45 60 PUSH1 0xe5 0C47 1B SHL 0C48 81 DUP2 0C49 52 MSTORE 0C4A 60 PUSH1 0x04 0C4C 01 ADD 0C4D 61 PUSH2 0x0835 0C50 90 SWAP1 0C51 61 PUSH2 0x2540 0C54 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C49 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C50 stack[0] = 0x0835 // @0C50 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2540, returns to 0x0835 label_0C55: // Incoming jump from 0x0C3D, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0C58 stack[-1] // @0C5D memory[0x40:0x60] // } 0C55 5B JUMPDEST 0C56 60 PUSH1 0x0d 0C58 81 DUP2 0C59 90 SWAP1 0C5A 55 SSTORE 0C5B 60 PUSH1 0x40 0C5D 51 MLOAD 0C5E 81 DUP2 0C5F 81 DUP2 0C60 52 MSTORE 0C61 7F PUSH32 0x4dd2a5ec13f6b592d27f09b567c7f5764b967191000d6ea870a1bdfc8a8a191d 0C82 90 SWAP1 0C83 60 PUSH1 0x20 0C85 01 ADD 0C86 61 PUSH2 0x087b 0C89 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0C5A storage[0x0d] = stack[-1] // @0C60 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0C82 stack[0] = 0x4dd2a5ec13f6b592d27f09b567c7f5764b967191000d6ea870a1bdfc8a8a191d // @0C85 stack[1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x087b label_0C8A: // Incoming jump from 0x04BC // Inputs[2] // { // @0C8D storage[0x08] // @0C97 msg.sender // } 0C8A 5B JUMPDEST 0C8B 60 PUSH1 0x08 0C8D 54 SLOAD 0C8E 60 PUSH1 0x01 0C90 60 PUSH1 0x01 0C92 60 PUSH1 0xa0 0C94 1B SHL 0C95 03 SUB 0C96 16 AND 0C97 33 CALLER 0C98 14 EQ 0C99 61 PUSH2 0x0cb4 0C9C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cb4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0C9D: // Incoming jump from 0x0C9C, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0C9F memory[0x40:0x60] } 0C9D 60 PUSH1 0x40 0C9F 51 MLOAD 0CA0 62 PUSH3 0x461bcd 0CA4 60 PUSH1 0xe5 0CA6 1B SHL 0CA7 81 DUP2 0CA8 52 MSTORE 0CA9 60 PUSH1 0x04 0CAB 01 ADD 0CAC 61 PUSH2 0x0835 0CAF 90 SWAP1 0CB0 61 PUSH2 0x2540 0CB3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0CA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CAF stack[0] = 0x0835 // @0CAF stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2540, returns to 0x0835 label_0CB4: // Incoming jump from 0x0C9C, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0CB5 stack[-1] // @0CB6 memory[stack[-1]:stack[-1] + 0x20] // } 0CB4 5B JUMPDEST 0CB5 80 DUP1 0CB6 51 MLOAD 0CB7 61 PUSH2 0x0cc7 0CBA 90 SWAP1 0CBB 60 PUSH1 0x0a 0CBD 90 SWAP1 0CBE 60 PUSH1 0x20 0CC0 84 DUP5 0CC1 01 ADD 0CC2 90 SWAP1 0CC3 61 PUSH2 0x2012 0CC6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0CBA stack[0] = 0x0cc7 // @0CBD stack[1] = 0x0a // @0CC2 stack[2] = stack[-1] + 0x20 // @0CC2 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2012 0CC7 5B JUMPDEST 0CC8 50 POP 0CC9 7F PUSH32 0xa93e7bffe1d9cf216fa67e24bb04fdd93b54c49932cb707eb79047ea23bcc747 0CEA 81 DUP2 0CEB 60 PUSH1 0x40 0CED 51 MLOAD 0CEE 61 PUSH2 0x087b 0CF1 91 SWAP2 0CF2 90 SWAP1 0CF3 61 PUSH2 0x252d 0CF6 56 *JUMP label_0CF7: // Incoming call from 0x0A53, returns to 0x0A54 // Incoming jump from 0x0510 // Inputs[1] { @0CFD stack[-1] } 0CF7 5B JUMPDEST 0CF8 60 PUSH1 0x00 0CFA 61 PUSH2 0x0d02 0CFD 82 DUP3 0CFE 61 PUSH2 0x19f8 0D01 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CF8 stack[0] = 0x00 // @0CFA stack[1] = 0x0d02 // @0CFD stack[2] = stack[-1] // } // Block ends with call to 0x19f8, returns to 0x0D02 label_0D02: // Incoming return from call to 0x19F8 at 0x0D01 // Inputs[4] // { // @0D03 memory[stack[-1]:stack[-1] + 0x20] // @0D03 stack[-1] // @0D04 stack[-4] // @0D05 stack[-3] // } 0D02 5B JUMPDEST 0D03 51 MLOAD 0D04 92 SWAP3 0D05 91 SWAP2 0D06 50 POP 0D07 50 POP 0D08 56 *JUMP // Stack delta = -3 // Outputs[1] { @0D04 stack[-4] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-4] label_0D09: // Incoming jump from 0x0530 // Inputs[2] // { // @0D0C storage[0x08] // @0D16 msg.sender // } 0D09 5B JUMPDEST 0D0A 60 PUSH1 0x08 0D0C 54 SLOAD 0D0D 60 PUSH1 0x01 0D0F 60 PUSH1 0x01 0D11 60 PUSH1 0xa0 0D13 1B SHL 0D14 03 SUB 0D15 16 AND 0D16 33 CALLER 0D17 14 EQ 0D18 61 PUSH2 0x0d33 0D1B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d33, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0D1C: // Incoming jump from 0x0D1B, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0D1E memory[0x40:0x60] } 0D1C 60 PUSH1 0x40 0D1E 51 MLOAD 0D1F 62 PUSH3 0x461bcd 0D23 60 PUSH1 0xe5 0D25 1B SHL 0D26 81 DUP2 0D27 52 MSTORE 0D28 60 PUSH1 0x04 0D2A 01 ADD 0D2B 61 PUSH2 0x0835 0D2E 90 SWAP1 0D2F 61 PUSH2 0x2540 0D32 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D27 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D2E stack[0] = 0x0835 // @0D2E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2540, returns to 0x0835 label_0D33: // Incoming jump from 0x0D1B, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0D37 storage[0x12] // @0D3C stack[-1] // @0D47 memory[0x40:0x60] // } 0D33 5B JUMPDEST 0D34 60 PUSH1 0x12 0D36 80 DUP1 0D37 54 SLOAD 0D38 60 PUSH1 0xff 0D3A 19 NOT 0D3B 16 AND 0D3C 82 DUP3 0D3D 15 ISZERO 0D3E 15 ISZERO 0D3F 90 SWAP1 0D40 81 DUP2 0D41 17 OR 0D42 90 SWAP1 0D43 91 SWAP2 0D44 55 SSTORE 0D45 60 PUSH1 0x40 0D47 51 MLOAD 0D48 90 SWAP1 0D49 81 DUP2 0D4A 52 MSTORE 0D4B 7F PUSH32 0xfde4f90d2b5f1d77636cd64052d52ac613d963642bce08723be1d1c1b902bcc6 0D6C 90 SWAP1 0D6D 60 PUSH1 0x20 0D6F 01 ADD 0D70 61 PUSH2 0x087b 0D73 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0D44 storage[0x12] = !!stack[-1] | (~0xff & storage[0x12]) // @0D4A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0D6C stack[0] = 0xfde4f90d2b5f1d77636cd64052d52ac613d963642bce08723be1d1c1b902bcc6 // @0D6F stack[1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x087b label_0D74: // Incoming jump from 0x0550 // Inputs[2] // { // @0D77 storage[0x08] // @0D81 msg.sender // } 0D74 5B JUMPDEST 0D75 60 PUSH1 0x08 0D77 54 SLOAD 0D78 60 PUSH1 0x01 0D7A 60 PUSH1 0x01 0D7C 60 PUSH1 0xa0 0D7E 1B SHL 0D7F 03 SUB 0D80 16 AND 0D81 33 CALLER 0D82 14 EQ 0D83 61 PUSH2 0x0d9e 0D86 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d9e, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0D87: // Incoming jump from 0x0D86, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0D89 memory[0x40:0x60] } 0D87 60 PUSH1 0x40 0D89 51 MLOAD 0D8A 62 PUSH3 0x461bcd 0D8E 60 PUSH1 0xe5 0D90 1B SHL 0D91 81 DUP2 0D92 52 MSTORE 0D93 60 PUSH1 0x04 0D95 01 ADD 0D96 61 PUSH2 0x0835 0D99 90 SWAP1 0D9A 61 PUSH2 0x2540 0D9D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D92 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D99 stack[0] = 0x0835 // @0D99 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2540, returns to 0x0835 label_0D9E: // Incoming jump from 0x0D86, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0DA1 stack[-1] // @0DA6 memory[0x40:0x60] // } 0D9E 5B JUMPDEST 0D9F 60 PUSH1 0x0f 0DA1 81 DUP2 0DA2 90 SWAP1 0DA3 55 SSTORE 0DA4 60 PUSH1 0x40 0DA6 51 MLOAD 0DA7 81 DUP2 0DA8 81 DUP2 0DA9 52 MSTORE 0DAA 7F PUSH32 0xa0d24607d8715449afeaea245a9dc03c9e5fae94f159423c1e6a3957532d2072 0DCB 90 SWAP1 0DCC 60 PUSH1 0x20 0DCE 01 ADD 0DCF 61 PUSH2 0x087b 0DD2 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0DA3 storage[0x0f] = stack[-1] // @0DA9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0DCB stack[0] = 0xa0d24607d8715449afeaea245a9dc03c9e5fae94f159423c1e6a3957532d2072 // @0DCE stack[1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x087b label_0DD3: // Incoming jump from 0x0570 // Inputs[1] { @0DDE stack[-1] } 0DD3 5B JUMPDEST 0DD4 60 PUSH1 0x00 0DD6 60 PUSH1 0x01 0DD8 60 PUSH1 0x01 0DDA 60 PUSH1 0xa0 0DDC 1B SHL 0DDD 03 SUB 0DDE 82 DUP3 0DDF 16 AND 0DE0 61 PUSH2 0x0dfc 0DE3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0DD4 stack[0] = 0x00 } // Block ends with conditional jump to 0x0dfc, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0DE4: // Incoming jump from 0x0DE3, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0DE6 memory[0x40:0x60] // @0DF6 memory[0x40:0x60] // @0DFB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0DE4 60 PUSH1 0x40 0DE6 51 MLOAD 0DE7 63 PUSH4 0x23d3ad81 0DEC 60 PUSH1 0xe2 0DEE 1B SHL 0DEF 81 DUP2 0DF0 52 MSTORE 0DF1 60 PUSH1 0x04 0DF3 01 ADD 0DF4 60 PUSH1 0x40 0DF6 51 MLOAD 0DF7 80 DUP1 0DF8 91 SWAP2 0DF9 03 SUB 0DFA 90 SWAP1 0DFB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0DF0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x23d3ad81 << 0xe2 // @0DFB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0DFC: // Incoming jump from 0x0DE3, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0E06 stack[-2] // @0E14 memory[0x00:0x40] // @0E15 storage[keccak256(memory[0x00:0x40])] // @0E1F stack[-3] // } 0DFC 5B JUMPDEST 0DFD 50 POP 0DFE 60 PUSH1 0x01 0E00 60 PUSH1 0x01 0E02 60 PUSH1 0xa0 0E04 1B SHL 0E05 03 SUB 0E06 16 AND 0E07 60 PUSH1 0x00 0E09 90 SWAP1 0E0A 81 DUP2 0E0B 52 MSTORE 0E0C 60 PUSH1 0x05 0E0E 60 PUSH1 0x20 0E10 52 MSTORE 0E11 60 PUSH1 0x40 0E13 90 SWAP1 0E14 20 SHA3 0E15 54 SLOAD 0E16 60 PUSH1 0x01 0E18 60 PUSH1 0x01 0E1A 60 PUSH1 0x40 0E1C 1B SHL 0E1D 03 SUB 0E1E 16 AND 0E1F 90 SWAP1 0E20 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0E0B memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0E10 memory[0x20:0x40] = 0x05 // @0E1F stack[-3] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0E21: // Incoming call from 0x0585, returns to 0x02C1 // Inputs[2] // { // @0E24 storage[0x08] // @0E2E msg.sender // } 0E21 5B JUMPDEST 0E22 60 PUSH1 0x08 0E24 54 SLOAD 0E25 60 PUSH1 0x01 0E27 60 PUSH1 0x01 0E29 60 PUSH1 0xa0 0E2B 1B SHL 0E2C 03 SUB 0E2D 16 AND 0E2E 33 CALLER 0E2F 14 EQ 0E30 61 PUSH2 0x0e4b 0E33 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e4b, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0E34: // Incoming jump from 0x0E33, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0E36 memory[0x40:0x60] } 0E34 60 PUSH1 0x40 0E36 51 MLOAD 0E37 62 PUSH3 0x461bcd 0E3B 60 PUSH1 0xe5 0E3D 1B SHL 0E3E 81 DUP2 0E3F 52 MSTORE 0E40 60 PUSH1 0x04 0E42 01 ADD 0E43 61 PUSH2 0x0835 0E46 90 SWAP1 0E47 61 PUSH2 0x2540 0E4A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E3F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E46 stack[0] = 0x0835 // @0E46 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2540, returns to 0x0835 label_0E4B: // Incoming jump from 0x0E33, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] 0E4B 5B JUMPDEST 0E4C 61 PUSH2 0x0e55 0E4F 60 PUSH1 0x00 0E51 61 PUSH2 0x1b12 0E54 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0E4C stack[0] = 0x0e55 // @0E4F stack[1] = 0x00 // } // Block ends with call to 0x1b12, returns to 0x0E55 label_0E55: // Incoming return from call to 0x1B12 at 0x0E54 // Inputs[1] { @0E56 stack[-1] } 0E55 5B JUMPDEST 0E56 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0E57: // Incoming jump from 0x05C3 // Inputs[2] // { // @0E5A storage[0x08] // @0E64 msg.sender // } 0E57 5B JUMPDEST 0E58 60 PUSH1 0x08 0E5A 54 SLOAD 0E5B 60 PUSH1 0x01 0E5D 60 PUSH1 0x01 0E5F 60 PUSH1 0xa0 0E61 1B SHL 0E62 03 SUB 0E63 16 AND 0E64 33 CALLER 0E65 14 EQ 0E66 61 PUSH2 0x0e81 0E69 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e81, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0E6A: // Incoming jump from 0x0E69, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0E6C memory[0x40:0x60] } 0E6A 60 PUSH1 0x40 0E6C 51 MLOAD 0E6D 62 PUSH3 0x461bcd 0E71 60 PUSH1 0xe5 0E73 1B SHL 0E74 81 DUP2 0E75 52 MSTORE 0E76 60 PUSH1 0x04 0E78 01 ADD 0E79 61 PUSH2 0x0835 0E7C 90 SWAP1 0E7D 61 PUSH2 0x2540 0E80 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E75 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E7C stack[0] = 0x0835 // @0E7C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2540, returns to 0x0835 label_0E81: // Incoming jump from 0x0E69, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0E85 storage[0x15] // @0E8A stack[-1] // @0E95 memory[0x40:0x60] // } 0E81 5B JUMPDEST 0E82 60 PUSH1 0x15 0E84 80 DUP1 0E85 54 SLOAD 0E86 60 PUSH1 0xff 0E88 19 NOT 0E89 16 AND 0E8A 82 DUP3 0E8B 15 ISZERO 0E8C 15 ISZERO 0E8D 90 SWAP1 0E8E 81 DUP2 0E8F 17 OR 0E90 90 SWAP1 0E91 91 SWAP2 0E92 55 SSTORE 0E93 60 PUSH1 0x40 0E95 51 MLOAD 0E96 90 SWAP1 0E97 81 DUP2 0E98 52 MSTORE 0E99 7F PUSH32 0x067225b113261bc0d9511cc3ae674ea4ad4f4853016c8c3dff9c00885918c69a 0EBA 90 SWAP1 0EBB 60 PUSH1 0x20 0EBD 01 ADD 0EBE 61 PUSH2 0x087b 0EC1 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0E92 storage[0x15] = !!stack[-1] | (~0xff & storage[0x15]) // @0E98 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0EBA stack[0] = 0x067225b113261bc0d9511cc3ae674ea4ad4f4853016c8c3dff9c00885918c69a // @0EBD stack[1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x087b label_0EC2: // Incoming call from 0x05D8, returns to 0x02D8 // Inputs[1] { @0EC8 storage[0x03] } 0EC2 5B JUMPDEST 0EC3 60 PUSH1 0x60 0EC5 60 PUSH1 0x03 0EC7 80 DUP1 0EC8 54 SLOAD 0EC9 61 PUSH2 0x0895 0ECC 90 SWAP1 0ECD 61 PUSH2 0x2603 0ED0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EC3 stack[0] = 0x60 // @0EC5 stack[1] = 0x03 // @0ECC stack[2] = 0x0895 // @0ECC stack[3] = storage[0x03] // } // Block ends with call to 0x2603, returns to 0x0895 label_0ED1: // Incoming jump from 0x05EB // Inputs[1] { @0ED4 storage[0x0e] } 0ED1 5B JUMPDEST 0ED2 60 PUSH1 0x0e 0ED4 54 SLOAD 0ED5 60 PUSH1 0xff 0ED7 16 AND 0ED8 15 ISZERO 0ED9 61 PUSH2 0x0f24 0EDC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f24, if !(0xff & storage[0x0e]) label_0EDD: // Incoming jump from 0x0EDC, if not !(0xff & storage[0x0e]) // Inputs[1] { @0EDF memory[0x40:0x60] } 0EDD 60 PUSH1 0x40 0EDF 51 MLOAD 0EE0 62 PUSH3 0x461bcd 0EE4 60 PUSH1 0xe5 0EE6 1B SHL 0EE7 81 DUP2 0EE8 52 MSTORE 0EE9 60 PUSH1 0x20 0EEB 60 PUSH1 0x04 0EED 82 DUP3 0EEE 01 ADD 0EEF 52 MSTORE 0EF0 60 PUSH1 0x18 0EF2 60 PUSH1 0x24 0EF4 82 DUP3 0EF5 01 ADD 0EF6 52 MSTORE 0EF7 7F PUSH32 0x43616e6e6f74206d696e74207768696c65207061757365640000000000000000 0F18 60 PUSH1 0x44 0F1A 82 DUP3 0F1B 01 ADD 0F1C 52 MSTORE 0F1D 60 PUSH1 0x64 0F1F 01 ADD 0F20 61 PUSH2 0x0835 0F23 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0EE8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EEF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0EF6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x18 // @0F1C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616e6e6f74206d696e74207768696c65207061757365640000000000000000 // @0F1F stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0835 label_0F24: // Incoming jump from 0x0EDC, if !(0xff & storage[0x0e]) // Inputs[1] { @0F27 stack[-1] } 0F24 5B JUMPDEST 0F25 60 PUSH1 0x00 0F27 81 DUP2 0F28 11 GT 0F29 61 PUSH2 0x0f31 0F2C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f31, if stack[-1] > 0x00 label_0F2D: // Incoming jump from 0x0F2C, if not stack[-1] > 0x00 // Inputs[1] { @0F30 memory[0x00:0x00] } 0F2D 60 PUSH1 0x00 0F2F 80 DUP1 0F30 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F30 revert(memory[0x00:0x00]); } // Block terminates label_0F31: // Incoming jump from 0x0F2C, if stack[-1] > 0x00 // Inputs[4] // { // @0F34 storage[0x0f] // @0F35 stack[-1] // @0F3B storage[0x01] // @0F3E storage[0x00] // } 0F31 5B JUMPDEST 0F32 60 PUSH1 0x0f 0F34 54 SLOAD 0F35 81 DUP2 0F36 61 PUSH2 0x0f42 0F39 60 PUSH1 0x01 0F3B 54 SLOAD 0F3C 60 PUSH1 0x00 0F3E 54 SLOAD 0F3F 03 SUB 0F40 90 SWAP1 0F41 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F34 stack[0] = storage[0x0f] // @0F35 stack[1] = stack[-1] // @0F40 stack[2] = storage[0x00] - storage[0x01] // } // Block ends with unconditional jump to 0x0f42 label_0F42: // Incoming jump from 0x0F41 // Inputs[2] // { // @0F46 stack[-2] // @0F47 stack[-1] // } 0F42 5B JUMPDEST 0F43 61 PUSH2 0x0f4c 0F46 91 SWAP2 0F47 90 SWAP1 0F48 61 PUSH2 0x2575 0F4B 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0F46 stack[-2] = 0x0f4c // @0F47 stack[-1] = stack[-2] // @0F47 stack[0] = stack[-1] // } // Block ends with call to 0x2575, returns to 0x0F4C label_0F4C: // Incoming return from call to 0x2575 at 0x0F4B // Inputs[2] // { // @0F4D stack[-2] // @0F4D stack[-1] // } 0F4C 5B JUMPDEST 0F4D 11 GT 0F4E 15 ISZERO 0F4F 61 PUSH2 0x0f57 0F52 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0f57, if !(stack[-1] > stack[-2]) label_0F53: // Incoming jump from 0x0F52, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0F56 memory[0x00:0x00] } 0F53 60 PUSH1 0x00 0F55 80 DUP1 0F56 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F56 revert(memory[0x00:0x00]); } // Block terminates label_0F57: // Incoming jump from 0x0F52, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @0F5A storage[0x08] // @0F64 msg.sender // } 0F57 5B JUMPDEST 0F58 60 PUSH1 0x08 0F5A 54 SLOAD 0F5B 60 PUSH1 0x01 0F5D 60 PUSH1 0x01 0F5F 60 PUSH1 0xa0 0F61 1B SHL 0F62 03 SUB 0F63 16 AND 0F64 33 CALLER 0F65 14 EQ 0F66 61 PUSH2 0x0ff8 0F69 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ff8, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0F6A: // Incoming jump from 0x0F69, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[5] // { // @0F6C storage[0x10] // @0F6D msg.sender // @0F7B memory[0x00:0x40] // @0F7C storage[keccak256(memory[0x00:0x40])] // @0F91 stack[-1] // } 0F6A 60 PUSH1 0x10 0F6C 54 SLOAD 0F6D 33 CALLER 0F6E 60 PUSH1 0x00 0F70 90 SWAP1 0F71 81 DUP2 0F72 52 MSTORE 0F73 60 PUSH1 0x05 0F75 60 PUSH1 0x20 0F77 52 MSTORE 0F78 60 PUSH1 0x40 0F7A 90 SWAP1 0F7B 20 SHA3 0F7C 54 SLOAD 0F7D 60 PUSH1 0x01 0F7F 60 PUSH1 0x40 0F81 1B SHL 0F82 90 SWAP1 0F83 04 DIV 0F84 60 PUSH1 0x01 0F86 60 PUSH1 0x01 0F88 60 PUSH1 0x40 0F8A 1B SHL 0F8B 03 SUB 0F8C 16 AND 0F8D 61 PUSH2 0x0f96 0F90 90 SWAP1 0F91 83 DUP4 0F92 61 PUSH2 0x2575 0F95 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0F6C stack[0] = storage[0x10] // @0F72 memory[0x00:0x20] = msg.sender // @0F77 memory[0x20:0x40] = 0x05 // @0F90 stack[2] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0x40) // @0F90 stack[1] = 0x0f96 // @0F91 stack[3] = stack[-1] // } // Block ends with call to 0x2575, returns to 0x0F96 label_0F96: // Incoming return from call to 0x2575 at 0x0F95 // Inputs[2] // { // @0F97 stack[-1] // @0F97 stack[-2] // } 0F96 5B JUMPDEST 0F97 11 GT 0F98 15 ISZERO 0F99 61 PUSH2 0x0fde 0F9C 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0fde, if !(stack[-1] > stack[-2]) label_0F9D: // Incoming jump from 0x0F9C, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0F9F memory[0x40:0x60] } 0F9D 60 PUSH1 0x40 0F9F 51 MLOAD 0FA0 62 PUSH3 0x461bcd 0FA4 60 PUSH1 0xe5 0FA6 1B SHL 0FA7 81 DUP2 0FA8 52 MSTORE 0FA9 60 PUSH1 0x20 0FAB 60 PUSH1 0x04 0FAD 82 DUP3 0FAE 01 ADD 0FAF 52 MSTORE 0FB0 60 PUSH1 0x17 0FB2 60 PUSH1 0x24 0FB4 82 DUP3 0FB5 01 ADD 0FB6 52 MSTORE 0FB7 76 PUSH23 0x115e18d959591cc81b585e081b5a5b9d08185b5bdd5b9d 0FCF 60 PUSH1 0x4a 0FD1 1B SHL 0FD2 60 PUSH1 0x44 0FD4 82 DUP3 0FD5 01 ADD 0FD6 52 MSTORE 0FD7 60 PUSH1 0x64 0FD9 01 ADD 0FDA 61 PUSH2 0x0835 0FDD 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0FA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FAF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0FB6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x17 // @0FD6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x115e18d959591cc81b585e081b5a5b9d08185b5bdd5b9d << 0x4a // @0FD9 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0835 label_0FDE: // Incoming jump from 0x0F9C, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @0FDF stack[-1] // @0FE2 storage[0x0d] // } 0FDE 5B JUMPDEST 0FDF 80 DUP1 0FE0 60 PUSH1 0x0d 0FE2 54 SLOAD 0FE3 61 PUSH2 0x0fec 0FE6 91 SWAP2 0FE7 90 SWAP1 0FE8 61 PUSH2 0x25a1 0FEB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FE6 stack[0] = 0x0fec // @0FE7 stack[1] = stack[-1] // @0FE7 stack[2] = storage[0x0d] // } // Block ends with call to 0x25a1, returns to 0x0FEC label_0FEC: // Incoming return from call to 0x25A1 at 0x0FEB // Inputs[2] // { // @0FED msg.value // @0FEE stack[-1] // } 0FEC 5B JUMPDEST 0FED 34 CALLVALUE 0FEE 10 LT 0FEF 15 ISZERO 0FF0 61 PUSH2 0x0ff8 0FF3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ff8, if !(msg.value < stack[-1]) label_0FF4: // Incoming jump from 0x0FF3, if not !(msg.value < stack[-1]) // Inputs[1] { @0FF7 memory[0x00:0x00] } 0FF4 60 PUSH1 0x00 0FF6 80 DUP1 0FF7 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FF7 revert(memory[0x00:0x00]); } // Block terminates label_0FF8: // Incoming jump from 0x0F69, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Incoming jump from 0x0FF3, if !(msg.value < stack[-1]) // Inputs[2] // { // @0FFC msg.sender // @0FFD stack[-1] // } 0FF8 5B JUMPDEST 0FF9 61 PUSH2 0x1002 0FFC 33 CALLER 0FFD 82 DUP3 0FFE 61 PUSH2 0x1b64 1001 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FF9 stack[0] = 0x1002 // @0FFC stack[1] = msg.sender // @0FFD stack[2] = stack[-1] // } // Block ends with call to 0x1b64, returns to 0x1002 label_1002: // Incoming return from call to 0x1B64 at 0x1001 // Inputs[2] // { // @1005 memory[0x40:0x60] // @1006 stack[-1] // } 1002 5B JUMPDEST 1003 60 PUSH1 0x40 1005 51 MLOAD 1006 81 DUP2 1007 81 DUP2 1008 52 MSTORE 1009 7F PUSH32 0x9031977345c66c78aecb300307e08dbf054962392ef18f89c9f88c9cc6c6cff1 102A 90 SWAP1 102B 60 PUSH1 0x20 102D 01 ADD 102E 61 PUSH2 0x087b 1031 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1008 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @102A stack[0] = 0x9031977345c66c78aecb300307e08dbf054962392ef18f89c9f88c9cc6c6cff1 // @102D stack[1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x087b label_1032: // Incoming jump from 0x060B // Inputs[2] // { // @103B stack[-2] // @103D msg.sender // } 1032 5B JUMPDEST 1033 60 PUSH1 0x01 1035 60 PUSH1 0x01 1037 60 PUSH1 0xa0 1039 1B SHL 103A 03 SUB 103B 82 DUP3 103C 16 AND 103D 33 CALLER 103E 14 EQ 103F 15 ISZERO 1040 61 PUSH2 0x105c 1043 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x105c, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) label_1044: // Incoming jump from 0x1043, if not !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @1046 memory[0x40:0x60] // @1056 memory[0x40:0x60] // @105B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1044 60 PUSH1 0x40 1046 51 MLOAD 1047 63 PUSH4 0xb06307db 104C 60 PUSH1 0xe0 104E 1B SHL 104F 81 DUP2 1050 52 MSTORE 1051 60 PUSH1 0x04 1053 01 ADD 1054 60 PUSH1 0x40 1056 51 MLOAD 1057 80 DUP1 1058 91 SWAP2 1059 03 SUB 105A 90 SWAP1 105B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1050 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb06307db << 0xe0 // @105B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_105C: // Incoming jump from 0x1043, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[10] // { // @105D msg.sender // @106E memory[0x00:0x40] // @1077 stack[-2] // @1082 memory[0x00:0x40] // @1084 storage[keccak256(memory[0x00:0x40])] // @1089 stack[-1] // @1093 memory[0x40:0x60] // @10BF memory[0x40:0x60] // @10C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @10C7 stack[-3] // } 105C 5B JUMPDEST 105D 33 CALLER 105E 60 PUSH1 0x00 1060 81 DUP2 1061 81 DUP2 1062 52 MSTORE 1063 60 PUSH1 0x07 1065 60 PUSH1 0x20 1067 90 SWAP1 1068 81 DUP2 1069 52 MSTORE 106A 60 PUSH1 0x40 106C 80 DUP1 106D 83 DUP4 106E 20 SHA3 106F 60 PUSH1 0x01 1071 60 PUSH1 0x01 1073 60 PUSH1 0xa0 1075 1B SHL 1076 03 SUB 1077 87 DUP8 1078 16 AND 1079 80 DUP1 107A 85 DUP6 107B 52 MSTORE 107C 90 SWAP1 107D 83 DUP4 107E 52 MSTORE 107F 92 SWAP3 1080 81 DUP2 1081 90 SWAP1 1082 20 SHA3 1083 80 DUP1 1084 54 SLOAD 1085 60 PUSH1 0xff 1087 19 NOT 1088 16 AND 1089 86 DUP7 108A 15 ISZERO 108B 15 ISZERO 108C 90 SWAP1 108D 81 DUP2 108E 17 OR 108F 90 SWAP1 1090 91 SWAP2 1091 55 SSTORE 1092 90 SWAP1 1093 51 MLOAD 1094 90 SWAP1 1095 81 DUP2 1096 52 MSTORE 1097 91 SWAP2 1098 92 SWAP3 1099 91 SWAP2 109A 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 10BB 91 SWAP2 10BC 01 ADD 10BD 60 PUSH1 0x40 10BF 51 MLOAD 10C0 80 DUP1 10C1 91 SWAP2 10C2 03 SUB 10C3 90 SWAP1 10C4 A3 LOG3 10C5 50 POP 10C6 50 POP 10C7 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @1062 memory[0x00:0x20] = msg.sender // @1069 memory[0x20:0x40] = 0x07 // @107B memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @107E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1091 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1096 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @10C4 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-3] label_10C8: // Incoming jump from 0x061E // Inputs[1] { @10CB storage[0x12] } 10C8 5B JUMPDEST 10C9 60 PUSH1 0x12 10CB 54 SLOAD 10CC 60 PUSH1 0xff 10CE 16 AND 10CF 15 ISZERO 10D0 61 PUSH2 0x1129 10D3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1129, if !(0xff & storage[0x12]) label_10D4: // Incoming jump from 0x10D3, if not !(0xff & storage[0x12]) // Inputs[1] { @10D6 memory[0x40:0x60] } 10D4 60 PUSH1 0x40 10D6 51 MLOAD 10D7 62 PUSH3 0x461bcd 10DB 60 PUSH1 0xe5 10DD 1B SHL 10DE 81 DUP2 10DF 52 MSTORE 10E0 60 PUSH1 0x20 10E2 60 PUSH1 0x04 10E4 82 DUP3 10E5 01 ADD 10E6 52 MSTORE 10E7 60 PUSH1 0x25 10E9 60 PUSH1 0x24 10EB 82 DUP3 10EC 01 ADD 10ED 52 MSTORE 10EE 7F PUSH32 0x43616e6e6f74206d696e74207768696c652077686974656c6973742069732070 110F 60 PUSH1 0x44 1111 82 DUP3 1112 01 ADD 1113 52 MSTORE 1114 64 PUSH5 0x185d5cd959 111A 60 PUSH1 0xda 111C 1B SHL 111D 60 PUSH1 0x64 111F 82 DUP3 1120 01 ADD 1121 52 MSTORE 1122 60 PUSH1 0x84 1124 01 ADD 1125 61 PUSH2 0x0835 1128 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @10DF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10E6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10ED memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @1113 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616e6e6f74206d696e74207768696c652077686974656c6973742069732070 // @1121 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x185d5cd959 << 0xda // @1124 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0835 label_1129: // Incoming jump from 0x10D3, if !(0xff & storage[0x12]) // Inputs[1] { @112C stack[-1] } 1129 5B JUMPDEST 112A 60 PUSH1 0x00 112C 81 DUP2 112D 11 GT 112E 61 PUSH2 0x1136 1131 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1136, if stack[-1] > 0x00 label_1132: // Incoming jump from 0x1131, if not stack[-1] > 0x00 // Inputs[1] { @1135 memory[0x00:0x00] } 1132 60 PUSH1 0x00 1134 80 DUP1 1135 FD *REVERT // Stack delta = +0 // Outputs[1] { @1135 revert(memory[0x00:0x00]); } // Block terminates label_1136: // Incoming jump from 0x1131, if stack[-1] > 0x00 // Inputs[4] // { // @1139 storage[0x0f] // @113A stack[-1] // @1140 storage[0x01] // @1143 storage[0x00] // } 1136 5B JUMPDEST 1137 60 PUSH1 0x0f 1139 54 SLOAD 113A 81 DUP2 113B 61 PUSH2 0x1147 113E 60 PUSH1 0x01 1140 54 SLOAD 1141 60 PUSH1 0x00 1143 54 SLOAD 1144 03 SUB 1145 90 SWAP1 1146 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1139 stack[0] = storage[0x0f] // @113A stack[1] = stack[-1] // @1145 stack[2] = storage[0x00] - storage[0x01] // } // Block ends with unconditional jump to 0x1147 label_1147: // Incoming jump from 0x1146 // Inputs[2] // { // @114B stack[-2] // @114C stack[-1] // } 1147 5B JUMPDEST 1148 61 PUSH2 0x1151 114B 91 SWAP2 114C 90 SWAP1 114D 61 PUSH2 0x2575 1150 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @114B stack[-2] = 0x1151 // @114C stack[-1] = stack[-2] // @114C stack[0] = stack[-1] // } // Block ends with call to 0x2575, returns to 0x1151 label_1151: // Incoming return from call to 0x2575 at 0x1150 // Inputs[2] // { // @1152 stack[-2] // @1152 stack[-1] // } 1151 5B JUMPDEST 1152 11 GT 1153 15 ISZERO 1154 61 PUSH2 0x115c 1157 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x115c, if !(stack[-1] > stack[-2]) label_1158: // Incoming jump from 0x1157, if not !(stack[-1] > stack[-2]) // Inputs[1] { @115B memory[0x00:0x00] } 1158 60 PUSH1 0x00 115A 80 DUP1 115B FD *REVERT // Stack delta = +0 // Outputs[1] { @115B revert(memory[0x00:0x00]); } // Block terminates label_115C: // Incoming jump from 0x1157, if !(stack[-1] > stack[-2]) // Inputs[3] // { // @115D msg.sender // @116B memory[0x00:0x40] // @116C storage[keccak256(memory[0x00:0x40])] // } 115C 5B JUMPDEST 115D 33 CALLER 115E 60 PUSH1 0x00 1160 90 SWAP1 1161 81 DUP2 1162 52 MSTORE 1163 60 PUSH1 0x14 1165 60 PUSH1 0x20 1167 52 MSTORE 1168 60 PUSH1 0x40 116A 90 SWAP1 116B 20 SHA3 116C 54 SLOAD 116D 60 PUSH1 0xff 116F 16 AND 1170 15 ISZERO 1171 61 PUSH2 0x11cb 1174 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1162 memory[0x00:0x20] = msg.sender // @1167 memory[0x20:0x40] = 0x14 // } // Block ends with conditional jump to 0x11cb, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_1175: // Incoming jump from 0x1174, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @1177 memory[0x40:0x60] } 1175 60 PUSH1 0x40 1177 51 MLOAD 1178 62 PUSH3 0x461bcd 117C 60 PUSH1 0xe5 117E 1B SHL 117F 81 DUP2 1180 52 MSTORE 1181 60 PUSH1 0x20 1183 60 PUSH1 0x04 1185 82 DUP3 1186 01 ADD 1187 52 MSTORE 1188 60 PUSH1 0x26 118A 60 PUSH1 0x24 118C 82 DUP3 118D 01 ADD 118E 52 MSTORE 118F 7F PUSH32 0x416464726573732068617320616c726561647920636c61696d65642077686974 11B0 60 PUSH1 0x44 11B2 82 DUP3 11B3 01 ADD 11B4 52 MSTORE 11B5 65 PUSH6 0x656c69737421 11BC 60 PUSH1 0xd0 11BE 1B SHL 11BF 60 PUSH1 0x64 11C1 82 DUP3 11C2 01 ADD 11C3 52 MSTORE 11C4 60 PUSH1 0x84 11C6 01 ADD 11C7 61 PUSH2 0x0835 11CA 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1180 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1187 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @118E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @11B4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416464726573732068617320616c726561647920636c61696d65642077686974 // @11C3 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x656c69737421 << 0xd0 // @11C6 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0835 label_11CB: // Incoming jump from 0x1174, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @11CE storage[0x08] // @11D8 msg.sender // } 11CB 5B JUMPDEST 11CC 60 PUSH1 0x08 11CE 54 SLOAD 11CF 60 PUSH1 0x01 11D1 60 PUSH1 0x01 11D3 60 PUSH1 0xa0 11D5 1B SHL 11D6 03 SUB 11D7 16 AND 11D8 33 CALLER 11D9 14 EQ 11DA 61 PUSH2 0x133e 11DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x133e, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_11DE: // Incoming jump from 0x11DD, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[5] // { // @11E0 storage[0x10] // @11E1 msg.sender // @11EF memory[0x00:0x40] // @11F0 storage[keccak256(memory[0x00:0x40])] // @1205 stack[-1] // } 11DE 60 PUSH1 0x10 11E0 54 SLOAD 11E1 33 CALLER 11E2 60 PUSH1 0x00 11E4 90 SWAP1 11E5 81 DUP2 11E6 52 MSTORE 11E7 60 PUSH1 0x05 11E9 60 PUSH1 0x20 11EB 52 MSTORE 11EC 60 PUSH1 0x40 11EE 90 SWAP1 11EF 20 SHA3 11F0 54 SLOAD 11F1 60 PUSH1 0x01 11F3 60 PUSH1 0x40 11F5 1B SHL 11F6 90 SWAP1 11F7 04 DIV 11F8 60 PUSH1 0x01 11FA 60 PUSH1 0x01 11FC 60 PUSH1 0x40 11FE 1B SHL 11FF 03 SUB 1200 16 AND 1201 61 PUSH2 0x120a 1204 90 SWAP1 1205 83 DUP4 1206 61 PUSH2 0x2575 1209 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @11E0 stack[0] = storage[0x10] // @11E6 memory[0x00:0x20] = msg.sender // @11EB memory[0x20:0x40] = 0x05 // @1204 stack[2] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0x40) // @1204 stack[1] = 0x120a // @1205 stack[3] = stack[-1] // } // Block ends with call to 0x2575, returns to 0x120A label_120A: // Incoming return from call to 0x2575 at 0x1209 // Inputs[2] // { // @120B stack[-2] // @120B stack[-1] // } 120A 5B JUMPDEST 120B 11 GT 120C 15 ISZERO 120D 61 PUSH2 0x1252 1210 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1252, if !(stack[-1] > stack[-2]) label_1211: // Incoming jump from 0x1210, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1213 memory[0x40:0x60] } 1211 60 PUSH1 0x40 1213 51 MLOAD 1214 62 PUSH3 0x461bcd 1218 60 PUSH1 0xe5 121A 1B SHL 121B 81 DUP2 121C 52 MSTORE 121D 60 PUSH1 0x20 121F 60 PUSH1 0x04 1221 82 DUP3 1222 01 ADD 1223 52 MSTORE 1224 60 PUSH1 0x17 1226 60 PUSH1 0x24 1228 82 DUP3 1229 01 ADD 122A 52 MSTORE 122B 76 PUSH23 0x115e18d959591cc81b585e081b5a5b9d08185b5bdd5b9d 1243 60 PUSH1 0x4a 1245 1B SHL 1246 60 PUSH1 0x44 1248 82 DUP3 1249 01 ADD 124A 52 MSTORE 124B 60 PUSH1 0x64 124D 01 ADD 124E 61 PUSH2 0x0835 1251 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @121C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1223 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @122A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x17 // @124A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x115e18d959591cc81b585e081b5a5b9d08185b5bdd5b9d << 0x4a // @124D stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0835 label_1252: // Incoming jump from 0x1210, if !(stack[-1] > stack[-2]) // Inputs[10] // { // @1255 memory[0x40:0x60] // @1264 msg.sender // @1276 memory[0x40:0x60] // @1284 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1289 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @128F stack[-3] // @1290 stack[-2] // @129B memory[0x40:0x60] // @12B5 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @12C2 storage[0x13] // } 1252 5B JUMPDEST 1253 60 PUSH1 0x40 1255 51 MLOAD 1256 6B PUSH12 0xffffffffffffffffffffffff 1263 19 NOT 1264 33 CALLER 1265 60 PUSH1 0x60 1267 1B SHL 1268 16 AND 1269 60 PUSH1 0x20 126B 82 DUP3 126C 01 ADD 126D 52 MSTORE 126E 60 PUSH1 0x00 1270 90 SWAP1 1271 60 PUSH1 0x34 1273 01 ADD 1274 60 PUSH1 0x40 1276 51 MLOAD 1277 60 PUSH1 0x20 1279 81 DUP2 127A 83 DUP4 127B 03 SUB 127C 03 SUB 127D 81 DUP2 127E 52 MSTORE 127F 90 SWAP1 1280 60 PUSH1 0x40 1282 52 MSTORE 1283 80 DUP1 1284 51 MLOAD 1285 90 SWAP1 1286 60 PUSH1 0x20 1288 01 ADD 1289 20 SHA3 128A 90 SWAP1 128B 50 POP 128C 61 PUSH2 0x12cc 128F 84 DUP5 1290 84 DUP5 1291 80 DUP1 1292 80 DUP1 1293 60 PUSH1 0x20 1295 02 MUL 1296 60 PUSH1 0x20 1298 01 ADD 1299 60 PUSH1 0x40 129B 51 MLOAD 129C 90 SWAP1 129D 81 DUP2 129E 01 ADD 129F 60 PUSH1 0x40 12A1 52 MSTORE 12A2 80 DUP1 12A3 93 SWAP4 12A4 92 SWAP3 12A5 91 SWAP2 12A6 90 SWAP1 12A7 81 DUP2 12A8 81 DUP2 12A9 52 MSTORE 12AA 60 PUSH1 0x20 12AC 01 ADD 12AD 83 DUP4 12AE 83 DUP4 12AF 60 PUSH1 0x20 12B1 02 MUL 12B2 80 DUP1 12B3 82 DUP3 12B4 84 DUP5 12B5 37 CALLDATACOPY 12B6 60 PUSH1 0x00 12B8 92 SWAP3 12B9 01 ADD 12BA 91 SWAP2 12BB 90 SWAP1 12BC 91 SWAP2 12BD 52 MSTORE 12BE 50 POP 12BF 50 POP 12C0 60 PUSH1 0x13 12C2 54 SLOAD 12C3 91 SWAP2 12C4 50 POP 12C5 84 DUP5 12C6 90 SWAP1 12C7 50 POP 12C8 61 PUSH2 0x1b82 12CB 56 *JUMP // Stack delta = +5 // Outputs[12] // { // @126D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (msg.sender << 0x60) & ~0xffffffffffffffffffffffff // @127E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x34 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @1282 memory[0x40:0x60] = 0x34 + memory[0x40:0x60] // @128A stack[0] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @128C stack[1] = 0x12cc // @12A1 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @12A3 stack[2] = memory[0x40:0x60] // @12A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @12B5 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @12BD memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @12C3 stack[3] = storage[0x13] // @12C6 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 0x1b82, returns to 0x12CC label_12CC: // Incoming return from call to 0x1B82 at 0x12CB // Inputs[1] { @12D0 stack[-1] } 12CC 5B JUMPDEST 12CD 61 PUSH2 0x1308 12D0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1308, if stack[-1] label_12D1: // Incoming jump from 0x12D0, if not stack[-1] // Inputs[1] { @12D3 memory[0x40:0x60] } 12D1 60 PUSH1 0x40 12D3 51 MLOAD 12D4 62 PUSH3 0x461bcd 12D8 60 PUSH1 0xe5 12DA 1B SHL 12DB 81 DUP2 12DC 52 MSTORE 12DD 60 PUSH1 0x20 12DF 60 PUSH1 0x04 12E1 82 DUP3 12E2 01 ADD 12E3 52 MSTORE 12E4 60 PUSH1 0x0d 12E6 60 PUSH1 0x24 12E8 82 DUP3 12E9 01 ADD 12EA 52 MSTORE 12EB 6C PUSH13 0x24b73b30b634b210383937b7b3 12F9 60 PUSH1 0x99 12FB 1B SHL 12FC 60 PUSH1 0x44 12FE 82 DUP3 12FF 01 ADD 1300 52 MSTORE 1301 60 PUSH1 0x64 1303 01 ADD 1304 61 PUSH2 0x0835 1307 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @12DC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12E3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @12EA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0d // @1300 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x24b73b30b634b210383937b7b3 << 0x99 // @1303 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0835 label_1308: // Incoming jump from 0x12D0, if stack[-1] // Inputs[2] // { // @1309 stack[-2] // @130C storage[0x11] // } 1308 5B JUMPDEST 1309 81 DUP2 130A 60 PUSH1 0x11 130C 54 SLOAD 130D 61 PUSH2 0x1316 1310 91 SWAP2 1311 90 SWAP1 1312 61 PUSH2 0x25a1 1315 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1310 stack[0] = 0x1316 // @1311 stack[1] = stack[-2] // @1311 stack[2] = storage[0x11] // } // Block ends with call to 0x25a1, returns to 0x1316 label_1316: // Incoming return from call to 0x25A1 at 0x1315 // Inputs[2] // { // @1317 msg.value // @1318 stack[-1] // } 1316 5B JUMPDEST 1317 34 CALLVALUE 1318 10 LT 1319 15 ISZERO 131A 61 PUSH2 0x1322 131D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1322, if !(msg.value < stack[-1]) label_131E: // Incoming jump from 0x131D, if not !(msg.value < stack[-1]) // Inputs[1] { @1321 memory[0x00:0x00] } 131E 60 PUSH1 0x00 1320 80 DUP1 1321 FD *REVERT // Stack delta = +0 // Outputs[1] { @1321 revert(memory[0x00:0x00]); } // Block terminates label_1322: // Incoming jump from 0x131D, if !(msg.value < stack[-1]) // Inputs[3] // { // @1324 msg.sender // @1332 memory[0x00:0x40] // @1334 storage[keccak256(memory[0x00:0x40])] // } 1322 5B JUMPDEST 1323 50 POP 1324 33 CALLER 1325 60 PUSH1 0x00 1327 90 SWAP1 1328 81 DUP2 1329 52 MSTORE 132A 60 PUSH1 0x14 132C 60 PUSH1 0x20 132E 52 MSTORE 132F 60 PUSH1 0x40 1331 90 SWAP1 1332 20 SHA3 1333 80 DUP1 1334 54 SLOAD 1335 60 PUSH1 0xff 1337 19 NOT 1338 16 AND 1339 60 PUSH1 0x01 133B 17 OR 133C 90 SWAP1 133D 55 SSTORE // Stack delta = -1 // Outputs[3] // { // @1329 memory[0x00:0x20] = msg.sender // @132E memory[0x20:0x40] = 0x14 // @133D storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // } // Block continues label_133E: // Incoming jump from 0x11DD, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Incoming jump from 0x133D // Inputs[2] // { // @1342 msg.sender // @1343 stack[-1] // } 133E 5B JUMPDEST 133F 61 PUSH2 0x1348 1342 33 CALLER 1343 82 DUP3 1344 61 PUSH2 0x1b64 1347 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @133F stack[0] = 0x1348 // @1342 stack[1] = msg.sender // @1343 stack[2] = stack[-1] // } // Block ends with call to 0x1b64, returns to 0x1348 label_1348: // Incoming return from call to 0x1B64 at 0x1347 // Inputs[4] // { // @136A stack[-3] // @136B stack[-2] // @136C stack[-1] // @136F memory[0x40:0x60] // } 1348 5B JUMPDEST 1349 7F PUSH32 0x47a9c0a8ed1b7177348fb273591983301b2e05e8a60dc203a381b7c675ec347e 136A 83 DUP4 136B 83 DUP4 136C 83 DUP4 136D 60 PUSH1 0x40 136F 51 MLOAD 1370 61 PUSH2 0x137b 1373 93 SWAP4 1374 92 SWAP3 1375 91 SWAP2 1376 90 SWAP1 1377 61 PUSH2 0x24ec 137A 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1349 stack[0] = 0x47a9c0a8ed1b7177348fb273591983301b2e05e8a60dc203a381b7c675ec347e // @1373 stack[1] = 0x137b // @1374 stack[2] = stack[-3] // @1375 stack[3] = stack[-2] // @1376 stack[4] = stack[-1] // @1376 stack[5] = memory[0x40:0x60] // } // Block ends with call to 0x24ec, returns to 0x137B label_137B: // Incoming return from call to 0x24EC at 0x137A // Inputs[5] // { // @137E memory[0x40:0x60] // @1380 stack[-1] // @1383 stack[-2] // @1383 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @1387 stack[-6] // } 137B 5B JUMPDEST 137C 60 PUSH1 0x40 137E 51 MLOAD 137F 80 DUP1 1380 91 SWAP2 1381 03 SUB 1382 90 SWAP1 1383 A1 LOG1 1384 50 POP 1385 50 POP 1386 50 POP 1387 56 *JUMP // Stack delta = -6 // Outputs[1] { @1383 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2]]); } // Block ends with unconditional jump to stack[-6] label_1388: // Incoming jump from 0x063E // Incoming jump from 0x0C2A // Inputs[3] // { // @138C stack[-4] // @138D stack[-3] // @138E stack[-2] // } 1388 5B JUMPDEST 1389 61 PUSH2 0x1393 138C 84 DUP5 138D 84 DUP5 138E 84 DUP5 138F 61 PUSH2 0x180a 1392 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1389 stack[0] = 0x1393 // @138C stack[1] = stack[-4] // @138D stack[2] = stack[-3] // @138E stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x180a 1393 5B JUMPDEST 1394 60 PUSH1 0x01 1396 60 PUSH1 0x01 1398 60 PUSH1 0xa0 139A 1B SHL 139B 03 SUB 139C 83 DUP4 139D 16 AND 139E 3B EXTCODESIZE 139F 15 ISZERO 13A0 15 ISZERO 13A1 80 DUP1 13A2 15 ISZERO 13A3 61 PUSH2 0x13b5 13A6 57 *JUMPI 13A7 50 POP 13A8 61 PUSH2 0x13b3 13AB 84 DUP5 13AC 84 DUP5 13AD 84 DUP5 13AE 84 DUP5 13AF 61 PUSH2 0x1b98 13B2 56 *JUMP 13B3 5B JUMPDEST 13B4 15 ISZERO 13B5 5B JUMPDEST 13B6 15 ISZERO 13B7 61 PUSH2 0x13d3 13BA 57 *JUMPI 13BB 60 PUSH1 0x40 13BD 51 MLOAD 13BE 63 PUSH4 0x68d2bf6b 13C3 60 PUSH1 0xe1 13C5 1B SHL 13C6 81 DUP2 13C7 52 MSTORE 13C8 60 PUSH1 0x04 13CA 01 ADD 13CB 60 PUSH1 0x40 13CD 51 MLOAD 13CE 80 DUP1 13CF 91 SWAP2 13D0 03 SUB 13D1 90 SWAP1 13D2 FD *REVERT label_13D3: // Incoming jump from 0x25FA, if !(stack[-1] > stack[-4]) // Inputs[1] { @13D8 stack[-5] } 13D3 5B JUMPDEST 13D4 50 POP 13D5 50 POP 13D6 50 POP 13D7 50 POP 13D8 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_13D9: // Incoming call from 0x0653, returns to 0x02D8 // Inputs[1] { @13DD storage[0x0c] } 13D9 5B JUMPDEST 13DA 60 PUSH1 0x0c 13DC 80 DUP1 13DD 54 SLOAD 13DE 61 PUSH2 0x0969 13E1 90 SWAP1 13E2 61 PUSH2 0x2603 13E5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @13DA stack[0] = 0x0c // @13E1 stack[1] = 0x0969 // @13E1 stack[2] = storage[0x0c] // } // Block ends with call to 0x2603, returns to 0x0969 label_13E6: // Incoming jump from 0x0673 // Inputs[1] { @13EC stack[-1] } 13E6 5B JUMPDEST 13E7 60 PUSH1 0x60 13E9 61 PUSH2 0x13f1 13EC 82 DUP3 13ED 61 PUSH2 0x1783 13F0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @13E7 stack[0] = 0x60 // @13E9 stack[1] = 0x13f1 // @13EC stack[2] = stack[-1] // } // Block ends with call to 0x1783, returns to 0x13F1 label_13F1: // Incoming return from call to 0x1783 at 0x13F0 // Inputs[1] { @13F5 stack[-1] } 13F1 5B JUMPDEST 13F2 61 PUSH2 0x1455 13F5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1455, if stack[-1] label_13F6: // Incoming jump from 0x13F5, if not stack[-1] // Inputs[1] { @13F8 memory[0x40:0x60] } 13F6 60 PUSH1 0x40 13F8 51 MLOAD 13F9 62 PUSH3 0x461bcd 13FD 60 PUSH1 0xe5 13FF 1B SHL 1400 81 DUP2 1401 52 MSTORE 1402 60 PUSH1 0x20 1404 60 PUSH1 0x04 1406 82 DUP3 1407 01 ADD 1408 52 MSTORE 1409 60 PUSH1 0x2f 140B 60 PUSH1 0x24 140D 82 DUP3 140E 01 ADD 140F 52 MSTORE 1410 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 1431 60 PUSH1 0x44 1433 82 DUP3 1434 01 ADD 1435 52 MSTORE 1436 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 1446 60 PUSH1 0x89 1448 1B SHL 1449 60 PUSH1 0x64 144B 82 DUP3 144C 01 ADD 144D 52 MSTORE 144E 60 PUSH1 0x84 1450 01 ADD 1451 61 PUSH2 0x0835 1454 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1401 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1408 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @140F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @1435 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @144D memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3732bc34b9ba32b73a103a37b5b2b7 << 0x89 // @1450 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0835 label_1455: // Incoming jump from 0x13F5, if stack[-1] // Inputs[1] { @1458 storage[0x15] } 1455 5B JUMPDEST 1456 60 PUSH1 0x15 1458 54 SLOAD 1459 60 PUSH1 0xff 145B 16 AND 145C 61 PUSH2 0x14f1 145F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14f1, if 0xff & storage[0x15] label_1460: // Incoming jump from 0x145F, if not 0xff & storage[0x15] // Inputs[1] { @1463 storage[0x0b] } 1460 60 PUSH1 0x0b 1462 80 DUP1 1463 54 SLOAD 1464 61 PUSH2 0x146c 1467 90 SWAP1 1468 61 PUSH2 0x2603 146B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1460 stack[0] = 0x0b // @1467 stack[1] = 0x146c // @1467 stack[2] = storage[0x0b] // } // Block ends with call to 0x2603, returns to 0x146C label_146C: // Incoming return from call to 0x2603 at 0x146B // Inputs[4] // { // @146D stack[-1] // @147C memory[0x40:0x60] // @1484 stack[-2] // @148F storage[stack[-2]] // } 146C 5B JUMPDEST 146D 80 DUP1 146E 60 PUSH1 0x1f 1470 01 ADD 1471 60 PUSH1 0x20 1473 80 DUP1 1474 91 SWAP2 1475 04 DIV 1476 02 MUL 1477 60 PUSH1 0x20 1479 01 ADD 147A 60 PUSH1 0x40 147C 51 MLOAD 147D 90 SWAP1 147E 81 DUP2 147F 01 ADD 1480 60 PUSH1 0x40 1482 52 MSTORE 1483 80 DUP1 1484 92 SWAP3 1485 91 SWAP2 1486 90 SWAP1 1487 81 DUP2 1488 81 DUP2 1489 52 MSTORE 148A 60 PUSH1 0x20 148C 01 ADD 148D 82 DUP3 148E 80 DUP1 148F 54 SLOAD 1490 61 PUSH2 0x1498 1493 90 SWAP1 1494 61 PUSH2 0x2603 1497 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @1482 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @1484 stack[-2] = memory[0x40:0x60] // @1485 stack[-1] = stack[-2] // @1486 stack[0] = stack[-1] // @1489 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @148C stack[1] = 0x20 + memory[0x40:0x60] // @148D stack[2] = stack[-2] // @1493 stack[4] = storage[stack[-2]] // @1493 stack[3] = 0x1498 // } // Block ends with call to 0x2603, returns to 0x1498 label_1498: // Incoming return from call to 0x2603 at 0x1497 // Inputs[1] { @1499 stack[-1] } 1498 5B JUMPDEST 1499 80 DUP1 149A 15 ISZERO 149B 61 PUSH2 0x14e5 149E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14e5, if !stack[-1] label_149F: // Incoming jump from 0x149E, if not !stack[-1] // Inputs[1] { @149F stack[-1] } 149F 80 DUP1 14A0 60 PUSH1 0x1f 14A2 10 LT 14A3 61 PUSH2 0x14ba 14A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14ba, if 0x1f < stack[-1] label_14A7: // Incoming jump from 0x14A6, if not 0x1f < stack[-1] // Inputs[4] // { // @14AB stack[-2] // @14AC storage[stack[-2]] // @14AF stack[-3] // @14B1 stack[-1] // } 14A7 61 PUSH2 0x0100 14AA 80 DUP1 14AB 83 DUP4 14AC 54 SLOAD 14AD 04 DIV 14AE 02 MUL 14AF 83 DUP4 14B0 52 MSTORE 14B1 91 SWAP2 14B2 60 PUSH1 0x20 14B4 01 ADD 14B5 91 SWAP2 14B6 61 PUSH2 0x14e5 14B9 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @14B0 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @14B5 stack[-1] = stack[-1] // @14B5 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x14e5 label_14BA: // Incoming jump from 0x14A6, if 0x1f < stack[-1] // Inputs[5] // { // @14BB stack[-3] // @14BC stack[-1] // @14BE stack[-2] // @14C6 memory[0x00:0x20] // @14CA storage[keccak256(memory[0x00:0x20])] // } 14BA 5B JUMPDEST 14BB 82 DUP3 14BC 01 ADD 14BD 91 SWAP2 14BE 90 SWAP1 14BF 60 PUSH1 0x00 14C1 52 MSTORE 14C2 60 PUSH1 0x20 14C4 60 PUSH1 0x00 14C6 20 SHA3 14C7 90 SWAP1 14C8 5B JUMPDEST 14C9 81 DUP2 14CA 54 SLOAD 14CB 81 DUP2 14CC 52 MSTORE 14CD 90 SWAP1 14CE 60 PUSH1 0x01 14D0 01 ADD 14D1 90 SWAP1 14D2 60 PUSH1 0x20 14D4 01 ADD 14D5 80 DUP1 14D6 83 DUP4 14D7 11 GT 14D8 61 PUSH2 0x14c8 14DB 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @14BD stack[-3] = stack[-3] + stack[-1] // @14C1 memory[0x00:0x20] = stack[-2] // @14CC memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @14D1 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @14D4 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x14c8, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_14DC: // Incoming jump from 0x14DB, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x14DB, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @14DC stack[-3] // @14DD stack[-1] // } 14DC 82 DUP3 14DD 90 SWAP1 14DE 03 SUB 14DF 60 PUSH1 0x1f 14E1 16 AND 14E2 82 DUP3 14E3 01 ADD 14E4 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @14E4 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @14E4 stack[-1] = stack[-3] // } // Block continues label_14E5: // Incoming jump from 0x14B9 // Incoming jump from 0x14E4 // Incoming jump from 0x149E, if !stack[-1] // Inputs[4] // { // @14EB stack[-7] // @14EB stack[-6] // @14ED stack[-9] // @14EE stack[-8] // } 14E5 5B JUMPDEST 14E6 50 POP 14E7 50 POP 14E8 50 POP 14E9 50 POP 14EA 50 POP 14EB 90 SWAP1 14EC 50 POP 14ED 91 SWAP2 14EE 90 SWAP1 14EF 50 POP 14F0 56 *JUMP // Stack delta = -8 // Outputs[1] { @14ED stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_14F1: // Incoming jump from 0x145F, if 0xff & storage[0x15] 14F1 5B JUMPDEST 14F2 60 PUSH1 0x00 14F4 61 PUSH2 0x14fb 14F7 61 PUSH2 0x1c90 14FA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @14F2 stack[0] = 0x00 // @14F4 stack[1] = 0x14fb // } // Block ends with unconditional jump to 0x1c90 14FB 5B JUMPDEST 14FC 90 SWAP1 14FD 50 POP 14FE 60 PUSH1 0x00 1500 81 DUP2 1501 51 MLOAD 1502 11 GT 1503 61 PUSH2 0x151b 1506 57 *JUMPI 1507 60 PUSH1 0x40 1509 51 MLOAD 150A 80 DUP1 150B 60 PUSH1 0x20 150D 01 ADD 150E 60 PUSH1 0x40 1510 52 MSTORE 1511 80 DUP1 1512 60 PUSH1 0x00 1514 81 DUP2 1515 52 MSTORE 1516 50 POP 1517 61 PUSH2 0x1549 151A 56 *JUMP 151B 5B JUMPDEST 151C 80 DUP1 151D 61 PUSH2 0x1525 1520 84 DUP5 1521 61 PUSH2 0x1c9f 1524 56 *JUMP 1525 5B JUMPDEST 1526 60 PUSH1 0x0c 1528 60 PUSH1 0x40 152A 51 MLOAD 152B 60 PUSH1 0x20 152D 01 ADD 152E 61 PUSH2 0x1539 1531 93 SWAP4 1532 92 SWAP3 1533 91 SWAP2 1534 90 SWAP1 1535 61 PUSH2 0x23ed 1538 56 *JUMP 1539 5B JUMPDEST 153A 60 PUSH1 0x40 153C 51 MLOAD 153D 60 PUSH1 0x20 153F 81 DUP2 1540 83 DUP4 1541 03 SUB 1542 03 SUB 1543 81 DUP2 1544 52 MSTORE 1545 90 SWAP1 1546 60 PUSH1 0x40 1548 52 MSTORE label_1549: // Incoming return from call to 0x2120 at 0x2165 // Incoming return from call to 0x213C at 0x232B // Incoming return from call to 0x26AF at 0x235F // Incoming return from call to 0x26AF at 0x237B // Incoming return from call to 0x23C1 at 0x253F // Inputs[3] // { // @154A stack[-5] // @154A stack[-1] // @154B stack[-4] // } 1549 5B JUMPDEST 154A 93 SWAP4 154B 92 SWAP3 154C 50 POP 154D 50 POP 154E 50 POP 154F 56 *JUMP // Stack delta = -4 // Outputs[1] { @154A stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1550: // Incoming jump from 0x0693 // Inputs[2] // { // @1553 storage[0x08] // @155D msg.sender // } 1550 5B JUMPDEST 1551 60 PUSH1 0x08 1553 54 SLOAD 1554 60 PUSH1 0x01 1556 60 PUSH1 0x01 1558 60 PUSH1 0xa0 155A 1B SHL 155B 03 SUB 155C 16 AND 155D 33 CALLER 155E 14 EQ 155F 61 PUSH2 0x157a 1562 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x157a, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_1563: // Incoming jump from 0x1562, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @1565 memory[0x40:0x60] } 1563 60 PUSH1 0x40 1565 51 MLOAD 1566 62 PUSH3 0x461bcd 156A 60 PUSH1 0xe5 156C 1B SHL 156D 81 DUP2 156E 52 MSTORE 156F 60 PUSH1 0x04 1571 01 ADD 1572 61 PUSH2 0x0835 1575 90 SWAP1 1576 61 PUSH2 0x2540 1579 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @156E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1575 stack[0] = 0x0835 // @1575 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2540, returns to 0x0835 label_157A: // Incoming jump from 0x1562, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @157D stack[-1] // @1582 memory[0x40:0x60] // } 157A 5B JUMPDEST 157B 60 PUSH1 0x11 157D 81 DUP2 157E 90 SWAP1 157F 55 SSTORE 1580 60 PUSH1 0x40 1582 51 MLOAD 1583 81 DUP2 1584 81 DUP2 1585 52 MSTORE 1586 7F PUSH32 0x5ccb0df1801c19d17cf8f5045e08ba452b5aaedec608843c8fc713c8405e00c3 15A7 90 SWAP1 15A8 60 PUSH1 0x20 15AA 01 ADD 15AB 61 PUSH2 0x087b 15AE 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @157F storage[0x11] = stack[-1] // @1585 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @15A7 stack[0] = 0x5ccb0df1801c19d17cf8f5045e08ba452b5aaedec608843c8fc713c8405e00c3 // @15AA stack[1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x087b label_15AF: // Incoming jump from 0x06C9 // Inputs[2] // { // @15B2 storage[0x08] // @15BC msg.sender // } 15AF 5B JUMPDEST 15B0 60 PUSH1 0x08 15B2 54 SLOAD 15B3 60 PUSH1 0x01 15B5 60 PUSH1 0x01 15B7 60 PUSH1 0xa0 15B9 1B SHL 15BA 03 SUB 15BB 16 AND 15BC 33 CALLER 15BD 14 EQ 15BE 61 PUSH2 0x15d9 15C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15d9, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_15C2: // Incoming jump from 0x15C1, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @15C4 memory[0x40:0x60] } 15C2 60 PUSH1 0x40 15C4 51 MLOAD 15C5 62 PUSH3 0x461bcd 15C9 60 PUSH1 0xe5 15CB 1B SHL 15CC 81 DUP2 15CD 52 MSTORE 15CE 60 PUSH1 0x04 15D0 01 ADD 15D1 61 PUSH2 0x0835 15D4 90 SWAP1 15D5 61 PUSH2 0x2540 15D8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @15CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @15D4 stack[0] = 0x0835 // @15D4 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2540, returns to 0x0835 label_15D9: // Incoming jump from 0x15C1, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @15DA stack[-1] // @15DB memory[stack[-1]:stack[-1] + 0x20] // } 15D9 5B JUMPDEST 15DA 80 DUP1 15DB 51 MLOAD 15DC 61 PUSH2 0x15ec 15DF 90 SWAP1 15E0 60 PUSH1 0x0c 15E2 90 SWAP1 15E3 60 PUSH1 0x20 15E5 84 DUP5 15E6 01 ADD 15E7 90 SWAP1 15E8 61 PUSH2 0x2012 15EB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @15DF stack[0] = 0x15ec // @15E2 stack[1] = 0x0c // @15E7 stack[2] = stack[-1] + 0x20 // @15E7 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2012 15EC 5B JUMPDEST 15ED 50 POP 15EE 7F PUSH32 0xbd636f157872a97a1e701d2df5503442cdff3bc35bc4bea76c95e5e53cad0044 160F 81 DUP2 1610 60 PUSH1 0x40 1612 51 MLOAD 1613 61 PUSH2 0x087b 1616 91 SWAP2 1617 90 SWAP1 1618 61 PUSH2 0x252d 161B 56 *JUMP label_161C: // Incoming jump from 0x0778 // Inputs[2] // { // @161F storage[0x08] // @1629 msg.sender // } 161C 5B JUMPDEST 161D 60 PUSH1 0x08 161F 54 SLOAD 1620 60 PUSH1 0x01 1622 60 PUSH1 0x01 1624 60 PUSH1 0xa0 1626 1B SHL 1627 03 SUB 1628 16 AND 1629 33 CALLER 162A 14 EQ 162B 61 PUSH2 0x1646 162E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1646, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_162F: // Incoming jump from 0x162E, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @1631 memory[0x40:0x60] } 162F 60 PUSH1 0x40 1631 51 MLOAD 1632 62 PUSH3 0x461bcd 1636 60 PUSH1 0xe5 1638 1B SHL 1639 81 DUP2 163A 52 MSTORE 163B 60 PUSH1 0x04 163D 01 ADD 163E 61 PUSH2 0x0835 1641 90 SWAP1 1642 61 PUSH2 0x2540 1645 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @163A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1641 stack[0] = 0x0835 // @1641 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2540, returns to 0x0835 label_1646: // Incoming jump from 0x162E, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @1647 stack[-1] // @1648 memory[stack[-1]:stack[-1] + 0x20] // } 1646 5B JUMPDEST 1647 80 DUP1 1648 51 MLOAD 1649 61 PUSH2 0x1659 164C 90 SWAP1 164D 60 PUSH1 0x0b 164F 90 SWAP1 1650 60 PUSH1 0x20 1652 84 DUP5 1653 01 ADD 1654 90 SWAP1 1655 61 PUSH2 0x2012 1658 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @164C stack[0] = 0x1659 // @164F stack[1] = 0x0b // @1654 stack[2] = stack[-1] + 0x20 // @1654 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2012 1659 5B JUMPDEST 165A 50 POP 165B 7F PUSH32 0xcd77469b86bd5e6ccb68fdbdd51d21940e64ca5b5241ab0f9c56bcef4f397377 167C 81 DUP2 167D 60 PUSH1 0x40 167F 51 MLOAD 1680 61 PUSH2 0x087b 1683 91 SWAP2 1684 90 SWAP1 1685 61 PUSH2 0x252d 1688 56 *JUMP label_1689: // Incoming jump from 0x0798 // Inputs[2] // { // @168C storage[0x08] // @1696 msg.sender // } 1689 5B JUMPDEST 168A 60 PUSH1 0x08 168C 54 SLOAD 168D 60 PUSH1 0x01 168F 60 PUSH1 0x01 1691 60 PUSH1 0xa0 1693 1B SHL 1694 03 SUB 1695 16 AND 1696 33 CALLER 1697 14 EQ 1698 61 PUSH2 0x16b3 169B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x16b3, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_169C: // Incoming jump from 0x169B, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @169E memory[0x40:0x60] } 169C 60 PUSH1 0x40 169E 51 MLOAD 169F 62 PUSH3 0x461bcd 16A3 60 PUSH1 0xe5 16A5 1B SHL 16A6 81 DUP2 16A7 52 MSTORE 16A8 60 PUSH1 0x04 16AA 01 ADD 16AB 61 PUSH2 0x0835 16AE 90 SWAP1 16AF 61 PUSH2 0x2540 16B2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @16A7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @16AE stack[0] = 0x0835 // @16AE stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2540, returns to 0x0835 label_16B3: // Incoming jump from 0x169B, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @16BC stack[-1] } 16B3 5B JUMPDEST 16B4 60 PUSH1 0x01 16B6 60 PUSH1 0x01 16B8 60 PUSH1 0xa0 16BA 1B SHL 16BB 03 SUB 16BC 81 DUP2 16BD 16 AND 16BE 61 PUSH2 0x1718 16C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1718, if stack[-1] & (0x01 << 0xa0) - 0x01 label_16C2: // Incoming jump from 0x16C1, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @16C4 memory[0x40:0x60] } 16C2 60 PUSH1 0x40 16C4 51 MLOAD 16C5 62 PUSH3 0x461bcd 16C9 60 PUSH1 0xe5 16CB 1B SHL 16CC 81 DUP2 16CD 52 MSTORE 16CE 60 PUSH1 0x20 16D0 60 PUSH1 0x04 16D2 82 DUP3 16D3 01 ADD 16D4 52 MSTORE 16D5 60 PUSH1 0x26 16D7 60 PUSH1 0x24 16D9 82 DUP3 16DA 01 ADD 16DB 52 MSTORE 16DC 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 16FD 60 PUSH1 0x44 16FF 82 DUP3 1700 01 ADD 1701 52 MSTORE 1702 65 PUSH6 0x646472657373 1709 60 PUSH1 0xd0 170B 1B SHL 170C 60 PUSH1 0x64 170E 82 DUP3 170F 01 ADD 1710 52 MSTORE 1711 60 PUSH1 0x84 1713 01 ADD 1714 61 PUSH2 0x0835 1717 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @16CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @16D4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @16DB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1701 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @1710 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @1713 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0835 label_1718: // Incoming jump from 0x16C1, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @171C stack[-1] } 1718 5B JUMPDEST 1719 61 PUSH2 0x1721 171C 81 DUP2 171D 61 PUSH2 0x1b12 1720 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1719 stack[0] = 0x1721 // @171C stack[1] = stack[-1] // } // Block ends with call to 0x1b12, returns to 0x1721 label_1721: // Incoming jump from 0x26C0, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1B12 at 0x1720 // Inputs[1] { @1723 stack[-2] } 1721 5B JUMPDEST 1722 50 POP 1723 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1724: // Incoming jump from 0x07B8 // Inputs[2] // { // @1727 storage[0x08] // @1731 msg.sender // } 1724 5B JUMPDEST 1725 60 PUSH1 0x08 1727 54 SLOAD 1728 60 PUSH1 0x01 172A 60 PUSH1 0x01 172C 60 PUSH1 0xa0 172E 1B SHL 172F 03 SUB 1730 16 AND 1731 33 CALLER 1732 14 EQ 1733 61 PUSH2 0x174e 1736 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x174e, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_1737: // Incoming jump from 0x1736, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @1739 memory[0x40:0x60] } 1737 60 PUSH1 0x40 1739 51 MLOAD 173A 62 PUSH3 0x461bcd 173E 60 PUSH1 0xe5 1740 1B SHL 1741 81 DUP2 1742 52 MSTORE 1743 60 PUSH1 0x04 1745 01 ADD 1746 61 PUSH2 0x0835 1749 90 SWAP1 174A 61 PUSH2 0x2540 174D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1742 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1749 stack[0] = 0x0835 // @1749 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2540, returns to 0x0835 label_174E: // Incoming jump from 0x1736, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @1751 stack[-1] // @1756 memory[0x40:0x60] // } 174E 5B JUMPDEST 174F 60 PUSH1 0x13 1751 81 DUP2 1752 90 SWAP1 1753 55 SSTORE 1754 60 PUSH1 0x40 1756 51 MLOAD 1757 81 DUP2 1758 81 DUP2 1759 52 MSTORE 175A 7F PUSH32 0x0dfd4d63e939364962f32ed5481bf6e523e3b4918c6c413fe7a8876751803d65 177B 90 SWAP1 177C 60 PUSH1 0x20 177E 01 ADD 177F 61 PUSH2 0x087b 1782 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1753 storage[0x13] = stack[-1] // @1759 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @177B stack[0] = 0x0dfd4d63e939364962f32ed5481bf6e523e3b4918c6c413fe7a8876751803d65 // @177E stack[1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x087b label_1783: // Incoming call from 0x0922, returns to 0x0923 // Incoming call from 0x13F0, returns to 0x13F1 // Inputs[2] // { // @1787 storage[0x00] // @1788 stack[-1] // } 1783 5B JUMPDEST 1784 60 PUSH1 0x00 1786 80 DUP1 1787 54 SLOAD 1788 82 DUP3 1789 10 LT 178A 80 DUP1 178B 15 ISZERO 178C 61 PUSH2 0x0805 178F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1784 stack[0] = 0x00 // @1789 stack[1] = stack[-1] < storage[0x00] // } // Block ends with conditional jump to 0x0805, if !(stack[-1] < storage[0x00]) label_1790: // Incoming jump from 0x178F, if not !(stack[-1] < storage[0x00]) // Inputs[4] // { // @1794 stack[-3] // @179F memory[0x00:0x40] // @17A0 storage[keccak256(memory[0x00:0x40])] // @17AC stack[-4] // } 1790 50 POP 1791 50 POP 1792 60 PUSH1 0x00 1794 90 SWAP1 1795 81 DUP2 1796 52 MSTORE 1797 60 PUSH1 0x04 1799 60 PUSH1 0x20 179B 52 MSTORE 179C 60 PUSH1 0x40 179E 90 SWAP1 179F 20 SHA3 17A0 54 SLOAD 17A1 60 PUSH1 0x01 17A3 60 PUSH1 0xe0 17A5 1B SHL 17A6 90 SWAP1 17A7 04 DIV 17A8 60 PUSH1 0xff 17AA 16 AND 17AB 15 ISZERO 17AC 90 SWAP1 17AD 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1796 memory[0x00:0x20] = stack[-3] // @179B memory[0x20:0x40] = 0x04 // @17AC stack[-4] = !(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with unconditional jump to stack[-4] label_17AE: // Incoming call from 0x18D7, returns to 0x18D8 // Incoming call from 0x0AD1, returns to 0x0AD2 // Inputs[8] // { // @17B1 stack[-2] // @17BD memory[0x00:0x40] // @17BF storage[keccak256(memory[0x00:0x40])] // @17D2 stack[-3] // @17DC memory[0x40:0x60] // @17E0 stack[-1] // @1805 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1809 stack[-4] // } 17AE 5B JUMPDEST 17AF 60 PUSH1 0x00 17B1 82 DUP3 17B2 81 DUP2 17B3 52 MSTORE 17B4 60 PUSH1 0x06 17B6 60 PUSH1 0x20 17B8 52 MSTORE 17B9 60 PUSH1 0x40 17BB 80 DUP1 17BC 82 DUP3 17BD 20 SHA3 17BE 80 DUP1 17BF 54 SLOAD 17C0 60 PUSH1 0x01 17C2 60 PUSH1 0x01 17C4 60 PUSH1 0xa0 17C6 1B SHL 17C7 03 SUB 17C8 19 NOT 17C9 16 AND 17CA 60 PUSH1 0x01 17CC 60 PUSH1 0x01 17CE 60 PUSH1 0xa0 17D0 1B SHL 17D1 03 SUB 17D2 87 DUP8 17D3 81 DUP2 17D4 16 AND 17D5 91 SWAP2 17D6 82 DUP3 17D7 17 OR 17D8 90 SWAP1 17D9 92 SWAP3 17DA 55 SSTORE 17DB 91 SWAP2 17DC 51 MLOAD 17DD 85 DUP6 17DE 93 SWAP4 17DF 91 SWAP2 17E0 85 DUP6 17E1 16 AND 17E2 91 SWAP2 17E3 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1804 91 SWAP2 1805 A4 LOG4 1806 50 POP 1807 50 POP 1808 50 POP 1809 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @17B3 memory[0x00:0x20] = stack[-2] // @17B8 memory[0x20:0x40] = 0x06 // @17DA storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1805 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_180A: // Incoming jump from 0x1392 // Incoming jump from 0x0B59 // Inputs[1] { @1810 stack[-1] } 180A 5B JUMPDEST 180B 60 PUSH1 0x00 180D 61 PUSH2 0x1815 1810 82 DUP3 1811 61 PUSH2 0x19f8 1814 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @180B stack[0] = 0x00 // @180D stack[1] = 0x1815 // @1810 stack[2] = stack[-1] // } // Block ends with call to 0x19f8, returns to 0x1815 label_1815: // Incoming return from call to 0x19F8 at 0x1814 // Inputs[4] // { // @1816 stack[-2] // @1816 stack[-1] // @1818 stack[-5] // @1826 memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } 1815 5B JUMPDEST 1816 90 SWAP1 1817 50 POP 1818 83 DUP4 1819 60 PUSH1 0x01 181B 60 PUSH1 0x01 181D 60 PUSH1 0xa0 181F 1B SHL 1820 03 SUB 1821 16 AND 1822 81 DUP2 1823 60 PUSH1 0x00 1825 01 ADD 1826 51 MLOAD 1827 60 PUSH1 0x01 1829 60 PUSH1 0x01 182B 60 PUSH1 0xa0 182D 1B SHL 182E 03 SUB 182F 16 AND 1830 14 EQ 1831 61 PUSH2 0x184c 1834 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1816 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x184c, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] label_1835: // Incoming jump from 0x1834, if not (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @1837 memory[0x40:0x60] // @1846 memory[0x40:0x60] // @184B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1835 60 PUSH1 0x40 1837 51 MLOAD 1838 62 PUSH3 0xa11481 183C 60 PUSH1 0xe8 183E 1B SHL 183F 81 DUP2 1840 52 MSTORE 1841 60 PUSH1 0x04 1843 01 ADD 1844 60 PUSH1 0x40 1846 51 MLOAD 1847 80 DUP1 1848 91 SWAP2 1849 03 SUB 184A 90 SWAP1 184B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1840 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa11481 << 0xe8 // @184B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_184C: // Incoming jump from 0x1834, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[2] // { // @184F msg.sender // @1858 stack[-4] // } 184C 5B JUMPDEST 184D 60 PUSH1 0x00 184F 33 CALLER 1850 60 PUSH1 0x01 1852 60 PUSH1 0x01 1854 60 PUSH1 0xa0 1856 1B SHL 1857 03 SUB 1858 86 DUP7 1859 16 AND 185A 14 EQ 185B 80 DUP1 185C 61 PUSH2 0x186a 185F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @184D stack[0] = 0x00 // @185A stack[1] = stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // } // Block ends with conditional jump to 0x186a, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender label_1860: // Incoming jump from 0x185F, if not stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @1864 stack[-6] // @1865 msg.sender // } 1860 50 POP 1861 61 PUSH2 0x186a 1864 85 DUP6 1865 33 CALLER 1866 61 PUSH2 0x072b 1869 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1861 stack[-1] = 0x186a // @1864 stack[0] = stack[-6] // @1865 stack[1] = msg.sender // } // Block ends with call to 0x072b, returns to 0x186A label_186A: // Incoming return from call to 0x072B at 0x1869 // Incoming jump from 0x185F, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @186B stack[-1] } 186A 5B JUMPDEST 186B 80 DUP1 186C 61 PUSH2 0x1885 186F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1885, if stack[-1] label_1870: // Incoming jump from 0x186F, if not stack[-1] // Inputs[2] // { // @1871 msg.sender // @1875 stack[-4] // } 1870 50 POP 1871 33 CALLER 1872 61 PUSH2 0x187a 1875 84 DUP5 1876 61 PUSH2 0x0918 1879 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1871 stack[-1] = msg.sender // @1872 stack[0] = 0x187a // @1875 stack[1] = stack[-4] // } // Block ends with call to 0x0918, returns to 0x187A label_187A: // Incoming return from call to 0x0918 at 0x1879 // Inputs[2] // { // @1883 stack[-1] // @1884 stack[-2] // } 187A 5B JUMPDEST 187B 60 PUSH1 0x01 187D 60 PUSH1 0x01 187F 60 PUSH1 0xa0 1881 1B SHL 1882 03 SUB 1883 16 AND 1884 14 EQ // Stack delta = -1 // Outputs[1] { @1884 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_1885: // Incoming jump from 0x186F, if stack[-1] // Incoming jump from 0x1884 // Inputs[2] // { // @1886 stack[-2] // @1886 stack[-1] // } 1885 5B JUMPDEST 1886 90 SWAP1 1887 50 POP 1888 80 DUP1 1889 61 PUSH2 0x18a5 188C 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1886 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x18a5, if stack[-1] label_188D: // Incoming jump from 0x188C, if not stack[-1] // Inputs[3] // { // @188F memory[0x40:0x60] // @189F memory[0x40:0x60] // @18A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 188D 60 PUSH1 0x40 188F 51 MLOAD 1890 63 PUSH4 0x2ce44b5f 1895 60 PUSH1 0xe1 1897 1B SHL 1898 81 DUP2 1899 52 MSTORE 189A 60 PUSH1 0x04 189C 01 ADD 189D 60 PUSH1 0x40 189F 51 MLOAD 18A0 80 DUP1 18A1 91 SWAP2 18A2 03 SUB 18A3 90 SWAP1 18A4 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1899 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @18A4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_18A5: // Incoming jump from 0x188C, if stack[-1] // Inputs[1] { @18AE stack[-4] } 18A5 5B JUMPDEST 18A6 60 PUSH1 0x01 18A8 60 PUSH1 0x01 18AA 60 PUSH1 0xa0 18AC 1B SHL 18AD 03 SUB 18AE 84 DUP5 18AF 16 AND 18B0 61 PUSH2 0x18cc 18B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x18cc, if stack[-4] & (0x01 << 0xa0) - 0x01 label_18B4: // Incoming jump from 0x18B3, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @18B6 memory[0x40:0x60] // @18C6 memory[0x40:0x60] // @18CB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 18B4 60 PUSH1 0x40 18B6 51 MLOAD 18B7 63 PUSH4 0x3a954ecd 18BC 60 PUSH1 0xe2 18BE 1B SHL 18BF 81 DUP2 18C0 52 MSTORE 18C1 60 PUSH1 0x04 18C3 01 ADD 18C4 60 PUSH1 0x40 18C6 51 MLOAD 18C7 80 DUP1 18C8 91 SWAP2 18C9 03 SUB 18CA 90 SWAP1 18CB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @18C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3a954ecd << 0xe2 // @18CB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_18CC: // Incoming jump from 0x18B3, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @18D2 stack[-3] // @18D3 stack[-5] // } 18CC 5B JUMPDEST 18CD 61 PUSH2 0x18d8 18D0 60 PUSH1 0x00 18D2 84 DUP5 18D3 87 DUP8 18D4 61 PUSH2 0x17ae 18D7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @18CD stack[0] = 0x18d8 // @18D0 stack[1] = 0x00 // @18D2 stack[2] = stack[-3] // @18D3 stack[3] = stack[-5] // } // Block ends with call to 0x17ae, returns to 0x18D8 label_18D8: // Incoming return from call to 0x17AE at 0x18D7 // Inputs[12] // { // @18E1 stack[-5] // @18F4 memory[0x00:0x40] // @18F6 storage[keccak256(memory[0x00:0x40])] // @1919 stack[-4] // @1921 memory[0x00:0x40] // @1923 storage[keccak256(memory[0x00:0x40])] // @1937 stack[-3] // @1941 memory[0x00:0x40] // @1943 storage[keccak256(memory[0x00:0x40])] // @1956 block.timestamp // @1967 memory[0x00:0x40] // @1969 storage[keccak256(memory[0x00:0x40])] // } 18D8 5B JUMPDEST 18D9 60 PUSH1 0x01 18DB 60 PUSH1 0x01 18DD 60 PUSH1 0xa0 18DF 1B SHL 18E0 03 SUB 18E1 85 DUP6 18E2 81 DUP2 18E3 16 AND 18E4 60 PUSH1 0x00 18E6 90 SWAP1 18E7 81 DUP2 18E8 52 MSTORE 18E9 60 PUSH1 0x05 18EB 60 PUSH1 0x20 18ED 90 SWAP1 18EE 81 DUP2 18EF 52 MSTORE 18F0 60 PUSH1 0x40 18F2 80 DUP1 18F3 83 DUP4 18F4 20 SHA3 18F5 80 DUP1 18F6 54 SLOAD 18F7 67 PUSH8 0xffffffffffffffff 1900 19 NOT 1901 80 DUP1 1902 82 DUP3 1903 16 AND 1904 60 PUSH1 0x01 1906 60 PUSH1 0x01 1908 60 PUSH1 0x40 190A 1B SHL 190B 03 SUB 190C 92 SWAP3 190D 83 DUP4 190E 16 AND 190F 60 PUSH1 0x00 1911 19 NOT 1912 01 ADD 1913 83 DUP4 1914 16 AND 1915 17 OR 1916 90 SWAP1 1917 92 SWAP3 1918 55 SSTORE 1919 89 DUP10 191A 86 DUP7 191B 16 AND 191C 80 DUP1 191D 86 DUP7 191E 52 MSTORE 191F 83 DUP4 1920 86 DUP7 1921 20 SHA3 1922 80 DUP1 1923 54 SLOAD 1924 93 SWAP4 1925 84 DUP5 1926 16 AND 1927 93 SWAP4 1928 83 DUP4 1929 16 AND 192A 60 PUSH1 0x01 192C 90 SWAP1 192D 81 DUP2 192E 01 ADD 192F 84 DUP5 1930 16 AND 1931 94 SWAP5 1932 90 SWAP1 1933 94 SWAP5 1934 17 OR 1935 90 SWAP1 1936 55 SSTORE 1937 89 DUP10 1938 86 DUP7 1939 52 MSTORE 193A 60 PUSH1 0x04 193C 90 SWAP1 193D 94 SWAP5 193E 52 MSTORE 193F 82 DUP3 1940 85 DUP6 1941 20 SHA3 1942 80 DUP1 1943 54 SLOAD 1944 60 PUSH1 0x01 1946 60 PUSH1 0x01 1948 60 PUSH1 0xe0 194A 1B SHL 194B 03 SUB 194C 19 NOT 194D 16 AND 194E 90 SWAP1 194F 94 SWAP5 1950 17 OR 1951 60 PUSH1 0x01 1953 60 PUSH1 0xa0 1955 1B SHL 1956 42 TIMESTAMP 1957 90 SWAP1 1958 92 SWAP3 1959 16 AND 195A 91 SWAP2 195B 90 SWAP1 195C 91 SWAP2 195D 02 MUL 195E 17 OR 195F 83 DUP4 1960 55 SSTORE 1961 87 DUP8 1962 01 ADD 1963 80 DUP1 1964 84 DUP5 1965 52 MSTORE 1966 92 SWAP3 1967 20 SHA3 1968 80 DUP1 1969 54 SLOAD 196A 91 SWAP2 196B 93 SWAP4 196C 90 SWAP1 196D 91 SWAP2 196E 16 AND 196F 61 PUSH2 0x19ac 1972 57 *JUMPI // Stack delta = +3 // Outputs[12] // { // @18E8 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @18EF memory[0x20:0x40] = 0x05 // @1918 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x40) - 0x01 & ~0x00 + ((0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @191E memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @1936 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x40) - 0x01 & 0x01 + ((0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @1939 memory[0x00:0x20] = stack[-3] // @193E memory[0x20:0x40] = 0x04 // @1960 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])]) // @1965 memory[0x00:0x20] = stack[-3] + 0x01 // @1966 stack[1] = stack[-3] + 0x01 // @196B stack[0] = keccak256(memory[0x00:0x40]) // @196D stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x19ac, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_1973: // Incoming jump from 0x1972, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1975 storage[0x00] // @1976 stack[-2] // } 1973 60 PUSH1 0x00 1975 54 SLOAD 1976 82 DUP3 1977 14 EQ 1978 61 PUSH2 0x19ac 197B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x19ac, if stack[-2] == storage[0x00] label_197C: // Incoming jump from 0x197B, if not stack[-2] == storage[0x00] // Inputs[5] // { // @197C stack[-1] // @197D storage[stack[-1]] // @1980 stack[-5] // @1982 memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @19A6 stack[-8] // } 197C 80 DUP1 197D 54 SLOAD 197E 60 PUSH1 0x20 1980 86 DUP7 1981 01 ADD 1982 51 MLOAD 1983 60 PUSH1 0x01 1985 60 PUSH1 0x01 1987 60 PUSH1 0x40 1989 1B SHL 198A 03 SUB 198B 16 AND 198C 60 PUSH1 0x01 198E 60 PUSH1 0xa0 1990 1B SHL 1991 02 MUL 1992 60 PUSH1 0x01 1994 60 PUSH1 0x01 1996 60 PUSH1 0xe0 1998 1B SHL 1999 03 SUB 199A 19 NOT 199B 90 SWAP1 199C 91 SWAP2 199D 16 AND 199E 60 PUSH1 0x01 19A0 60 PUSH1 0x01 19A2 60 PUSH1 0xa0 19A4 1B SHL 19A5 03 SUB 19A6 8A DUP11 19A7 16 AND 19A8 17 OR 19A9 17 OR 19AA 81 DUP2 19AB 55 SSTORE // Stack delta = +0 // Outputs[1] { @19AB storage[stack[-1]] = (stack[-8] & (0x01 << 0xa0) - 0x01) | (storage[stack[-1]] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * ((0x01 << 0x40) - 0x01 & memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20]) } // Block continues label_19AC: // Incoming jump from 0x1972, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x197B, if stack[-2] == storage[0x00] // Incoming jump from 0x19AB // Inputs[6] // { // @19B0 stack[-6] // @19B1 stack[-7] // @19BB stack[-8] // @19E8 memory[0x40:0x60] // @19EB memory[0x40:0x60] // @19F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 19AC 5B JUMPDEST 19AD 50 POP 19AE 50 POP 19AF 50 POP 19B0 82 DUP3 19B1 84 DUP5 19B2 60 PUSH1 0x01 19B4 60 PUSH1 0x01 19B6 60 PUSH1 0xa0 19B8 1B SHL 19B9 03 SUB 19BA 16 AND 19BB 86 DUP7 19BC 60 PUSH1 0x01 19BE 60 PUSH1 0x01 19C0 60 PUSH1 0xa0 19C2 1B SHL 19C3 03 SUB 19C4 16 AND 19C5 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 19E6 60 PUSH1 0x40 19E8 51 MLOAD 19E9 60 PUSH1 0x40 19EB 51 MLOAD 19EC 80 DUP1 19ED 91 SWAP2 19EE 03 SUB 19EF 90 SWAP1 19F0 A4 LOG4 // Stack delta = -3 // Outputs[1] { @19F0 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-8] & (0x01 << 0xa0) - 0x01, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-6]]); } // Block continues label_19F1: // Incoming jump from 0x2011 // Incoming jump from 0x19F0 // Inputs[1] { @19F7 stack[-6] } 19F1 5B JUMPDEST 19F2 50 POP 19F3 50 POP 19F4 50 POP 19F5 50 POP 19F6 50 POP 19F7 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_19F8: // Incoming call from 0x0D01, returns to 0x0D02 // Incoming call from 0x1814, returns to 0x1815 // Inputs[3] // { // @19FC memory[0x40:0x60] // @1A16 stack[-1] // @1A19 storage[0x00] // } 19F8 5B JUMPDEST 19F9 60 PUSH1 0x40 19FB 80 DUP1 19FC 51 MLOAD 19FD 60 PUSH1 0x60 19FF 81 DUP2 1A00 01 ADD 1A01 82 DUP3 1A02 52 MSTORE 1A03 60 PUSH1 0x00 1A05 80 DUP1 1A06 82 DUP3 1A07 52 MSTORE 1A08 60 PUSH1 0x20 1A0A 82 DUP3 1A0B 01 ADD 1A0C 81 DUP2 1A0D 90 SWAP1 1A0E 52 MSTORE 1A0F 91 SWAP2 1A10 81 DUP2 1A11 01 ADD 1A12 91 SWAP2 1A13 90 SWAP1 1A14 91 SWAP2 1A15 52 MSTORE 1A16 81 DUP2 1A17 60 PUSH1 0x00 1A19 54 SLOAD 1A1A 81 DUP2 1A1B 10 LT 1A1C 15 ISZERO 1A1D 61 PUSH2 0x1af9 1A20 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @1A02 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1A07 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1A0E memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @1A14 stack[0] = memory[0x40:0x60] // @1A15 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @1A16 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1af9, if !(stack[-1] < storage[0x00]) label_1A21: // Incoming jump from 0x1A20, if not !(stack[-1] < storage[0x00]) // Inputs[4] // { // @1A23 stack[-1] // @1A32 memory[0x00:0x40] // @1A34 memory[0x40:0x60] // @1A3C storage[keccak256(memory[0x00:0x40])] // } 1A21 60 PUSH1 0x00 1A23 81 DUP2 1A24 81 DUP2 1A25 52 MSTORE 1A26 60 PUSH1 0x04 1A28 60 PUSH1 0x20 1A2A 90 SWAP1 1A2B 81 DUP2 1A2C 52 MSTORE 1A2D 60 PUSH1 0x40 1A2F 91 SWAP2 1A30 82 DUP3 1A31 90 SWAP1 1A32 20 SHA3 1A33 82 DUP3 1A34 51 MLOAD 1A35 60 PUSH1 0x60 1A37 81 DUP2 1A38 01 ADD 1A39 84 DUP5 1A3A 52 MSTORE 1A3B 90 SWAP1 1A3C 54 SLOAD 1A3D 60 PUSH1 0x01 1A3F 60 PUSH1 0x01 1A41 60 PUSH1 0xa0 1A43 1B SHL 1A44 03 SUB 1A45 81 DUP2 1A46 16 AND 1A47 82 DUP3 1A48 52 MSTORE 1A49 60 PUSH1 0x01 1A4B 60 PUSH1 0xa0 1A4D 1B SHL 1A4E 81 DUP2 1A4F 04 DIV 1A50 60 PUSH1 0x01 1A52 60 PUSH1 0x01 1A54 60 PUSH1 0x40 1A56 1B SHL 1A57 03 SUB 1A58 16 AND 1A59 92 SWAP3 1A5A 82 DUP3 1A5B 01 ADD 1A5C 92 SWAP3 1A5D 90 SWAP1 1A5E 92 SWAP3 1A5F 52 MSTORE 1A60 60 PUSH1 0x01 1A62 60 PUSH1 0xe0 1A64 1B SHL 1A65 90 SWAP1 1A66 91 SWAP2 1A67 04 DIV 1A68 60 PUSH1 0xff 1A6A 16 AND 1A6B 15 ISZERO 1A6C 15 ISZERO 1A6D 91 SWAP2 1A6E 81 DUP2 1A6F 01 ADD 1A70 82 DUP3 1A71 90 SWAP1 1A72 52 MSTORE 1A73 90 SWAP1 1A74 61 PUSH2 0x1af7 1A77 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @1A25 memory[0x00:0x20] = stack[-1] // @1A2C memory[0x20:0x40] = 0x04 // @1A3A memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1A48 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @1A5F memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @1A72 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // @1A73 stack[0] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x1af7, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) label_1A78: // Incoming jump from 0x1A77, if not !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // Inputs[2] // { // @1A78 stack[-1] // @1A79 memory[stack[-1]:stack[-1] + 0x20] // } 1A78 80 DUP1 1A79 51 MLOAD 1A7A 60 PUSH1 0x01 1A7C 60 PUSH1 0x01 1A7E 60 PUSH1 0xa0 1A80 1B SHL 1A81 03 SUB 1A82 16 AND 1A83 15 ISZERO 1A84 61 PUSH2 0x1a8e 1A87 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1a8e, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) label_1A88: // Incoming jump from 0x1A87, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @1A88 stack[-1] // @1A88 stack[-5] // @1A89 stack[-4] // } 1A88 93 SWAP4 1A89 92 SWAP3 1A8A 50 POP 1A8B 50 POP 1A8C 50 POP 1A8D 56 *JUMP // Stack delta = -4 // Outputs[1] { @1A88 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1A8E: // Incoming jump from 0x1A87, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1AF6 // Inputs[4] // { // @1A93 stack[-2] // @1AA5 memory[0x00:0x40] // @1AA7 memory[0x40:0x60] // @1AAF storage[keccak256(memory[0x00:0x40])] // } 1A8E 5B JUMPDEST 1A8F 50 POP 1A90 60 PUSH1 0x00 1A92 19 NOT 1A93 01 ADD 1A94 60 PUSH1 0x00 1A96 81 DUP2 1A97 81 DUP2 1A98 52 MSTORE 1A99 60 PUSH1 0x04 1A9B 60 PUSH1 0x20 1A9D 90 SWAP1 1A9E 81 DUP2 1A9F 52 MSTORE 1AA0 60 PUSH1 0x40 1AA2 91 SWAP2 1AA3 82 DUP3 1AA4 90 SWAP1 1AA5 20 SHA3 1AA6 82 DUP3 1AA7 51 MLOAD 1AA8 60 PUSH1 0x60 1AAA 81 DUP2 1AAB 01 ADD 1AAC 84 DUP5 1AAD 52 MSTORE 1AAE 90 SWAP1 1AAF 54 SLOAD 1AB0 60 PUSH1 0x01 1AB2 60 PUSH1 0x01 1AB4 60 PUSH1 0xa0 1AB6 1B SHL 1AB7 03 SUB 1AB8 81 DUP2 1AB9 16 AND 1ABA 80 DUP1 1ABB 83 DUP4 1ABC 52 MSTORE 1ABD 60 PUSH1 0x01 1ABF 60 PUSH1 0xa0 1AC1 1B SHL 1AC2 82 DUP3 1AC3 04 DIV 1AC4 60 PUSH1 0x01 1AC6 60 PUSH1 0x01 1AC8 60 PUSH1 0x40 1ACA 1B SHL 1ACB 03 SUB 1ACC 16 AND 1ACD 93 SWAP4 1ACE 83 DUP4 1ACF 01 ADD 1AD0 93 SWAP4 1AD1 90 SWAP1 1AD2 93 SWAP4 1AD3 52 MSTORE 1AD4 60 PUSH1 0x01 1AD6 60 PUSH1 0xe0 1AD8 1B SHL 1AD9 90 SWAP1 1ADA 04 DIV 1ADB 60 PUSH1 0xff 1ADD 16 AND 1ADE 15 ISZERO 1ADF 15 ISZERO 1AE0 92 SWAP3 1AE1 81 DUP2 1AE2 01 ADD 1AE3 92 SWAP3 1AE4 90 SWAP1 1AE5 92 SWAP3 1AE6 52 MSTORE 1AE7 15 ISZERO 1AE8 61 PUSH2 0x1af2 1AEB 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @1A93 stack[-2] = ~0x00 + stack[-2] // @1A98 memory[0x00:0x20] = ~0x00 + stack[-2] // @1A9F memory[0x20:0x40] = 0x04 // @1AAD memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1ABC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @1AD3 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @1AE5 stack[-1] = memory[0x40:0x60] // @1AE6 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with conditional jump to 0x1af2, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_1AEC: // Incoming jump from 0x1AEB, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @1AEC stack[-5] // @1AEC stack[-1] // @1AED stack[-4] // } 1AEC 93 SWAP4 1AED 92 SWAP3 1AEE 50 POP 1AEF 50 POP 1AF0 50 POP 1AF1 56 *JUMP // Stack delta = -4 // Outputs[1] { @1AEC stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1AF2: // Incoming jump from 0x1AEB, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) 1AF2 5B JUMPDEST 1AF3 61 PUSH2 0x1a8e 1AF6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1a8e label_1AF7: // Incoming jump from 0x1A77, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) 1AF7 5B JUMPDEST 1AF8 50 POP // Stack delta = -1 // Block continues label_1AF9: // Incoming jump from 0x1A20, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x1AF8 // Inputs[3] // { // @1AFC memory[0x40:0x60] // @1B0C memory[0x40:0x60] // @1B11 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1AF9 5B JUMPDEST 1AFA 60 PUSH1 0x40 1AFC 51 MLOAD 1AFD 63 PUSH4 0x6f96cda1 1B02 60 PUSH1 0xe1 1B04 1B SHL 1B05 81 DUP2 1B06 52 MSTORE 1B07 60 PUSH1 0x04 1B09 01 ADD 1B0A 60 PUSH1 0x40 1B0C 51 MLOAD 1B0D 80 DUP1 1B0E 91 SWAP2 1B0F 03 SUB 1B10 90 SWAP1 1B11 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1B06 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @1B11 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1B12: // Incoming call from 0x1720, returns to 0x1721 // Incoming call from 0x0E54, returns to 0x0E55 // Inputs[5] // { // @1B16 storage[0x08] // @1B1F stack[-1] // @1B34 memory[0x40:0x60] // @1B60 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1B63 stack[-2] // } 1B12 5B JUMPDEST 1B13 60 PUSH1 0x08 1B15 80 DUP1 1B16 54 SLOAD 1B17 60 PUSH1 0x01 1B19 60 PUSH1 0x01 1B1B 60 PUSH1 0xa0 1B1D 1B SHL 1B1E 03 SUB 1B1F 83 DUP4 1B20 81 DUP2 1B21 16 AND 1B22 60 PUSH1 0x01 1B24 60 PUSH1 0x01 1B26 60 PUSH1 0xa0 1B28 1B SHL 1B29 03 SUB 1B2A 19 NOT 1B2B 83 DUP4 1B2C 16 AND 1B2D 81 DUP2 1B2E 17 OR 1B2F 90 SWAP1 1B30 93 SWAP4 1B31 55 SSTORE 1B32 60 PUSH1 0x40 1B34 51 MLOAD 1B35 91 SWAP2 1B36 16 AND 1B37 91 SWAP2 1B38 90 SWAP1 1B39 82 DUP3 1B3A 90 SWAP1 1B3B 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1B5C 90 SWAP1 1B5D 60 PUSH1 0x00 1B5F 90 SWAP1 1B60 A3 LOG3 1B61 50 POP 1B62 50 POP 1B63 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1B31 storage[0x08] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x08] & ~((0x01 << 0xa0) - 0x01)) // @1B60 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_1B64: // Incoming call from 0x1001, returns to 0x1002 // Incoming call from 0x1347, returns to 0x1348 // Inputs[3] // { // @1B68 stack[-2] // @1B69 stack[-1] // @1B6C memory[0x40:0x60] // } 1B64 5B JUMPDEST 1B65 61 PUSH2 0x1b7e 1B68 82 DUP3 1B69 82 DUP3 1B6A 60 PUSH1 0x40 1B6C 51 MLOAD 1B6D 80 DUP1 1B6E 60 PUSH1 0x20 1B70 01 ADD 1B71 60 PUSH1 0x40 1B73 52 MSTORE 1B74 80 DUP1 1B75 60 PUSH1 0x00 1B77 81 DUP2 1B78 52 MSTORE 1B79 50 POP 1B7A 61 PUSH2 0x1db8 1B7D 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1B65 stack[0] = 0x1b7e // @1B68 stack[1] = stack[-2] // @1B69 stack[2] = stack[-1] // @1B6C stack[3] = memory[0x40:0x60] // @1B73 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1B78 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x1db8, returns to 0x1B7E label_1B7E: // Incoming return from call to 0x1DB8 at 0x1B7D // Inputs[1] { @1B81 stack[-3] } 1B7E 5B JUMPDEST 1B7F 50 POP 1B80 50 POP 1B81 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1B82: // Incoming call from 0x12CB, returns to 0x12CC // Inputs[3] // { // @1B85 stack[-2] // @1B89 stack[-3] // @1B8A stack[-1] // } 1B82 5B JUMPDEST 1B83 60 PUSH1 0x00 1B85 82 DUP3 1B86 61 PUSH2 0x1b8f 1B89 85 DUP6 1B8A 84 DUP5 1B8B 61 PUSH2 0x1dc5 1B8E 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1B83 stack[0] = 0x00 // @1B85 stack[1] = stack[-2] // @1B86 stack[2] = 0x1b8f // @1B89 stack[3] = stack[-3] // @1B8A stack[4] = stack[-1] // } // Block ends with call to 0x1dc5, returns to 0x1B8F label_1B8F: // Incoming return from call to 0x1DC5 at 0x1B8E // Inputs[4] // { // @1B90 stack[-1] // @1B90 stack[-2] // @1B91 stack[-7] // @1B92 stack[-6] // } 1B8F 5B JUMPDEST 1B90 14 EQ 1B91 94 SWAP5 1B92 93 SWAP4 1B93 50 POP 1B94 50 POP 1B95 50 POP 1B96 50 POP 1B97 56 *JUMP // Stack delta = -6 // Outputs[1] { @1B91 stack[-7] = stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-7] label_1B98: // Incoming jump from 0x1F8A // Inputs[6] // { // @1B9B memory[0x40:0x60] // @1BB1 stack[-3] // @1BBE msg.sender // @1BC0 stack[-4] // @1BC2 stack[-2] // @1BC4 stack[-1] // } 1B98 5B JUMPDEST 1B99 60 PUSH1 0x40 1B9B 51 MLOAD 1B9C 63 PUSH4 0x0a85bd01 1BA1 60 PUSH1 0xe1 1BA3 1B SHL 1BA4 81 DUP2 1BA5 52 MSTORE 1BA6 60 PUSH1 0x00 1BA8 90 SWAP1 1BA9 60 PUSH1 0x01 1BAB 60 PUSH1 0x01 1BAD 60 PUSH1 0xa0 1BAF 1B SHL 1BB0 03 SUB 1BB1 85 DUP6 1BB2 16 AND 1BB3 90 SWAP1 1BB4 63 PUSH4 0x150b7a02 1BB9 90 SWAP1 1BBA 61 PUSH2 0x1bcd 1BBD 90 SWAP1 1BBE 33 CALLER 1BBF 90 SWAP1 1BC0 89 DUP10 1BC1 90 SWAP1 1BC2 88 DUP9 1BC3 90 SWAP1 1BC4 88 DUP9 1BC5 90 SWAP1 1BC6 60 PUSH1 0x04 1BC8 01 ADD 1BC9 61 PUSH2 0x24af 1BCC 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @1BA5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @1BA8 stack[0] = 0x00 // @1BB3 stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1BB9 stack[2] = 0x150b7a02 // @1BBD stack[3] = 0x1bcd // @1BBF stack[4] = msg.sender // @1BC1 stack[5] = stack[-4] // @1BC3 stack[6] = stack[-2] // @1BC5 stack[7] = stack[-1] // @1BC8 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24af, returns to 0x1BCD label_1BCD: // Incoming return from call to 0x24AF at 0x1BCC // Inputs[4] // { // @1BD2 memory[0x40:0x60] // @1BD4 stack[-1] // @1BD9 stack[-3] // @1BDB address(stack[-3]).code.length // } 1BCD 5B JUMPDEST 1BCE 60 PUSH1 0x20 1BD0 60 PUSH1 0x40 1BD2 51 MLOAD 1BD3 80 DUP1 1BD4 83 DUP4 1BD5 03 SUB 1BD6 81 DUP2 1BD7 60 PUSH1 0x00 1BD9 87 DUP8 1BDA 80 DUP1 1BDB 3B EXTCODESIZE 1BDC 15 ISZERO 1BDD 80 DUP1 1BDE 15 ISZERO 1BDF 61 PUSH2 0x1be7 1BE2 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @1BCE stack[0] = 0x20 // @1BD2 stack[1] = memory[0x40:0x60] // @1BD5 stack[2] = stack[-1] - memory[0x40:0x60] // @1BD6 stack[3] = memory[0x40:0x60] // @1BD7 stack[4] = 0x00 // @1BD9 stack[5] = stack[-3] // @1BDC stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1be7, if !!address(stack[-3]).code.length label_1BE3: // Incoming jump from 0x1BE2, if not !!address(stack[-3]).code.length // Inputs[1] { @1BE6 memory[0x00:0x00] } 1BE3 60 PUSH1 0x00 1BE5 80 DUP1 1BE6 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BE6 revert(memory[0x00:0x00]); } // Block terminates label_1BE7: // Incoming jump from 0x1BE2, if !!address(stack[-3]).code.length // Inputs[10] // { // @1BE9 msg.gas // @1BEA stack[-3] // @1BEA stack[-6] // @1BEA stack[-7] // @1BEA memory[stack[-4]:stack[-4] + stack[-5]] // @1BEA stack[-2] // @1BEA stack[-5] // @1BEA address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1BEA stack[-4] // @1BEB stack[-10] // } 1BE7 5B JUMPDEST 1BE8 50 POP 1BE9 5A GAS 1BEA F1 CALL 1BEB 92 SWAP3 1BEC 50 POP 1BED 50 POP 1BEE 50 POP 1BEF 80 DUP1 1BF0 15 ISZERO 1BF1 61 PUSH2 0x1c17 1BF4 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @1BEA memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1BEB 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 0x1c17, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1BF5: // Incoming jump from 0x1BF4, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1BF9 memory[0x40:0x60] // @1BFC returndata.length // } 1BF5 50 POP 1BF6 60 PUSH1 0x40 1BF8 80 DUP1 1BF9 51 MLOAD 1BFA 60 PUSH1 0x1f 1BFC 3D RETURNDATASIZE 1BFD 90 SWAP1 1BFE 81 DUP2 1BFF 01 ADD 1C00 60 PUSH1 0x1f 1C02 19 NOT 1C03 16 AND 1C04 82 DUP3 1C05 01 ADD 1C06 90 SWAP1 1C07 92 SWAP3 1C08 52 MSTORE 1C09 61 PUSH2 0x1c14 1C0C 91 SWAP2 1C0D 81 DUP2 1C0E 01 ADD 1C0F 90 SWAP1 1C10 61 PUSH2 0x2360 1C13 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1C08 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1C0C stack[-1] = 0x1c14 // @1C0F stack[1] = memory[0x40:0x60] // @1C0F stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x2360 1C14 5B JUMPDEST 1C15 60 PUSH1 0x01 label_1C17: // Incoming jump from 0x1BF4, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1C1B stack[-1] } 1C17 5B JUMPDEST 1C18 61 PUSH2 0x1c72 1C1B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1c72, if stack[-1] label_1C1C: // Incoming jump from 0x1C1B, if not stack[-1] // Inputs[1] { @1C1C returndata.length } 1C1C 3D RETURNDATASIZE 1C1D 80 DUP1 1C1E 80 DUP1 1C1F 15 ISZERO 1C20 61 PUSH2 0x1c45 1C23 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C1C stack[0] = returndata.length // @1C1D stack[1] = returndata.length // } // Block ends with conditional jump to 0x1c45, if !returndata.length label_1C24: // Incoming jump from 0x1C23, if not !returndata.length // Inputs[6] // { // @1C26 memory[0x40:0x60] // @1C27 stack[-2] // @1C2E returndata.length // @1C36 returndata.length // @1C39 returndata.length // @1C40 returndata[0x00:0x00 + returndata.length] // } 1C24 60 PUSH1 0x40 1C26 51 MLOAD 1C27 91 SWAP2 1C28 50 POP 1C29 60 PUSH1 0x1f 1C2B 19 NOT 1C2C 60 PUSH1 0x3f 1C2E 3D RETURNDATASIZE 1C2F 01 ADD 1C30 16 AND 1C31 82 DUP3 1C32 01 ADD 1C33 60 PUSH1 0x40 1C35 52 MSTORE 1C36 3D RETURNDATASIZE 1C37 82 DUP3 1C38 52 MSTORE 1C39 3D RETURNDATASIZE 1C3A 60 PUSH1 0x00 1C3C 60 PUSH1 0x20 1C3E 84 DUP5 1C3F 01 ADD 1C40 3E RETURNDATACOPY 1C41 61 PUSH2 0x1c4a 1C44 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1C27 stack[-2] = memory[0x40:0x60] // @1C35 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1C38 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1C40 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1c4a label_1C45: // Incoming jump from 0x1C23, if !returndata.length // Inputs[2] // { // @1C48 stack[-2] // @1C4D memory[0x60:0x80] // } 1C45 5B JUMPDEST 1C46 60 PUSH1 0x60 1C48 91 SWAP2 1C49 50 POP 1C4A 5B JUMPDEST 1C4B 50 POP 1C4C 80 DUP1 1C4D 51 MLOAD 1C4E 61 PUSH2 0x1c6a 1C51 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1C48 stack[-2] = 0x60 } // Block ends with conditional jump to 0x1c6a, if memory[0x60:0x80] label_1C52: // Incoming jump from 0x1C51, if not memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1C51, if not memory[0x60:0x80] // Inputs[3] // { // @1C54 memory[0x40:0x60] // @1C64 memory[0x40:0x60] // @1C69 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1C52 60 PUSH1 0x40 1C54 51 MLOAD 1C55 63 PUSH4 0x68d2bf6b 1C5A 60 PUSH1 0xe1 1C5C 1B SHL 1C5D 81 DUP2 1C5E 52 MSTORE 1C5F 60 PUSH1 0x04 1C61 01 ADD 1C62 60 PUSH1 0x40 1C64 51 MLOAD 1C65 80 DUP1 1C66 91 SWAP2 1C67 03 SUB 1C68 90 SWAP1 1C69 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1C5E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @1C69 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1C6A: // Incoming jump from 0x1C51, if memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1C51, if memory[0x60:0x80] // Inputs[3] // { // @1C6B stack[-1] // @1C6C memory[stack[-1]:stack[-1] + 0x20] // @1C71 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 1C6A 5B JUMPDEST 1C6B 80 DUP1 1C6C 51 MLOAD 1C6D 81 DUP2 1C6E 60 PUSH1 0x20 1C70 01 ADD 1C71 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C71 revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_1C72: // Incoming jump from 0x1C1B, if stack[-1] // Inputs[2] // { // @1C7C stack[-1] // @1C86 stack[-2] // } 1C72 5B JUMPDEST 1C73 60 PUSH1 0x01 1C75 60 PUSH1 0x01 1C77 60 PUSH1 0xe0 1C79 1B SHL 1C7A 03 SUB 1C7B 19 NOT 1C7C 16 AND 1C7D 63 PUSH4 0x0a85bd01 1C82 60 PUSH1 0xe1 1C84 1B SHL 1C85 14 EQ 1C86 90 SWAP1 1C87 50 POP // Stack delta = -1 // Outputs[1] { @1C86 stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block continues label_1C88: // Incoming return from call to 0x20AB at 0x23C0 // Incoming jump from 0x1C87 // Inputs[3] // { // @1C89 stack[-1] // @1C89 stack[-6] // @1C8A stack[-5] // } 1C88 5B JUMPDEST 1C89 94 SWAP5 1C8A 93 SWAP4 1C8B 50 POP 1C8C 50 POP 1C8D 50 POP 1C8E 50 POP 1C8F 56 *JUMP // Stack delta = -5 // Outputs[1] { @1C89 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1C90: // Incoming jump from 0x14FA // Inputs[1] { @1C96 storage[0x0a] } 1C90 5B JUMPDEST 1C91 60 PUSH1 0x60 1C93 60 PUSH1 0x0a 1C95 80 DUP1 1C96 54 SLOAD 1C97 61 PUSH2 0x0895 1C9A 90 SWAP1 1C9B 61 PUSH2 0x2603 1C9E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C91 stack[0] = 0x60 // @1C93 stack[1] = 0x0a // @1C9A stack[2] = 0x0895 // @1C9A stack[3] = storage[0x0a] // } // Block ends with call to 0x2603, returns to 0x0895 1C9F 5B JUMPDEST 1CA0 60 PUSH1 0x60 1CA2 81 DUP2 1CA3 61 PUSH2 0x1cc3 1CA6 57 *JUMPI 1CA7 50 POP 1CA8 50 POP 1CA9 60 PUSH1 0x40 1CAB 80 DUP1 1CAC 51 MLOAD 1CAD 80 DUP1 1CAE 82 DUP3 1CAF 01 ADD 1CB0 90 SWAP1 1CB1 91 SWAP2 1CB2 52 MSTORE 1CB3 60 PUSH1 0x01 1CB5 81 DUP2 1CB6 52 MSTORE 1CB7 60 PUSH1 0x03 1CB9 60 PUSH1 0xfc 1CBB 1B SHL 1CBC 60 PUSH1 0x20 1CBE 82 DUP3 1CBF 01 ADD 1CC0 52 MSTORE 1CC1 90 SWAP1 1CC2 56 *JUMP 1CC3 5B JUMPDEST 1CC4 81 DUP2 1CC5 60 PUSH1 0x00 1CC7 5B JUMPDEST 1CC8 81 DUP2 1CC9 15 ISZERO 1CCA 61 PUSH2 0x1ced 1CCD 57 *JUMPI 1CCE 80 DUP1 1CCF 61 PUSH2 0x1cd7 1CD2 81 DUP2 1CD3 61 PUSH2 0x263e 1CD6 56 *JUMP 1CD7 5B JUMPDEST 1CD8 91 SWAP2 1CD9 50 POP 1CDA 61 PUSH2 0x1ce6 1CDD 90 SWAP1 1CDE 50 POP 1CDF 60 PUSH1 0x0a 1CE1 83 DUP4 1CE2 61 PUSH2 0x258d 1CE5 56 *JUMP 1CE6 5B JUMPDEST 1CE7 91 SWAP2 1CE8 50 POP 1CE9 61 PUSH2 0x1cc7 1CEC 56 *JUMP 1CED 5B JUMPDEST 1CEE 60 PUSH1 0x00 1CF0 81 DUP2 1CF1 60 PUSH1 0x01 1CF3 60 PUSH1 0x01 1CF5 60 PUSH1 0x40 1CF7 1B SHL 1CF8 03 SUB 1CF9 81 DUP2 1CFA 11 GT 1CFB 15 ISZERO 1CFC 61 PUSH2 0x1d15 1CFF 57 *JUMPI 1D00 63 PUSH4 0x4e487b71 1D05 60 PUSH1 0xe0 1D07 1B SHL 1D08 60 PUSH1 0x00 1D0A 52 MSTORE 1D0B 60 PUSH1 0x41 1D0D 60 PUSH1 0x04 1D0F 52 MSTORE 1D10 60 PUSH1 0x24 1D12 60 PUSH1 0x00 1D14 FD *REVERT 1D15 5B JUMPDEST 1D16 60 PUSH1 0x40 1D18 51 MLOAD 1D19 90 SWAP1 1D1A 80 DUP1 1D1B 82 DUP3 1D1C 52 MSTORE 1D1D 80 DUP1 1D1E 60 PUSH1 0x1f 1D20 01 ADD 1D21 60 PUSH1 0x1f 1D23 19 NOT 1D24 16 AND 1D25 60 PUSH1 0x20 1D27 01 ADD 1D28 82 DUP3 1D29 01 ADD 1D2A 60 PUSH1 0x40 1D2C 52 MSTORE 1D2D 80 DUP1 1D2E 15 ISZERO 1D2F 61 PUSH2 0x1d3f 1D32 57 *JUMPI 1D33 60 PUSH1 0x20 1D35 82 DUP3 1D36 01 ADD 1D37 81 DUP2 1D38 80 DUP1 1D39 36 CALLDATASIZE 1D3A 83 DUP4 1D3B 37 CALLDATACOPY 1D3C 01 ADD 1D3D 90 SWAP1 1D3E 50 POP 1D3F 5B JUMPDEST 1D40 50 POP 1D41 90 SWAP1 1D42 50 POP 1D43 5B JUMPDEST 1D44 84 DUP5 1D45 15 ISZERO 1D46 61 PUSH2 0x1c88 1D49 57 *JUMPI 1D4A 61 PUSH2 0x1d54 1D4D 60 PUSH1 0x01 1D4F 83 DUP4 1D50 61 PUSH2 0x25c0 1D53 56 *JUMP 1D54 5B JUMPDEST 1D55 91 SWAP2 1D56 50 POP 1D57 61 PUSH2 0x1d61 1D5A 60 PUSH1 0x0a 1D5C 86 DUP7 1D5D 61 PUSH2 0x2659 1D60 56 *JUMP 1D61 5B JUMPDEST 1D62 61 PUSH2 0x1d6c 1D65 90 SWAP1 1D66 60 PUSH1 0x30 1D68 61 PUSH2 0x2575 1D6B 56 *JUMP 1D6C 5B JUMPDEST 1D6D 60 PUSH1 0xf8 1D6F 1B SHL 1D70 81 DUP2 1D71 83 DUP4 1D72 81 DUP2 1D73 51 MLOAD 1D74 81 DUP2 1D75 10 LT 1D76 61 PUSH2 0x1d8f 1D79 57 *JUMPI 1D7A 63 PUSH4 0x4e487b71 1D7F 60 PUSH1 0xe0 1D81 1B SHL 1D82 60 PUSH1 0x00 1D84 52 MSTORE 1D85 60 PUSH1 0x32 1D87 60 PUSH1 0x04 1D89 52 MSTORE 1D8A 60 PUSH1 0x24 1D8C 60 PUSH1 0x00 1D8E FD *REVERT 1D8F 5B JUMPDEST 1D90 60 PUSH1 0x20 1D92 01 ADD 1D93 01 ADD 1D94 90 SWAP1 1D95 60 PUSH1 0x01 1D97 60 PUSH1 0x01 1D99 60 PUSH1 0xf8 1D9B 1B SHL 1D9C 03 SUB 1D9D 19 NOT 1D9E 16 AND 1D9F 90 SWAP1 1DA0 81 DUP2 1DA1 60 PUSH1 0x00 1DA3 1A BYTE 1DA4 90 SWAP1 1DA5 53 MSTORE8 1DA6 50 POP 1DA7 61 PUSH2 0x1db1 1DAA 60 PUSH1 0x0a 1DAC 86 DUP7 1DAD 61 PUSH2 0x258d 1DB0 56 *JUMP 1DB1 5B JUMPDEST 1DB2 94 SWAP5 1DB3 50 POP 1DB4 61 PUSH2 0x1d43 1DB7 56 *JUMP label_1DB8: // Incoming call from 0x1B7D, returns to 0x1B7E // Inputs[3] // { // @1DBC stack[-3] // @1DBD stack[-2] // @1DBE stack[-1] // } 1DB8 5B JUMPDEST 1DB9 61 PUSH2 0x0ad2 1DBC 83 DUP4 1DBD 83 DUP4 1DBE 83 DUP4 1DBF 60 PUSH1 0x01 1DC1 61 PUSH2 0x1e47 1DC4 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1DB9 stack[0] = 0x0ad2 // @1DBC stack[1] = stack[-3] // @1DBD stack[2] = stack[-2] // @1DBE stack[3] = stack[-1] // @1DBF stack[4] = 0x01 // } // Block ends with call to 0x1e47, returns to 0x0AD2 label_1DC5: // Incoming call from 0x1B8E, returns to 0x1B8F // Inputs[3] // { // @1DC8 stack[-1] // @1DCB stack[-2] // @1DCC memory[stack[-2]:stack[-2] + 0x20] // } 1DC5 5B JUMPDEST 1DC6 60 PUSH1 0x00 1DC8 81 DUP2 1DC9 81 DUP2 1DCA 5B JUMPDEST 1DCB 84 DUP5 1DCC 51 MLOAD 1DCD 81 DUP2 1DCE 10 LT 1DCF 15 ISZERO 1DD0 61 PUSH2 0x1e3f 1DD3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1DC6 stack[0] = 0x00 // @1DC8 stack[1] = stack[-1] // @1DC9 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1e3f, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_1DD4: // Incoming jump from 0x1DD3, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1DD3, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1DD6 stack[-5] // @1DD7 stack[-1] // @1DD9 memory[stack[-5]:stack[-5] + 0x20] // } 1DD4 60 PUSH1 0x00 1DD6 85 DUP6 1DD7 82 DUP3 1DD8 81 DUP2 1DD9 51 MLOAD 1DDA 81 DUP2 1DDB 10 LT 1DDC 61 PUSH2 0x1df5 1DDF 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1DD4 stack[0] = 0x00 // @1DD6 stack[1] = stack[-5] // @1DD7 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x1df5, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_1DE0: // Incoming jump from 0x1DDF, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[1] { @1DF4 memory[0x00:0x24] } 1DE0 63 PUSH4 0x4e487b71 1DE5 60 PUSH1 0xe0 1DE7 1B SHL 1DE8 60 PUSH1 0x00 1DEA 52 MSTORE 1DEB 60 PUSH1 0x32 1DED 60 PUSH1 0x04 1DEF 52 MSTORE 1DF0 60 PUSH1 0x24 1DF2 60 PUSH1 0x00 1DF4 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1DEA memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1DEF memory[0x04:0x24] = 0x32 // @1DF4 revert(memory[0x00:0x24]); // } // Block terminates label_1DF5: // Incoming jump from 0x1DDF, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[5] // { // @1DF8 stack[-1] // @1DFC stack[-2] // @1DFD memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1DFE stack[-3] // @1E01 stack[-5] // } 1DF5 5B JUMPDEST 1DF6 60 PUSH1 0x20 1DF8 02 MUL 1DF9 60 PUSH1 0x20 1DFB 01 ADD 1DFC 01 ADD 1DFD 51 MLOAD 1DFE 90 SWAP1 1DFF 50 POP 1E00 80 DUP1 1E01 83 DUP4 1E02 11 GT 1E03 61 PUSH2 0x1e1b 1E06 57 *JUMPI // Stack delta = -2 // Outputs[1] { @1DFE stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with conditional jump to 0x1e1b, if stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_1E07: // Incoming jump from 0x1E06, if not stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[3] // { // @1E09 stack[-3] // @1E0E stack[-1] // @1E14 memory[0x00:0x40] // } 1E07 60 PUSH1 0x00 1E09 83 DUP4 1E0A 81 DUP2 1E0B 52 MSTORE 1E0C 60 PUSH1 0x20 1E0E 82 DUP3 1E0F 90 SWAP1 1E10 52 MSTORE 1E11 60 PUSH1 0x40 1E13 90 SWAP1 1E14 20 SHA3 1E15 92 SWAP3 1E16 50 POP 1E17 61 PUSH2 0x1e2c 1E1A 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1E0B memory[0x00:0x20] = stack[-3] // @1E10 memory[0x20:0x40] = stack[-1] // @1E15 stack[-3] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to 0x1e2c label_1E1B: // Incoming jump from 0x1E06, if stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[4] // { // @1E1E stack[-1] // @1E23 stack[-3] // @1E29 memory[0x00:0x40] // @1E2E stack[-2] // } 1E1B 5B JUMPDEST 1E1C 60 PUSH1 0x00 1E1E 81 DUP2 1E1F 81 DUP2 1E20 52 MSTORE 1E21 60 PUSH1 0x20 1E23 84 DUP5 1E24 90 SWAP1 1E25 52 MSTORE 1E26 60 PUSH1 0x40 1E28 90 SWAP1 1E29 20 SHA3 1E2A 92 SWAP3 1E2B 50 POP 1E2C 5B JUMPDEST 1E2D 50 POP 1E2E 80 DUP1 1E2F 61 PUSH2 0x1e37 1E32 81 DUP2 1E33 61 PUSH2 0x263e 1E36 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @1E20 memory[0x00:0x20] = stack[-1] // @1E25 memory[0x20:0x40] = stack[-3] // @1E2A stack[-3] = keccak256(memory[0x00:0x40]) // @1E2E stack[-1] = stack[-2] // @1E2F stack[0] = 0x1e37 // @1E32 stack[1] = stack[-2] // } // Block ends with call to 0x263e, returns to 0x1E37 label_1E37: // Incoming return from call to 0x263E at 0x1E36 // Incoming return from call to 0x263E at 0x1E36 // Inputs[2] // { // @1E38 stack[-3] // @1E38 stack[-1] // } 1E37 5B JUMPDEST 1E38 91 SWAP2 1E39 50 POP 1E3A 50 POP 1E3B 61 PUSH2 0x1dca 1E3E 56 *JUMP // Stack delta = -2 // Outputs[1] { @1E38 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1dca label_1E3F: // Incoming jump from 0x1DD3, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1DD3, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1E41 stack[-6] // @1E41 stack[-2] // @1E42 stack[-5] // } 1E3F 5B JUMPDEST 1E40 50 POP 1E41 93 SWAP4 1E42 92 SWAP3 1E43 50 POP 1E44 50 POP 1E45 50 POP 1E46 56 *JUMP // Stack delta = -5 // Outputs[1] { @1E41 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_1E47: // Incoming call from 0x1DC4, returns to 0x0AD2 // Inputs[2] // { // @1E4A storage[0x00] // @1E53 stack[-4] // } 1E47 5B JUMPDEST 1E48 60 PUSH1 0x00 1E4A 54 SLOAD 1E4B 60 PUSH1 0x01 1E4D 60 PUSH1 0x01 1E4F 60 PUSH1 0xa0 1E51 1B SHL 1E52 03 SUB 1E53 85 DUP6 1E54 16 AND 1E55 61 PUSH2 0x1e70 1E58 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E4A stack[0] = storage[0x00] } // Block ends with conditional jump to 0x1e70, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1E59: // Incoming jump from 0x1E58, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1E5B memory[0x40:0x60] // @1E6A memory[0x40:0x60] // @1E6F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1E59 60 PUSH1 0x40 1E5B 51 MLOAD 1E5C 62 PUSH3 0x2e0763 1E60 60 PUSH1 0xe8 1E62 1B SHL 1E63 81 DUP2 1E64 52 MSTORE 1E65 60 PUSH1 0x04 1E67 01 ADD 1E68 60 PUSH1 0x40 1E6A 51 MLOAD 1E6B 80 DUP1 1E6C 91 SWAP2 1E6D 03 SUB 1E6E 90 SWAP1 1E6F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1E64 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e0763 << 0xe8 // @1E6F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1E70: // Incoming jump from 0x1E58, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1E71 stack[-4] } 1E70 5B JUMPDEST 1E71 83 DUP4 1E72 61 PUSH2 0x1e8e 1E75 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e8e, if stack[-4] label_1E76: // Incoming jump from 0x1E75, if not stack[-4] // Inputs[3] // { // @1E78 memory[0x40:0x60] // @1E88 memory[0x40:0x60] // @1E8D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1E76 60 PUSH1 0x40 1E78 51 MLOAD 1E79 63 PUSH4 0xb562e8dd 1E7E 60 PUSH1 0xe0 1E80 1B SHL 1E81 81 DUP2 1E82 52 MSTORE 1E83 60 PUSH1 0x04 1E85 01 ADD 1E86 60 PUSH1 0x40 1E88 51 MLOAD 1E89 80 DUP1 1E8A 91 SWAP2 1E8B 03 SUB 1E8C 90 SWAP1 1E8D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1E82 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd << 0xe0 // @1E8D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1E8E: // Incoming jump from 0x1E75, if stack[-4] // Inputs[9] // { // @1E97 stack[-5] // @1EA9 memory[0x00:0x40] // @1EAB storage[keccak256(memory[0x00:0x40])] // @1ECB stack[-4] // @1EF7 stack[-1] // @1F01 memory[0x00:0x40] // @1F03 storage[keccak256(memory[0x00:0x40])] // @1F16 block.timestamp // @1F25 stack[-2] // } 1E8E 5B JUMPDEST 1E8F 60 PUSH1 0x01 1E91 60 PUSH1 0x01 1E93 60 PUSH1 0xa0 1E95 1B SHL 1E96 03 SUB 1E97 85 DUP6 1E98 16 AND 1E99 60 PUSH1 0x00 1E9B 81 DUP2 1E9C 81 DUP2 1E9D 52 MSTORE 1E9E 60 PUSH1 0x05 1EA0 60 PUSH1 0x20 1EA2 90 SWAP1 1EA3 81 DUP2 1EA4 52 MSTORE 1EA5 60 PUSH1 0x40 1EA7 80 DUP1 1EA8 83 DUP4 1EA9 20 SHA3 1EAA 80 DUP1 1EAB 54 SLOAD 1EAC 6F PUSH16 0xffffffffffffffffffffffffffffffff 1EBD 19 NOT 1EBE 81 DUP2 1EBF 16 AND 1EC0 60 PUSH1 0x01 1EC2 60 PUSH1 0x01 1EC4 60 PUSH1 0x40 1EC6 1B SHL 1EC7 03 SUB 1EC8 80 DUP1 1EC9 83 DUP4 1ECA 16 AND 1ECB 8C DUP13 1ECC 01 ADD 1ECD 81 DUP2 1ECE 16 AND 1ECF 91 SWAP2 1ED0 82 DUP3 1ED1 17 OR 1ED2 60 PUSH1 0x01 1ED4 60 PUSH1 0x40 1ED6 1B SHL 1ED7 67 PUSH8 0xffffffffffffffff 1EE0 19 NOT 1EE1 90 SWAP1 1EE2 94 SWAP5 1EE3 16 AND 1EE4 90 SWAP1 1EE5 92 SWAP3 1EE6 17 OR 1EE7 83 DUP4 1EE8 90 SWAP1 1EE9 04 DIV 1EEA 81 DUP2 1EEB 16 AND 1EEC 8C DUP13 1EED 01 ADD 1EEE 81 DUP2 1EEF 16 AND 1EF0 90 SWAP1 1EF1 92 SWAP3 1EF2 02 MUL 1EF3 17 OR 1EF4 90 SWAP1 1EF5 91 SWAP2 1EF6 55 SSTORE 1EF7 85 DUP6 1EF8 84 DUP5 1EF9 52 MSTORE 1EFA 60 PUSH1 0x04 1EFC 90 SWAP1 1EFD 92 SWAP3 1EFE 52 MSTORE 1EFF 90 SWAP1 1F00 91 SWAP2 1F01 20 SHA3 1F02 80 DUP1 1F03 54 SLOAD 1F04 60 PUSH1 0x01 1F06 60 PUSH1 0x01 1F08 60 PUSH1 0xe0 1F0A 1B SHL 1F0B 03 SUB 1F0C 19 NOT 1F0D 16 AND 1F0E 90 SWAP1 1F0F 92 SWAP3 1F10 17 OR 1F11 60 PUSH1 0x01 1F13 60 PUSH1 0xa0 1F15 1B SHL 1F16 42 TIMESTAMP 1F17 90 SWAP1 1F18 92 SWAP3 1F19 16 AND 1F1A 91 SWAP2 1F1B 90 SWAP1 1F1C 91 SWAP2 1F1D 02 MUL 1F1E 17 OR 1F1F 90 SWAP1 1F20 55 SSTORE 1F21 80 DUP1 1F22 80 DUP1 1F23 85 DUP6 1F24 01 ADD 1F25 83 DUP4 1F26 80 DUP1 1F27 15 ISZERO 1F28 61 PUSH2 0x1f3a 1F2B 57 *JUMPI // Stack delta = +3 // Outputs[9] // { // @1E9D memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1EA4 memory[0x20:0x40] = 0x05 // @1EF6 storage[keccak256(memory[0x00:0x40])] = (0x01 << 0x40) * ((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)) / (0x01 << 0x40))) | ((0x01 << 0x40) - 0x01 & stack[-4] + (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0x40) - 0x01)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffffffffffffffffffff) // @1EF9 memory[0x00:0x20] = stack[-1] // @1EFE memory[0x20:0x40] = 0x04 // @1F20 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])]) // @1F21 stack[0] = stack[-1] // @1F24 stack[1] = stack[-4] + stack[-1] // @1F25 stack[2] = stack[-2] // } // Block ends with conditional jump to 0x1f3a, if !stack[-2] label_1F2C: // Incoming jump from 0x1F2B, if not !stack[-2] // Inputs[2] // { // @1F35 stack[-8] // @1F37 address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // } 1F2C 50 POP 1F2D 60 PUSH1 0x01 1F2F 60 PUSH1 0x01 1F31 60 PUSH1 0xa0 1F33 1B SHL 1F34 03 SUB 1F35 87 DUP8 1F36 16 AND 1F37 3B EXTCODESIZE 1F38 15 ISZERO 1F39 15 ISZERO 1F3A 5B JUMPDEST 1F3B 15 ISZERO 1F3C 61 PUSH2 0x1fc3 1F3F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1fc3, if !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length label_1F40: // Incoming jump from 0x1F3F, if not !stack[-1] // Incoming jump from 0x1F3F, if not !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Inputs[5] // { // @1F43 memory[0x40:0x60] // @1F44 stack[-2] // @1F4E stack[-7] // @1F78 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1F86 stack[-5] // } 1F40 5B JUMPDEST 1F41 60 PUSH1 0x40 1F43 51 MLOAD 1F44 82 DUP3 1F45 90 SWAP1 1F46 60 PUSH1 0x01 1F48 60 PUSH1 0x01 1F4A 60 PUSH1 0xa0 1F4C 1B SHL 1F4D 03 SUB 1F4E 89 DUP10 1F4F 16 AND 1F50 90 SWAP1 1F51 60 PUSH1 0x00 1F53 90 SWAP1 1F54 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1F75 90 SWAP1 1F76 82 DUP3 1F77 90 SWAP1 1F78 A4 LOG4 1F79 61 PUSH2 0x1f8b 1F7C 60 PUSH1 0x00 1F7E 88 DUP9 1F7F 84 DUP5 1F80 80 DUP1 1F81 60 PUSH1 0x01 1F83 01 ADD 1F84 95 SWAP6 1F85 50 POP 1F86 88 DUP9 1F87 61 PUSH2 0x1b98 1F8A 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1F78 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // @1F79 stack[0] = 0x1f8b // @1F7C stack[1] = 0x00 // @1F7E stack[2] = stack[-7] // @1F7F stack[3] = stack[-2] // @1F84 stack[-2] = 0x01 + stack[-2] // @1F86 stack[4] = stack[-5] // } // Block ends with unconditional jump to 0x1b98 1F8B 5B JUMPDEST 1F8C 61 PUSH2 0x1fa8 1F8F 57 *JUMPI 1F90 60 PUSH1 0x40 1F92 51 MLOAD 1F93 63 PUSH4 0x68d2bf6b 1F98 60 PUSH1 0xe1 1F9A 1B SHL 1F9B 81 DUP2 1F9C 52 MSTORE 1F9D 60 PUSH1 0x04 1F9F 01 ADD 1FA0 60 PUSH1 0x40 1FA2 51 MLOAD 1FA3 80 DUP1 1FA4 91 SWAP2 1FA5 03 SUB 1FA6 90 SWAP1 1FA7 FD *REVERT 1FA8 5B JUMPDEST 1FA9 80 DUP1 1FAA 82 DUP3 1FAB 14 EQ 1FAC 15 ISZERO 1FAD 61 PUSH2 0x1f40 1FB0 57 *JUMPI 1FB1 82 DUP3 1FB2 60 PUSH1 0x00 1FB4 54 SLOAD 1FB5 14 EQ 1FB6 61 PUSH2 0x1fbe 1FB9 57 *JUMPI 1FBA 60 PUSH1 0x00 1FBC 80 DUP1 1FBD FD *REVERT 1FBE 5B JUMPDEST 1FBF 61 PUSH2 0x2009 1FC2 56 *JUMP label_1FC3: // Incoming jump from 0x1F3F, if !stack[-1] // Incoming jump from 0x1F3F, if !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Inputs[5] // { // @1FC7 memory[0x40:0x60] // @1FCA stack[-2] // @1FD6 stack[-7] // @2000 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @2001 stack[-1] // } 1FC3 5B JUMPDEST 1FC4 5B JUMPDEST 1FC5 60 PUSH1 0x40 1FC7 51 MLOAD 1FC8 60 PUSH1 0x01 1FCA 83 DUP4 1FCB 01 ADD 1FCC 92 SWAP3 1FCD 90 SWAP1 1FCE 60 PUSH1 0x01 1FD0 60 PUSH1 0x01 1FD2 60 PUSH1 0xa0 1FD4 1B SHL 1FD5 03 SUB 1FD6 89 DUP10 1FD7 16 AND 1FD8 90 SWAP1 1FD9 60 PUSH1 0x00 1FDB 90 SWAP1 1FDC 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1FFD 90 SWAP1 1FFE 82 DUP3 1FFF 90 SWAP1 2000 A4 LOG4 2001 80 DUP1 2002 82 DUP3 2003 14 EQ 2004 15 ISZERO 2005 61 PUSH2 0x1fc4 2008 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1FCC stack[-2] = stack[-2] + 0x01 // @2000 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with conditional jump to 0x1fc4, if !(stack[-2] + 0x01 == stack[-1]) label_2009: // Incoming jump from 0x2008, if not !(stack[-2] + 0x01 == stack[-1]) // Incoming jump from 0x2008, if not !(stack[-2] + 0x01 == stack[-1]) // Inputs[1] { @200D stack[-2] } 2009 5B JUMPDEST 200A 50 POP 200B 60 PUSH1 0x00 200D 55 SSTORE 200E 61 PUSH2 0x19f1 2011 56 *JUMP // Stack delta = -2 // Outputs[1] { @200D storage[0x00] = stack[-2] } // Block ends with unconditional jump to 0x19f1 label_2012: // Incoming jump from 0x15EB // Incoming jump from 0x1658 // Incoming jump from 0x0CC6 // Inputs[2] // { // @2013 stack[-3] // @2015 storage[stack[-3]] // } 2012 5B JUMPDEST 2013 82 DUP3 2014 80 DUP1 2015 54 SLOAD 2016 61 PUSH2 0x201e 2019 90 SWAP1 201A 61 PUSH2 0x2603 201D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2013 stack[0] = stack[-3] // @2019 stack[1] = 0x201e // @2019 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x2603, returns to 0x201E label_201E: // Incoming return from call to 0x2603 at 0x201D // Inputs[5] // { // @201F stack[-2] // @201F stack[-1] // @2027 memory[0x00:0x20] // @2032 stack[-4] // @2033 stack[-3] // } 201E 5B JUMPDEST 201F 90 SWAP1 2020 60 PUSH1 0x00 2022 52 MSTORE 2023 60 PUSH1 0x20 2025 60 PUSH1 0x00 2027 20 SHA3 2028 90 SWAP1 2029 60 PUSH1 0x1f 202B 01 ADD 202C 60 PUSH1 0x20 202E 90 SWAP1 202F 04 DIV 2030 81 DUP2 2031 01 ADD 2032 92 SWAP3 2033 82 DUP3 2034 61 PUSH2 0x2040 2037 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2022 memory[0x00:0x20] = stack[-2] // @2028 stack[-2] = keccak256(memory[0x00:0x20]) // @2032 stack[-1] = stack[-4] // @2032 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x2040, if stack[-3] label_2038: // Incoming jump from 0x2037, if not stack[-3] // Inputs[1] { @203A stack[-5] } 2038 60 PUSH1 0x00 203A 85 DUP6 203B 55 SSTORE 203C 61 PUSH2 0x2086 203F 56 *JUMP // Stack delta = +0 // Outputs[1] { @203B storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x2086 label_2040: // Incoming jump from 0x2037, if stack[-3] // Inputs[1] { @2041 stack[-3] } 2040 5B JUMPDEST 2041 82 DUP3 2042 60 PUSH1 0x1f 2044 10 LT 2045 61 PUSH2 0x2059 2048 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2059, if 0x1f < stack[-3] label_2049: // Incoming jump from 0x2048, if not 0x1f < stack[-3] // Inputs[4] // { // @2049 stack[-1] // @204A memory[stack[-1]:stack[-1] + 0x20] // @204F stack[-3] // @2053 stack[-5] // } 2049 80 DUP1 204A 51 MLOAD 204B 60 PUSH1 0xff 204D 19 NOT 204E 16 AND 204F 83 DUP4 2050 80 DUP1 2051 01 ADD 2052 17 OR 2053 85 DUP6 2054 55 SSTORE 2055 61 PUSH2 0x2086 2058 56 *JUMP // Stack delta = +0 // Outputs[1] { @2054 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x2086 label_2059: // Incoming jump from 0x2048, if 0x1f < stack[-3] // Inputs[2] // { // @205A stack[-3] // @2060 stack[-5] // } 2059 5B JUMPDEST 205A 82 DUP3 205B 80 DUP1 205C 01 ADD 205D 60 PUSH1 0x01 205F 01 ADD 2060 85 DUP6 2061 55 SSTORE 2062 82 DUP3 2063 15 ISZERO 2064 61 PUSH2 0x2086 2067 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2061 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x2086, if !stack[-3] label_2068: // Incoming jump from 0x2067, if not !stack[-3] // Inputs[2] // { // @2068 stack[-3] // @2068 stack[-1] // } 2068 91 SWAP2 2069 82 DUP3 206A 01 ADD 206B 5B JUMPDEST 206C 82 DUP3 206D 81 DUP2 206E 11 GT 206F 15 ISZERO 2070 61 PUSH2 0x2086 2073 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2068 stack[-3] = stack[-1] // @206A stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x2086, if !(stack[-1] + stack[-3] > stack[-1]) label_2074: // Incoming jump from 0x2073, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x2073, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @2074 stack[-3] // @2075 memory[stack[-3]:stack[-3] + 0x20] // @2076 stack[-2] // @2078 stack[-1] // } 2074 82 DUP3 2075 51 MLOAD 2076 82 DUP3 2077 55 SSTORE 2078 91 SWAP2 2079 60 PUSH1 0x20 207B 01 ADD 207C 91 SWAP2 207D 90 SWAP1 207E 60 PUSH1 0x01 2080 01 ADD 2081 90 SWAP1 2082 61 PUSH2 0x206b 2085 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2077 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @207C stack[-3] = 0x20 + stack[-3] // @2081 stack[-2] = 0x01 + stack[-2] // @2081 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x206b label_2086: // Incoming jump from 0x2058 // Incoming jump from 0x2073, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x2067, if !stack[-3] // Incoming jump from 0x203F // Incoming jump from 0x2073, if !(stack[-1] > stack[-3]) // Inputs[2] // { // @208B stack[-4] // @208C stack[-3] // } 2086 5B JUMPDEST 2087 50 POP 2088 61 PUSH2 0x2092 208B 92 SWAP3 208C 91 SWAP2 208D 50 POP 208E 61 PUSH2 0x2096 2091 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @208B stack[-4] = 0x2092 // @208C stack[-3] = stack[-4] // } // Block ends with call to 0x2096, returns to 0x2092 label_2092: // Incoming jump from 0x209F, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x2096 at 0x2091 // Incoming jump from 0x209F, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @2094 stack[-3] // @2094 stack[-2] // } 2092 5B JUMPDEST 2093 50 POP 2094 90 SWAP1 2095 56 *JUMP // Stack delta = -2 // Outputs[1] { @2094 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_2096: // Incoming call from 0x2091, returns to 0x2092 // Inputs[2] // { // @2098 stack[-1] // @2099 stack[-2] // } 2096 5B JUMPDEST 2097 5B JUMPDEST 2098 80 DUP1 2099 82 DUP3 209A 11 GT 209B 15 ISZERO 209C 61 PUSH2 0x2092 209F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2092, if !(stack[-2] > stack[-1]) label_20A0: // Incoming jump from 0x209F, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x209F, if not !(stack[-2] > stack[-1]) // Inputs[1] { @20A2 stack[-1] } 20A0 60 PUSH1 0x00 20A2 81 DUP2 20A3 55 SSTORE 20A4 60 PUSH1 0x01 20A6 01 ADD 20A7 61 PUSH2 0x2097 20AA 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @20A3 storage[stack[-1]] = 0x00 // @20A6 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2097 label_20AB: // Incoming call from 0x23C0, returns to 0x1C88 // Incoming call from 0x223E, returns to 0x223F // Inputs[1] { @20B7 stack[-2] } 20AB 5B JUMPDEST 20AC 60 PUSH1 0x00 20AE 60 PUSH1 0x01 20B0 60 PUSH1 0x01 20B2 60 PUSH1 0x40 20B4 1B SHL 20B5 03 SUB 20B6 80 DUP1 20B7 84 DUP5 20B8 11 GT 20B9 15 ISZERO 20BA 61 PUSH2 0x20c5 20BD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20AC stack[0] = 0x00 // @20B5 stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x20c5, if !(stack[-2] > (0x01 << 0x40) - 0x01) label_20BE: // Incoming jump from 0x20BD, if not !(stack[-2] > (0x01 << 0x40) - 0x01) 20BE 61 PUSH2 0x20c5 20C1 61 PUSH2 0x2699 20C4 56 *JUMP // Stack delta = +1 // Outputs[1] { @20BE stack[0] = 0x20c5 } // Block ends with unconditional jump to 0x2699 label_20C5: // Incoming jump from 0x20BD, if !(stack[-2] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @20C8 memory[0x40:0x60] // @20CB stack[-4] // @20DA stack[-1] // } 20C5 5B JUMPDEST 20C6 60 PUSH1 0x40 20C8 51 MLOAD 20C9 60 PUSH1 0x1f 20CB 85 DUP6 20CC 01 ADD 20CD 60 PUSH1 0x1f 20CF 19 NOT 20D0 90 SWAP1 20D1 81 DUP2 20D2 16 AND 20D3 60 PUSH1 0x3f 20D5 01 ADD 20D6 16 AND 20D7 81 DUP2 20D8 01 ADD 20D9 90 SWAP1 20DA 82 DUP3 20DB 82 DUP3 20DC 11 GT 20DD 81 DUP2 20DE 83 DUP4 20DF 10 LT 20E0 17 OR 20E1 15 ISZERO 20E2 61 PUSH2 0x20ed 20E5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20D9 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @20D9 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x20ed, 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_20E6: // Incoming jump from 0x20E5, 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])) 20E6 61 PUSH2 0x20ed 20E9 61 PUSH2 0x2699 20EC 56 *JUMP // Stack delta = +1 // Outputs[1] { @20E6 stack[0] = 0x20ed } // Block ends with unconditional jump to 0x2699 label_20ED: // Incoming jump from 0x20E5, 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] // { // @20EE stack[-2] // @20F2 stack[-1] // @20F3 stack[-4] // @20F5 stack[-6] // @20F8 stack[-7] // @20FA stack[-5] // } 20ED 5B JUMPDEST 20EE 81 DUP2 20EF 60 PUSH1 0x40 20F1 52 MSTORE 20F2 80 DUP1 20F3 93 SWAP4 20F4 50 POP 20F5 85 DUP6 20F6 81 DUP2 20F7 52 MSTORE 20F8 86 DUP7 20F9 86 DUP7 20FA 86 DUP7 20FB 01 ADD 20FC 11 GT 20FD 15 ISZERO 20FE 61 PUSH2 0x2106 2101 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @20F1 memory[0x40:0x60] = stack[-2] // @20F3 stack[-4] = stack[-1] // @20F7 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x2106, if !(stack[-5] + stack[-6] > stack[-7]) label_2102: // Incoming jump from 0x2101, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @2105 memory[0x00:0x00] } 2102 60 PUSH1 0x00 2104 80 DUP1 2105 FD *REVERT // Stack delta = +0 // Outputs[1] { @2105 revert(memory[0x00:0x00]); } // Block terminates label_2106: // Incoming jump from 0x2101, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @2107 stack[-6] // @2108 stack[-5] // @210B stack[-1] // @210D msg.data[stack[-5]:stack[-5] + stack[-6]] // @211A stack[-4] // @211A stack[-8] // @211B stack[-7] // } 2106 5B JUMPDEST 2107 85 DUP6 2108 85 DUP6 2109 60 PUSH1 0x20 210B 83 DUP4 210C 01 ADD 210D 37 CALLDATACOPY 210E 60 PUSH1 0x00 2110 60 PUSH1 0x20 2112 87 DUP8 2113 83 DUP4 2114 01 ADD 2115 01 ADD 2116 52 MSTORE 2117 50 POP 2118 50 POP 2119 50 POP 211A 93 SWAP4 211B 92 SWAP3 211C 50 POP 211D 50 POP 211E 50 POP 211F 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @210D memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @2116 memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @211A stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_2120: // Incoming call from 0x2165, returns to 0x1549 // Incoming call from 0x228E, returns to 0x228F // Incoming call from 0x218E, returns to 0x218F // Incoming call from 0x21B4, returns to 0x21B5 // Incoming call from 0x2180, returns to 0x2181 // Incoming call from 0x21F0, returns to 0x21F1 // Incoming call from 0x2265, returns to 0x2266 // Incoming call from 0x21C2, returns to 0x21C3 // Incoming call from 0x21FE, returns to 0x21FF // Inputs[2] // { // @2121 stack[-1] // @2122 msg.data[stack[-1]:stack[-1] + 0x20] // } 2120 5B JUMPDEST 2121 80 DUP1 2122 35 CALLDATALOAD 2123 60 PUSH1 0x01 2125 60 PUSH1 0x01 2127 60 PUSH1 0xa0 2129 1B SHL 212A 03 SUB 212B 81 DUP2 212C 16 AND 212D 81 DUP2 212E 14 EQ 212F 61 PUSH2 0x2137 2132 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2122 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x2137, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_2133: // Incoming jump from 0x2132, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2136 memory[0x00:0x00] } 2133 60 PUSH1 0x00 2135 80 DUP1 2136 FD *REVERT // Stack delta = +0 // Outputs[1] { @2136 revert(memory[0x00:0x00]); } // Block terminates label_2137: // Incoming jump from 0x2132, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x2147, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @2138 stack[-3] // @2138 stack[-1] // @2139 stack[-2] // } 2137 5B JUMPDEST 2138 91 SWAP2 2139 90 SWAP1 213A 50 POP 213B 56 *JUMP // Stack delta = -2 // Outputs[1] { @2138 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_213C: // Incoming call from 0x232B, returns to 0x1549 // Incoming call from 0x2273, returns to 0x218F // Inputs[2] // { // @213D stack[-1] // @213E msg.data[stack[-1]:stack[-1] + 0x20] // } 213C 5B JUMPDEST 213D 80 DUP1 213E 35 CALLDATALOAD 213F 80 DUP1 2140 15 ISZERO 2141 15 ISZERO 2142 81 DUP2 2143 14 EQ 2144 61 PUSH2 0x2137 2147 57 *JUMPI // Stack delta = +1 // Outputs[1] { @213E stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x2137, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_2148: // Incoming jump from 0x2147, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @214B memory[0x00:0x00] } 2148 60 PUSH1 0x00 214A 80 DUP1 214B FD *REVERT // Stack delta = +0 // Outputs[1] { @214B revert(memory[0x00:0x00]); } // Block terminates label_214C: // Incoming call from 0x06E4, returns to 0x06E5 // Incoming call from 0x03C9, returns to 0x03CA // Incoming call from 0x0793, returns to 0x0794 // Incoming call from 0x056B, returns to 0x056C // Inputs[2] // { // @2151 stack[-1] // @2152 stack[-2] // } 214C 5B JUMPDEST 214D 60 PUSH1 0x00 214F 60 PUSH1 0x20 2151 82 DUP3 2152 84 DUP5 2153 03 SUB 2154 12 SLT 2155 15 ISZERO 2156 61 PUSH2 0x215d 2159 57 *JUMPI // Stack delta = +1 // Outputs[1] { @214D stack[0] = 0x00 } // Block ends with conditional jump to 0x215d, if !(stack[-2] - stack[-1] i< 0x20) label_215A: // Incoming jump from 0x2159, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @215A stack[-1] // @215C memory[stack[-1]:stack[-1] + stack[-1]] // } 215A 80 DUP1 215B 81 DUP2 215C FD *REVERT // Stack delta = +0 // Outputs[1] { @215C revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_215D: // Incoming jump from 0x2159, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2161 stack[-2] } 215D 5B JUMPDEST 215E 61 PUSH2 0x1549 2161 82 DUP3 2162 61 PUSH2 0x2120 2165 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @215E stack[0] = 0x1549 // @2161 stack[1] = stack[-2] // } // Block ends with call to 0x2120, returns to 0x1549 label_2166: // Incoming call from 0x072A, returns to 0x072B // Inputs[2] // { // @216C stack[-1] // @216D stack[-2] // } 2166 5B JUMPDEST 2167 60 PUSH1 0x00 2169 80 DUP1 216A 60 PUSH1 0x40 216C 83 DUP4 216D 85 DUP6 216E 03 SUB 216F 12 SLT 2170 15 ISZERO 2171 61 PUSH2 0x2178 2174 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2167 stack[0] = 0x00 // @2169 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2178, if !(stack[-2] - stack[-1] i< 0x40) label_2175: // Incoming jump from 0x2174, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2175 stack[-1] // @2177 memory[stack[-1]:stack[-1] + stack[-1]] // } 2175 80 DUP1 2176 81 DUP2 2177 FD *REVERT // Stack delta = +0 // Outputs[1] { @2177 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2178: // Incoming jump from 0x2174, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @217C stack[-3] } 2178 5B JUMPDEST 2179 61 PUSH2 0x2181 217C 83 DUP4 217D 61 PUSH2 0x2120 2180 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2179 stack[0] = 0x2181 // @217C stack[1] = stack[-3] // } // Block ends with call to 0x2120, returns to 0x2181 label_2181: // Incoming return from call to 0x2120 at 0x2180 // Inputs[3] // { // @2182 stack[-1] // @2182 stack[-3] // @2189 stack[-4] // } 2181 5B JUMPDEST 2182 91 SWAP2 2183 50 POP 2184 61 PUSH2 0x218f 2187 60 PUSH1 0x20 2189 84 DUP5 218A 01 ADD 218B 61 PUSH2 0x2120 218E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2182 stack[-3] = stack[-1] // @2184 stack[-1] = 0x218f // @218A stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x2120, returns to 0x218F label_218F: // Incoming return from call to 0x2120 at 0x218E // Incoming return from call to 0x213C at 0x2273 // Inputs[6] // { // @2190 stack[-2] // @2190 stack[-1] // @2192 stack[-5] // @2194 stack[-3] // @2194 stack[-6] // @2195 stack[-4] // } 218F 5B JUMPDEST 2190 90 SWAP1 2191 50 POP 2192 92 SWAP3 2193 50 POP 2194 92 SWAP3 2195 90 SWAP1 2196 50 POP 2197 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2192 stack[-5] = stack[-1] // @2194 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2198: // Incoming call from 0x043D, returns to 0x043E // Incoming call from 0x03FF, returns to 0x0400 // Inputs[2] // { // @21A0 stack[-1] // @21A1 stack[-2] // } 2198 5B JUMPDEST 2199 60 PUSH1 0x00 219B 80 DUP1 219C 60 PUSH1 0x00 219E 60 PUSH1 0x60 21A0 84 DUP5 21A1 86 DUP7 21A2 03 SUB 21A3 12 SLT 21A4 15 ISZERO 21A5 61 PUSH2 0x21ac 21A8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2199 stack[0] = 0x00 // @219B stack[1] = 0x00 // @219C stack[2] = 0x00 // } // Block ends with conditional jump to 0x21ac, if !(stack[-2] - stack[-1] i< 0x60) label_21A9: // Incoming jump from 0x21A8, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @21A9 stack[-1] // @21AB memory[stack[-1]:stack[-1] + stack[-1]] // } 21A9 80 DUP1 21AA 81 DUP2 21AB FD *REVERT // Stack delta = +0 // Outputs[1] { @21AB revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_21AC: // Incoming jump from 0x21A8, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @21B0 stack[-4] } 21AC 5B JUMPDEST 21AD 61 PUSH2 0x21b5 21B0 84 DUP5 21B1 61 PUSH2 0x2120 21B4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @21AD stack[0] = 0x21b5 // @21B0 stack[1] = stack[-4] // } // Block ends with call to 0x2120, returns to 0x21B5 label_21B5: // Incoming return from call to 0x2120 at 0x21B4 // Inputs[3] // { // @21B6 stack[-4] // @21B6 stack[-1] // @21BD stack[-5] // } 21B5 5B JUMPDEST 21B6 92 SWAP3 21B7 50 POP 21B8 61 PUSH2 0x21c3 21BB 60 PUSH1 0x20 21BD 85 DUP6 21BE 01 ADD 21BF 61 PUSH2 0x2120 21C2 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @21B6 stack[-4] = stack[-1] // @21B8 stack[-1] = 0x21c3 // @21BE stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x2120, returns to 0x21C3 label_21C3: // Incoming return from call to 0x2120 at 0x21C2 // Inputs[8] // { // @21C4 stack[-3] // @21C4 stack[-1] // @21C8 stack[-5] // @21CA msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @21CB stack[-2] // @21CF stack[-6] // @21D1 stack[-7] // @21D1 stack[-4] // } 21C3 5B JUMPDEST 21C4 91 SWAP2 21C5 50 POP 21C6 60 PUSH1 0x40 21C8 84 DUP5 21C9 01 ADD 21CA 35 CALLDATALOAD 21CB 90 SWAP1 21CC 50 POP 21CD 92 SWAP3 21CE 50 POP 21CF 92 SWAP3 21D0 50 POP 21D1 92 SWAP3 21D2 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @21CD stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @21CF stack[-6] = stack[-1] // @21D1 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_21D3: // Incoming call from 0x0639, returns to 0x063A // Inputs[2] // { // @21DC stack[-1] // @21DD stack[-2] // } 21D3 5B JUMPDEST 21D4 60 PUSH1 0x00 21D6 80 DUP1 21D7 60 PUSH1 0x00 21D9 80 DUP1 21DA 60 PUSH1 0x80 21DC 85 DUP6 21DD 87 DUP8 21DE 03 SUB 21DF 12 SLT 21E0 15 ISZERO 21E1 61 PUSH2 0x21e8 21E4 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @21D4 stack[0] = 0x00 // @21D6 stack[1] = 0x00 // @21D7 stack[2] = 0x00 // @21D9 stack[3] = 0x00 // } // Block ends with conditional jump to 0x21e8, if !(stack[-2] - stack[-1] i< 0x80) label_21E5: // Incoming jump from 0x21E4, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @21E5 stack[-1] // @21E7 memory[stack[-1]:stack[-1] + stack[-1]] // } 21E5 80 DUP1 21E6 81 DUP2 21E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @21E7 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_21E8: // Incoming jump from 0x21E4, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @21EC stack[-5] } 21E8 5B JUMPDEST 21E9 61 PUSH2 0x21f1 21EC 85 DUP6 21ED 61 PUSH2 0x2120 21F0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @21E9 stack[0] = 0x21f1 // @21EC stack[1] = stack[-5] // } // Block ends with call to 0x2120, returns to 0x21F1 label_21F1: // Incoming return from call to 0x2120 at 0x21F0 // Inputs[3] // { // @21F2 stack[-1] // @21F2 stack[-5] // @21F9 stack[-6] // } 21F1 5B JUMPDEST 21F2 93 SWAP4 21F3 50 POP 21F4 61 PUSH2 0x21ff 21F7 60 PUSH1 0x20 21F9 86 DUP7 21FA 01 ADD 21FB 61 PUSH2 0x2120 21FE 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @21F2 stack[-5] = stack[-1] // @21F4 stack[-1] = 0x21ff // @21FA stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x2120, returns to 0x21FF label_21FF: // Incoming return from call to 0x2120 at 0x21FE // Inputs[6] // { // @2200 stack[-1] // @2200 stack[-4] // @2204 stack[-6] // @2206 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2207 stack[-3] // @220D msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 21FF 5B JUMPDEST 2200 92 SWAP3 2201 50 POP 2202 60 PUSH1 0x40 2204 85 DUP6 2205 01 ADD 2206 35 CALLDATALOAD 2207 91 SWAP2 2208 50 POP 2209 60 PUSH1 0x60 220B 85 DUP6 220C 01 ADD 220D 35 CALLDATALOAD 220E 60 PUSH1 0x01 2210 60 PUSH1 0x01 2212 60 PUSH1 0x40 2214 1B SHL 2215 03 SUB 2216 81 DUP2 2217 11 GT 2218 15 ISZERO 2219 61 PUSH2 0x2220 221C 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2200 stack[-4] = stack[-1] // @2207 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @220D stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x2220, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) label_221D: // Incoming jump from 0x221C, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @221D stack[-2] // @221F memory[stack[-2]:stack[-2] + stack[-2]] // } 221D 81 DUP2 221E 82 DUP3 221F FD *REVERT // Stack delta = +0 // Outputs[1] { @221F revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2220: // Incoming jump from 0x221C, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2221 stack[-6] // @2222 stack[-1] // @2227 stack[-7] // } 2220 5B JUMPDEST 2221 85 DUP6 2222 01 ADD 2223 60 PUSH1 0x1f 2225 81 DUP2 2226 01 ADD 2227 87 DUP8 2228 13 SGT 2229 61 PUSH2 0x2230 222C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2222 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x2230, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_222D: // Incoming jump from 0x222C, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[2] // { // @222D stack[-2] // @222F memory[stack[-2]:stack[-2] + stack[-2]] // } 222D 81 DUP2 222E 82 DUP3 222F FD *REVERT // Stack delta = +0 // Outputs[1] { @222F revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2230: // Incoming jump from 0x222C, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @2234 stack[-7] // @2235 stack[-1] // @2236 msg.data[stack[-1]:stack[-1] + 0x20] // } 2230 5B JUMPDEST 2231 61 PUSH2 0x223f 2234 87 DUP8 2235 82 DUP3 2236 35 CALLDATALOAD 2237 60 PUSH1 0x20 2239 84 DUP5 223A 01 ADD 223B 61 PUSH2 0x20ab 223E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2231 stack[0] = 0x223f // @2234 stack[1] = stack[-7] // @2236 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @223A stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x20ab, returns to 0x223F label_223F: // Incoming return from call to 0x20AB at 0x223E // Inputs[8] // { // @2240 stack[-1] // @2240 stack[-3] // @2243 stack[-6] // @2244 stack[-9] // @2245 stack[-5] // @2246 stack[-8] // @2248 stack[-7] // @2248 stack[-4] // } 223F 5B JUMPDEST 2240 91 SWAP2 2241 50 POP 2242 50 POP 2243 92 SWAP3 2244 95 SWAP6 2245 91 SWAP2 2246 94 SWAP5 2247 50 POP 2248 92 SWAP3 2249 50 POP 224A 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @2243 stack[-6] = stack[-1] // @2244 stack[-9] = stack[-6] // @2246 stack[-8] = stack[-5] // @2248 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_224B: // Incoming call from 0x0606, returns to 0x0607 // Inputs[2] // { // @2251 stack[-1] // @2252 stack[-2] // } 224B 5B JUMPDEST 224C 60 PUSH1 0x00 224E 80 DUP1 224F 60 PUSH1 0x40 2251 83 DUP4 2252 85 DUP6 2253 03 SUB 2254 12 SLT 2255 15 ISZERO 2256 61 PUSH2 0x225d 2259 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @224C stack[0] = 0x00 // @224E stack[1] = 0x00 // } // Block ends with conditional jump to 0x225d, if !(stack[-2] - stack[-1] i< 0x40) label_225A: // Incoming jump from 0x2259, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @225A stack[-2] // @225C memory[stack[-2]:stack[-2] + stack[-2]] // } 225A 81 DUP2 225B 82 DUP3 225C FD *REVERT // Stack delta = +0 // Outputs[1] { @225C revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_225D: // Incoming jump from 0x2259, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2261 stack[-3] } 225D 5B JUMPDEST 225E 61 PUSH2 0x2266 2261 83 DUP4 2262 61 PUSH2 0x2120 2265 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @225E stack[0] = 0x2266 // @2261 stack[1] = stack[-3] // } // Block ends with call to 0x2120, returns to 0x2266 label_2266: // Incoming return from call to 0x2120 at 0x2265 // Inputs[3] // { // @2267 stack[-3] // @2267 stack[-1] // @226E stack[-4] // } 2266 5B JUMPDEST 2267 91 SWAP2 2268 50 POP 2269 61 PUSH2 0x218f 226C 60 PUSH1 0x20 226E 84 DUP5 226F 01 ADD 2270 61 PUSH2 0x213c 2273 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2267 stack[-3] = stack[-1] // @2269 stack[-1] = 0x218f // @226F stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x213c, returns to 0x218F label_2274: // Incoming call from 0x036C, returns to 0x036D // Inputs[2] // { // @227A stack[-1] // @227B stack[-2] // } 2274 5B JUMPDEST 2275 60 PUSH1 0x00 2277 80 DUP1 2278 60 PUSH1 0x40 227A 83 DUP4 227B 85 DUP6 227C 03 SUB 227D 12 SLT 227E 15 ISZERO 227F 61 PUSH2 0x2286 2282 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2275 stack[0] = 0x00 // @2277 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2286, if !(stack[-2] - stack[-1] i< 0x40) label_2283: // Incoming jump from 0x2282, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2283 stack[-2] // @2285 memory[stack[-2]:stack[-2] + stack[-2]] // } 2283 81 DUP2 2284 82 DUP3 2285 FD *REVERT // Stack delta = +0 // Outputs[1] { @2285 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2286: // Incoming jump from 0x2282, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @228A stack[-3] } 2286 5B JUMPDEST 2287 61 PUSH2 0x228f 228A 83 DUP4 228B 61 PUSH2 0x2120 228E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2287 stack[0] = 0x228f // @228A stack[1] = stack[-3] // } // Block ends with call to 0x2120, returns to 0x228F label_228F: // Incoming return from call to 0x2120 at 0x228E // Inputs[5] // { // @2290 stack[-1] // @2290 stack[-6] // @2293 stack[-4] // @2297 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @2298 stack[-5] // } 228F 5B JUMPDEST 2290 94 SWAP5 2291 60 PUSH1 0x20 2293 93 SWAP4 2294 90 SWAP1 2295 93 SWAP4 2296 01 ADD 2297 35 CALLDATALOAD 2298 93 SWAP4 2299 50 POP 229A 50 POP 229B 50 POP 229C 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2290 stack[-6] = stack[-1] // @2298 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_229D: // Incoming call from 0x0619, returns to 0x061A // Inputs[2] // { // @22A5 stack[-1] // @22A6 stack[-2] // } 229D 5B JUMPDEST 229E 60 PUSH1 0x00 22A0 80 DUP1 22A1 60 PUSH1 0x00 22A3 60 PUSH1 0x40 22A5 84 DUP5 22A6 86 DUP7 22A7 03 SUB 22A8 12 SLT 22A9 15 ISZERO 22AA 61 PUSH2 0x22b1 22AD 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @229E stack[0] = 0x00 // @22A0 stack[1] = 0x00 // @22A1 stack[2] = 0x00 // } // Block ends with conditional jump to 0x22b1, if !(stack[-2] - stack[-1] i< 0x40) label_22AE: // Incoming jump from 0x22AD, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @22AE stack[-3] // @22B0 memory[stack[-3]:stack[-3] + stack[-3]] // } 22AE 82 DUP3 22AF 83 DUP4 22B0 FD *REVERT // Stack delta = +0 // Outputs[1] { @22B0 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_22B1: // Incoming jump from 0x22AD, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @22B2 stack[-4] // @22B3 msg.data[stack[-4]:stack[-4] + 0x20] // } 22B1 5B JUMPDEST 22B2 83 DUP4 22B3 35 CALLDATALOAD 22B4 60 PUSH1 0x01 22B6 60 PUSH1 0x01 22B8 60 PUSH1 0x40 22BA 1B SHL 22BB 03 SUB 22BC 80 DUP1 22BD 82 DUP3 22BE 11 GT 22BF 15 ISZERO 22C0 61 PUSH2 0x22c7 22C3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @22B3 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @22BB stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x22c7, if !(msg.data[stack[-4]:stack[-4] + 0x20] > (0x01 << 0x40) - 0x01) label_22C4: // Incoming jump from 0x22C3, if not !(msg.data[stack[-4]:stack[-4] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @22C4 stack[-5] // @22C6 memory[stack[-5]:stack[-5] + stack[-5]] // } 22C4 84 DUP5 22C5 85 DUP6 22C6 FD *REVERT // Stack delta = +0 // Outputs[1] { @22C6 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_22C7: // Incoming jump from 0x22C3, if !(msg.data[stack[-4]:stack[-4] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @22C8 stack[-2] // @22C9 stack[-6] // @22CD stack[-7] // } 22C7 5B JUMPDEST 22C8 81 DUP2 22C9 86 DUP7 22CA 01 ADD 22CB 91 SWAP2 22CC 50 POP 22CD 86 DUP7 22CE 60 PUSH1 0x1f 22D0 83 DUP4 22D1 01 ADD 22D2 12 SLT 22D3 61 PUSH2 0x22da 22D6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @22CB stack[-2] = stack[-6] + stack[-2] } // Block ends with conditional jump to 0x22da, if stack[-6] + stack[-2] + 0x1f i< stack[-7] label_22D7: // Incoming jump from 0x22D6, if not stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[2] // { // @22D7 stack[-5] // @22D9 memory[stack[-5]:stack[-5] + stack[-5]] // } 22D7 84 DUP5 22D8 85 DUP6 22D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @22D9 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_22DA: // Incoming jump from 0x22D6, if stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[3] // { // @22DB stack[-2] // @22DC msg.data[stack[-2]:stack[-2] + 0x20] // @22DD stack[-1] // } 22DA 5B JUMPDEST 22DB 81 DUP2 22DC 35 CALLDATALOAD 22DD 81 DUP2 22DE 81 DUP2 22DF 11 GT 22E0 15 ISZERO 22E1 61 PUSH2 0x22e8 22E4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22DC stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x22e8, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_22E5: // Incoming jump from 0x22E4, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[2] // { // @22E5 stack[-6] // @22E7 memory[stack[-6]:stack[-6] + stack[-6]] // } 22E5 85 DUP6 22E6 86 DUP7 22E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @22E7 revert(memory[stack[-6]:stack[-6] + stack[-6]]); } // Block terminates label_22E8: // Incoming jump from 0x22E4, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @22E9 stack[-8] // @22EC stack[-1] // @22F0 stack[-3] // } 22E8 5B JUMPDEST 22E9 87 DUP8 22EA 60 PUSH1 0x20 22EC 82 DUP3 22ED 60 PUSH1 0x05 22EF 1B SHL 22F0 85 DUP6 22F1 01 ADD 22F2 01 ADD 22F3 11 GT 22F4 15 ISZERO 22F5 61 PUSH2 0x22fc 22F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x22fc, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-8]) label_22F9: // Incoming jump from 0x22F8, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-8]) // Inputs[2] // { // @22F9 stack[-6] // @22FB memory[stack[-6]:stack[-6] + stack[-6]] // } 22F9 85 DUP6 22FA 86 DUP7 22FB FD *REVERT // Stack delta = +0 // Outputs[1] { @22FB revert(memory[stack[-6]:stack[-6] + stack[-6]]); } // Block terminates label_22FC: // Incoming jump from 0x22F8, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-8]) // Inputs[8] // { // @22FF stack[-3] // @2302 stack[-9] // @2303 stack[-1] // @2304 stack[-8] // @2306 stack[-7] // @2307 stack[-2] // @230A msg.data[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] // @230C stack[-6] // } 22FC 5B JUMPDEST 22FD 60 PUSH1 0x20 22FF 92 SWAP3 2300 83 DUP4 2301 01 ADD 2302 98 SWAP9 2303 90 SWAP1 2304 97 SWAP8 2305 50 POP 2306 95 SWAP6 2307 90 SWAP1 2308 91 SWAP2 2309 01 ADD 230A 35 CALLDATALOAD 230B 94 SWAP5 230C 93 SWAP4 230D 50 POP 230E 50 POP 230F 50 POP 2310 50 POP 2311 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @2302 stack[-9] = 0x20 + stack[-3] // @2304 stack[-8] = stack[-1] // @230B stack[-7] = msg.data[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] // } // Block ends with unconditional jump to stack[-9] label_2312: // Incoming call from 0x05BE, returns to 0x05BF // Incoming call from 0x02BB, returns to 0x02BC // Incoming call from 0x052B, returns to 0x052C // Inputs[2] // { // @2317 stack[-1] // @2318 stack[-2] // } 2312 5B JUMPDEST 2313 60 PUSH1 0x00 2315 60 PUSH1 0x20 2317 82 DUP3 2318 84 DUP5 2319 03 SUB 231A 12 SLT 231B 15 ISZERO 231C 61 PUSH2 0x2323 231F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2313 stack[0] = 0x00 } // Block ends with conditional jump to 0x2323, if !(stack[-2] - stack[-1] i< 0x20) label_2320: // Incoming jump from 0x231F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2320 stack[-1] // @2322 memory[stack[-1]:stack[-1] + stack[-1]] // } 2320 80 DUP1 2321 81 DUP2 2322 FD *REVERT // Stack delta = +0 // Outputs[1] { @2322 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2323: // Incoming jump from 0x231F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2327 stack[-2] } 2323 5B JUMPDEST 2324 61 PUSH2 0x1549 2327 82 DUP3 2328 61 PUSH2 0x213c 232B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2324 stack[0] = 0x1549 // @2327 stack[1] = stack[-2] // } // Block ends with call to 0x213c, returns to 0x1549 label_232C: // Incoming call from 0x05E6, returns to 0x05E7 // Incoming call from 0x054B, returns to 0x054C // Incoming call from 0x068E, returns to 0x068F // Incoming call from 0x045D, returns to 0x045E // Incoming call from 0x02FF, returns to 0x0300 // Incoming call from 0x050B, returns to 0x050C // Incoming call from 0x07B3, returns to 0x07B4 // Incoming call from 0x034C, returns to 0x034D // Incoming call from 0x066E, returns to 0x066F // Inputs[2] // { // @2331 stack[-1] // @2332 stack[-2] // } 232C 5B JUMPDEST 232D 60 PUSH1 0x00 232F 60 PUSH1 0x20 2331 82 DUP3 2332 84 DUP5 2333 03 SUB 2334 12 SLT 2335 15 ISZERO 2336 61 PUSH2 0x233d 2339 57 *JUMPI // Stack delta = +1 // Outputs[1] { @232D stack[0] = 0x00 } // Block ends with conditional jump to 0x233d, if !(stack[-2] - stack[-1] i< 0x20) label_233A: // Incoming jump from 0x2339, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @233A stack[-1] // @233C memory[stack[-1]:stack[-1] + stack[-1]] // } 233A 80 DUP1 233B 81 DUP2 233C FD *REVERT // Stack delta = +0 // Outputs[1] { @233C revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_233D: // Incoming jump from 0x2339, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @233F msg.data[stack[-2]:stack[-2] + 0x20] // @233F stack[-2] // @2340 stack[-4] // @2341 stack[-3] // } 233D 5B JUMPDEST 233E 50 POP 233F 35 CALLDATALOAD 2340 91 SWAP2 2341 90 SWAP1 2342 50 POP 2343 56 *JUMP // Stack delta = -3 // Outputs[1] { @2340 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_2344: // Incoming call from 0x0286, returns to 0x0287 // Inputs[2] // { // @2349 stack[-1] // @234A stack[-2] // } 2344 5B JUMPDEST 2345 60 PUSH1 0x00 2347 60 PUSH1 0x20 2349 82 DUP3 234A 84 DUP5 234B 03 SUB 234C 12 SLT 234D 15 ISZERO 234E 61 PUSH2 0x2355 2351 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2345 stack[0] = 0x00 } // Block ends with conditional jump to 0x2355, if !(stack[-2] - stack[-1] i< 0x20) label_2352: // Incoming jump from 0x2351, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2352 stack[-1] // @2354 memory[stack[-1]:stack[-1] + stack[-1]] // } 2352 80 DUP1 2353 81 DUP2 2354 FD *REVERT // Stack delta = +0 // Outputs[1] { @2354 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2355: // Incoming jump from 0x2351, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2356 stack[-2] // @2357 msg.data[stack[-2]:stack[-2] + 0x20] // } 2355 5B JUMPDEST 2356 81 DUP2 2357 35 CALLDATALOAD 2358 61 PUSH2 0x1549 235B 81 DUP2 235C 61 PUSH2 0x26af 235F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2357 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2358 stack[1] = 0x1549 // @235B stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x26af, returns to 0x1549 label_2360: // Incoming jump from 0x1C13 // Inputs[2] // { // @2365 stack[-1] // @2366 stack[-2] // } 2360 5B JUMPDEST 2361 60 PUSH1 0x00 2363 60 PUSH1 0x20 2365 82 DUP3 2366 84 DUP5 2367 03 SUB 2368 12 SLT 2369 15 ISZERO 236A 61 PUSH2 0x2371 236D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2361 stack[0] = 0x00 } // Block ends with conditional jump to 0x2371, if !(stack[-2] - stack[-1] i< 0x20) label_236E: // Incoming jump from 0x236D, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @236E stack[-1] // @2370 memory[stack[-1]:stack[-1] + stack[-1]] // } 236E 80 DUP1 236F 81 DUP2 2370 FD *REVERT // Stack delta = +0 // Outputs[1] { @2370 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2371: // Incoming jump from 0x236D, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2372 stack[-2] // @2373 memory[stack[-2]:stack[-2] + 0x20] // } 2371 5B JUMPDEST 2372 81 DUP2 2373 51 MLOAD 2374 61 PUSH2 0x1549 2377 81 DUP2 2378 61 PUSH2 0x26af 237B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2373 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2374 stack[1] = 0x1549 // @2377 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x26af, returns to 0x1549 label_237C: // Incoming call from 0x06C4, returns to 0x06C5 // Incoming call from 0x0773, returns to 0x0774 // Incoming call from 0x04B7, returns to 0x04B8 // Inputs[2] // { // @2381 stack[-1] // @2382 stack[-2] // } 237C 5B JUMPDEST 237D 60 PUSH1 0x00 237F 60 PUSH1 0x20 2381 82 DUP3 2382 84 DUP5 2383 03 SUB 2384 12 SLT 2385 15 ISZERO 2386 61 PUSH2 0x238d 2389 57 *JUMPI // Stack delta = +1 // Outputs[1] { @237D stack[0] = 0x00 } // Block ends with conditional jump to 0x238d, if !(stack[-2] - stack[-1] i< 0x20) label_238A: // Incoming jump from 0x2389, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @238A stack[-1] // @238C memory[stack[-1]:stack[-1] + stack[-1]] // } 238A 80 DUP1 238B 81 DUP2 238C FD *REVERT // Stack delta = +0 // Outputs[1] { @238C revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_238D: // Incoming jump from 0x2389, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @238E stack[-2] // @238F msg.data[stack[-2]:stack[-2] + 0x20] // } 238D 5B JUMPDEST 238E 81 DUP2 238F 35 CALLDATALOAD 2390 60 PUSH1 0x01 2392 60 PUSH1 0x01 2394 60 PUSH1 0x40 2396 1B SHL 2397 03 SUB 2398 81 DUP2 2399 11 GT 239A 15 ISZERO 239B 61 PUSH2 0x23a2 239E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @238F stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x23a2, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_239F: // Incoming jump from 0x239E, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @239F stack[-2] // @23A1 memory[stack[-2]:stack[-2] + stack[-2]] // } 239F 81 DUP2 23A0 82 DUP3 23A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @23A1 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_23A2: // Incoming jump from 0x239E, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @23A3 stack[-3] // @23A4 stack[-1] // @23A9 stack[-4] // } 23A2 5B JUMPDEST 23A3 82 DUP3 23A4 01 ADD 23A5 60 PUSH1 0x1f 23A7 81 DUP2 23A8 01 ADD 23A9 84 DUP5 23AA 13 SGT 23AB 61 PUSH2 0x23b2 23AE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @23A4 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x23b2, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_23AF: // Incoming jump from 0x23AE, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[2] // { // @23AF stack[-2] // @23B1 memory[stack[-2]:stack[-2] + stack[-2]] // } 23AF 81 DUP2 23B0 82 DUP3 23B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @23B1 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_23B2: // Incoming jump from 0x23AE, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @23B6 stack[-4] // @23B7 stack[-1] // @23B8 msg.data[stack[-1]:stack[-1] + 0x20] // } 23B2 5B JUMPDEST 23B3 61 PUSH2 0x1c88 23B6 84 DUP5 23B7 82 DUP3 23B8 35 CALLDATALOAD 23B9 60 PUSH1 0x20 23BB 84 DUP5 23BC 01 ADD 23BD 61 PUSH2 0x20ab 23C0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @23B3 stack[0] = 0x1c88 // @23B6 stack[1] = stack[-4] // @23B8 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @23BC stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x20ab, returns to 0x1C88 label_23C1: // Incoming call from 0x253F, returns to 0x1549 // Incoming call from 0x24E1, returns to 0x24E2 // Inputs[3] // { // @23C4 stack[-1] // @23C5 memory[stack[-1]:stack[-1] + 0x20] // @23C7 stack[-2] // } 23C1 5B JUMPDEST 23C2 60 PUSH1 0x00 23C4 81 DUP2 23C5 51 MLOAD 23C6 80 DUP1 23C7 84 DUP5 23C8 52 MSTORE 23C9 61 PUSH2 0x23d9 23CC 81 DUP2 23CD 60 PUSH1 0x20 23CF 86 DUP7 23D0 01 ADD 23D1 60 PUSH1 0x20 23D3 86 DUP7 23D4 01 ADD 23D5 61 PUSH2 0x25d7 23D8 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @23C2 stack[0] = 0x00 // @23C5 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @23C8 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @23C9 stack[2] = 0x23d9 // @23CC stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @23D0 stack[4] = stack[-2] + 0x20 // @23D4 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x25d7, returns to 0x23D9 label_23D9: // Incoming return from call to 0x25D7 at 0x23D8 // Inputs[4] // { // @23DC stack[-1] // @23E1 stack[-4] // @23E2 stack[-2] // @23E8 stack[-5] // } 23D9 5B JUMPDEST 23DA 60 PUSH1 0x1f 23DC 01 ADD 23DD 60 PUSH1 0x1f 23DF 19 NOT 23E0 16 AND 23E1 92 SWAP3 23E2 90 SWAP1 23E3 92 SWAP3 23E4 01 ADD 23E5 60 PUSH1 0x20 23E7 01 ADD 23E8 92 SWAP3 23E9 91 SWAP2 23EA 50 POP 23EB 50 POP 23EC 56 *JUMP // Stack delta = -4 // Outputs[1] { @23E8 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] 23ED 5B JUMPDEST 23EE 60 PUSH1 0x00 23F0 84 DUP5 23F1 51 MLOAD 23F2 60 PUSH1 0x20 23F4 61 PUSH2 0x2400 23F7 82 DUP3 23F8 85 DUP6 23F9 83 DUP4 23FA 8A DUP11 23FB 01 ADD 23FC 61 PUSH2 0x25d7 23FF 56 *JUMP 2400 5B JUMPDEST 2401 85 DUP6 2402 51 MLOAD 2403 91 SWAP2 2404 84 DUP5 2405 01 ADD 2406 91 SWAP2 2407 61 PUSH2 0x2413 240A 81 DUP2 240B 84 DUP5 240C 84 DUP5 240D 8A DUP11 240E 01 ADD 240F 61 PUSH2 0x25d7 2412 56 *JUMP 2413 5B JUMPDEST 2414 85 DUP6 2415 54 SLOAD 2416 92 SWAP3 2417 01 ADD 2418 91 SWAP2 2419 83 DUP4 241A 90 SWAP1 241B 60 PUSH1 0x01 241D 81 DUP2 241E 81 DUP2 241F 1C SHR 2420 90 SWAP1 2421 80 DUP1 2422 83 DUP4 2423 16 AND 2424 80 DUP1 2425 61 PUSH2 0x242f 2428 57 *JUMPI 2429 60 PUSH1 0x7f 242B 83 DUP4 242C 16 AND 242D 92 SWAP3 242E 50 POP 242F 5B JUMPDEST 2430 85 DUP6 2431 83 DUP4 2432 10 LT 2433 81 DUP2 2434 14 EQ 2435 15 ISZERO 2436 61 PUSH2 0x244d 2439 57 *JUMPI 243A 63 PUSH4 0x4e487b71 243F 60 PUSH1 0xe0 2441 1B SHL 2442 88 DUP9 2443 52 MSTORE 2444 60 PUSH1 0x22 2446 60 PUSH1 0x04 2448 52 MSTORE 2449 60 PUSH1 0x24 244B 88 DUP9 244C FD *REVERT 244D 5B JUMPDEST 244E 80 DUP1 244F 80 DUP1 2450 15 ISZERO 2451 61 PUSH2 0x2461 2454 57 *JUMPI 2455 60 PUSH1 0x01 2457 81 DUP2 2458 14 EQ 2459 61 PUSH2 0x2472 245C 57 *JUMPI 245D 61 PUSH2 0x249e 2460 56 *JUMP 2461 5B JUMPDEST 2462 60 PUSH1 0xff 2464 19 NOT 2465 85 DUP6 2466 16 AND 2467 88 DUP9 2468 52 MSTORE 2469 83 DUP4 246A 88 DUP9 246B 01 ADD 246C 95 SWAP6 246D 50 POP 246E 61 PUSH2 0x249e 2471 56 *JUMP 2472 5B JUMPDEST 2473 60 PUSH1 0x00 2475 8B DUP12 2476 81 DUP2 2477 52 MSTORE 2478 60 PUSH1 0x20 247A 90 SWAP1 247B 20 SHA3 247C 89 DUP10 247D 5B JUMPDEST 247E 85 DUP6 247F 81 DUP2 2480 10 LT 2481 15 ISZERO 2482 61 PUSH2 0x2496 2485 57 *JUMPI 2486 81 DUP2 2487 54 SLOAD 2488 8A DUP11 2489 82 DUP3 248A 01 ADD 248B 52 MSTORE 248C 90 SWAP1 248D 84 DUP5 248E 01 ADD 248F 90 SWAP1 2490 88 DUP9 2491 01 ADD 2492 61 PUSH2 0x247d 2495 56 *JUMP 2496 5B JUMPDEST 2497 50 POP 2498 50 POP 2499 83 DUP4 249A 88 DUP9 249B 01 ADD 249C 95 SWAP6 249D 50 POP 249E 5B JUMPDEST 249F 50 POP 24A0 93 SWAP4 24A1 9B SWAP12 24A2 9A SWAP11 24A3 50 POP 24A4 50 POP 24A5 50 POP 24A6 50 POP 24A7 50 POP 24A8 50 POP 24A9 50 POP 24AA 50 POP 24AB 50 POP 24AC 50 POP 24AD 50 POP 24AE 56 *JUMP label_24AF: // Incoming call from 0x1BCC, returns to 0x1BCD // Inputs[5] // { // @24B8 stack[-5] // @24BB stack[-1] // @24BD stack[-4] // @24C8 stack[-3] // @24DD stack[-2] // } 24AF 5B JUMPDEST 24B0 60 PUSH1 0x01 24B2 60 PUSH1 0x01 24B4 60 PUSH1 0xa0 24B6 1B SHL 24B7 03 SUB 24B8 85 DUP6 24B9 81 DUP2 24BA 16 AND 24BB 82 DUP3 24BC 52 MSTORE 24BD 84 DUP5 24BE 16 AND 24BF 60 PUSH1 0x20 24C1 82 DUP3 24C2 01 ADD 24C3 52 MSTORE 24C4 60 PUSH1 0x40 24C6 81 DUP2 24C7 01 ADD 24C8 83 DUP4 24C9 90 SWAP1 24CA 52 MSTORE 24CB 60 PUSH1 0x80 24CD 60 PUSH1 0x60 24CF 82 DUP3 24D0 01 ADD 24D1 81 DUP2 24D2 90 SWAP1 24D3 52 MSTORE 24D4 60 PUSH1 0x00 24D6 90 SWAP1 24D7 61 PUSH2 0x24e2 24DA 90 SWAP1 24DB 83 DUP4 24DC 01 ADD 24DD 84 DUP5 24DE 61 PUSH2 0x23c1 24E1 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @24BC memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @24C3 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @24CA memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @24D3 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @24D6 stack[0] = 0x00 // @24DA stack[1] = 0x24e2 // @24DC stack[2] = stack[-1] + 0x80 // @24DD stack[3] = stack[-2] // } // Block ends with call to 0x23c1, returns to 0x24E2 label_24E2: // Incoming return from call to 0x23C1 at 0x24E1 // Inputs[3] // { // @24E3 stack[-1] // @24E3 stack[-8] // @24E4 stack[-7] // } 24E2 5B JUMPDEST 24E3 96 SWAP7 24E4 95 SWAP6 24E5 50 POP 24E6 50 POP 24E7 50 POP 24E8 50 POP 24E9 50 POP 24EA 50 POP 24EB 56 *JUMP // Stack delta = -7 // Outputs[1] { @24E3 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_24EC: // Incoming call from 0x137A, returns to 0x137B // Inputs[2] // { // @24F0 stack[-1] // @24F4 stack[-3] // } 24EC 5B JUMPDEST 24ED 60 PUSH1 0x40 24EF 80 DUP1 24F0 82 DUP3 24F1 52 MSTORE 24F2 81 DUP2 24F3 01 ADD 24F4 83 DUP4 24F5 90 SWAP1 24F6 52 MSTORE 24F7 60 PUSH1 0x00 24F9 60 PUSH1 0x01 24FB 60 PUSH1 0x01 24FD 60 PUSH1 0xfb 24FF 1B SHL 2500 03 SUB 2501 84 DUP5 2502 11 GT 2503 15 ISZERO 2504 61 PUSH2 0x250b 2507 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @24F1 memory[stack[-1]:stack[-1] + 0x20] = 0x40 // @24F6 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @24F7 stack[0] = 0x00 // } // Block ends with conditional jump to 0x250b, if !(stack[-3] > (0x01 << 0xfb) - 0x01) label_2508: // Incoming jump from 0x2507, if not !(stack[-3] > (0x01 << 0xfb) - 0x01) // Inputs[2] // { // @2508 stack[-1] // @250A memory[stack[-1]:stack[-1] + stack[-1]] // } 2508 80 DUP1 2509 81 DUP2 250A FD *REVERT // Stack delta = +0 // Outputs[1] { @250A revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_250B: // Incoming jump from 0x2507, if !(stack[-3] > (0x01 << 0xfb) - 0x01) // Inputs[7] // { // @250C stack[-4] // @2511 stack[-5] // @2514 stack[-2] // @2516 msg.data[stack[-5]:stack[-5] + stack[-4] << 0x05] // @251C stack[-1] // @2524 stack[-3] // @2528 stack[-6] // } 250B 5B JUMPDEST 250C 83 DUP4 250D 60 PUSH1 0x05 250F 1B SHL 2510 80 DUP1 2511 86 DUP7 2512 60 PUSH1 0x60 2514 85 DUP6 2515 01 ADD 2516 37 CALLDATACOPY 2517 82 DUP3 2518 01 ADD 2519 60 PUSH1 0x60 251B 01 ADD 251C 90 SWAP1 251D 81 DUP2 251E 52 MSTORE 251F 60 PUSH1 0x20 2521 90 SWAP1 2522 91 SWAP2 2523 01 ADD 2524 91 SWAP2 2525 90 SWAP1 2526 91 SWAP2 2527 52 MSTORE 2528 92 SWAP3 2529 91 SWAP2 252A 50 POP 252B 50 POP 252C 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @2516 memory[stack[-2] + 0x60:stack[-2] + 0x60 + stack[-4] << 0x05] = msg.data[stack[-5]:stack[-5] + stack[-4] << 0x05] // @251E memory[0x60 + stack[-2] + (stack[-4] << 0x05):0x60 + stack[-2] + (stack[-4] << 0x05) + 0x20] = stack[-1] // @2527 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @2528 stack[-6] = 0x60 + stack[-2] + (stack[-4] << 0x05) // } // Block ends with unconditional jump to stack[-6] label_252D: // Incoming jump from 0x02E4 // Inputs[2] // { // @2530 stack[-1] // @253B stack[-2] // } 252D 5B JUMPDEST 252E 60 PUSH1 0x20 2530 81 DUP2 2531 52 MSTORE 2532 60 PUSH1 0x00 2534 61 PUSH2 0x1549 2537 60 PUSH1 0x20 2539 83 DUP4 253A 01 ADD 253B 84 DUP5 253C 61 PUSH2 0x23c1 253F 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2531 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2532 stack[0] = 0x00 // @2534 stack[1] = 0x1549 // @253A stack[2] = stack[-1] + 0x20 // @253B stack[3] = stack[-2] // } // Block ends with call to 0x23c1, returns to 0x1549 label_2540: // Incoming call from 0x0D9D, returns to 0x0835 // Incoming call from 0x0B83, returns to 0x0835 // Incoming call from 0x0CB3, returns to 0x0835 // Incoming call from 0x0E80, returns to 0x0835 // Incoming call from 0x1579, returns to 0x0835 // Incoming call from 0x0E4A, returns to 0x0835 // Incoming call from 0x0B00, returns to 0x0835 // Incoming call from 0x174D, returns to 0x0835 // Incoming call from 0x1645, returns to 0x0835 // Incoming call from 0x16B2, returns to 0x0835 // Incoming call from 0x0834, returns to 0x0835 // Incoming call from 0x0D32, returns to 0x0835 // Incoming call from 0x0A13, returns to 0x0835 // Incoming call from 0x0C54, returns to 0x0835 // Incoming call from 0x15D8, returns to 0x0835 // Inputs[2] // { // @2544 stack[-1] // @2573 stack[-2] // } 2540 5B JUMPDEST 2541 60 PUSH1 0x20 2543 80 DUP1 2544 82 DUP3 2545 52 MSTORE 2546 81 DUP2 2547 81 DUP2 2548 01 ADD 2549 52 MSTORE 254A 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 256B 60 PUSH1 0x40 256D 82 DUP3 256E 01 ADD 256F 52 MSTORE 2570 60 PUSH1 0x60 2572 01 ADD 2573 90 SWAP1 2574 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2545 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2549 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @256F memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @2573 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2575: // Incoming call from 0x0F95, returns to 0x0F96 // Incoming call from 0x0F4B, returns to 0x0F4C // Incoming call from 0x1150, returns to 0x1151 // Incoming call from 0x1209, returns to 0x120A // Inputs[2] // { // @2578 stack[-2] // @257A stack[-1] // } 2575 5B JUMPDEST 2576 60 PUSH1 0x00 2578 82 DUP3 2579 19 NOT 257A 82 DUP3 257B 11 GT 257C 15 ISZERO 257D 61 PUSH2 0x2588 2580 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2576 stack[0] = 0x00 } // Block ends with conditional jump to 0x2588, if !(stack[-1] > ~stack[-2]) label_2581: // Incoming jump from 0x2580, if not !(stack[-1] > ~stack[-2]) 2581 61 PUSH2 0x2588 2584 61 PUSH2 0x266d 2587 56 *JUMP // Stack delta = +1 // Outputs[1] { @2581 stack[0] = 0x2588 } // Block ends with unconditional jump to 0x266d label_2588: // Incoming jump from 0x2580, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @258A stack[-3] // @258A stack[-2] // @258B stack[-4] // } 2588 5B JUMPDEST 2589 50 POP 258A 01 ADD 258B 90 SWAP1 258C 56 *JUMP // Stack delta = -3 // Outputs[1] { @258B stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] 258D 5B JUMPDEST 258E 60 PUSH1 0x00 2590 82 DUP3 2591 61 PUSH2 0x259c 2594 57 *JUMPI 2595 61 PUSH2 0x259c 2598 61 PUSH2 0x2683 259B 56 *JUMP 259C 5B JUMPDEST 259D 50 POP 259E 04 DIV 259F 90 SWAP1 25A0 56 *JUMP label_25A1: // Incoming call from 0x1315, returns to 0x1316 // Incoming call from 0x0FEB, returns to 0x0FEC // Inputs[2] // { // @25A4 stack[-1] // @25A9 stack[-2] // } 25A1 5B JUMPDEST 25A2 60 PUSH1 0x00 25A4 81 DUP2 25A5 60 PUSH1 0x00 25A7 19 NOT 25A8 04 DIV 25A9 83 DUP4 25AA 11 GT 25AB 82 DUP3 25AC 15 ISZERO 25AD 15 ISZERO 25AE 16 AND 25AF 15 ISZERO 25B0 61 PUSH2 0x25bb 25B3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25A2 stack[0] = 0x00 } // Block ends with conditional jump to 0x25bb, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_25B4: // Incoming jump from 0x25B3, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 25B4 61 PUSH2 0x25bb 25B7 61 PUSH2 0x266d 25BA 56 *JUMP // Stack delta = +1 // Outputs[1] { @25B4 stack[0] = 0x25bb } // Block ends with unconditional jump to 0x266d label_25BB: // Incoming jump from 0x25B3, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @25BD stack[-3] // @25BD stack[-2] // @25BE stack[-4] // } 25BB 5B JUMPDEST 25BC 50 POP 25BD 02 MUL 25BE 90 SWAP1 25BF 56 *JUMP // Stack delta = -3 // Outputs[1] { @25BE stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] 25C0 5B JUMPDEST 25C1 60 PUSH1 0x00 25C3 82 DUP3 25C4 82 DUP3 25C5 10 LT 25C6 15 ISZERO 25C7 61 PUSH2 0x25d2 25CA 57 *JUMPI 25CB 61 PUSH2 0x25d2 25CE 61 PUSH2 0x266d 25D1 56 *JUMP 25D2 5B JUMPDEST 25D3 50 POP 25D4 03 SUB 25D5 90 SWAP1 25D6 56 *JUMP label_25D7: // Incoming call from 0x23D8, returns to 0x23D9 // Inputs[1] { @25DB stack[-3] } 25D7 5B JUMPDEST 25D8 60 PUSH1 0x00 25DA 5B JUMPDEST 25DB 83 DUP4 25DC 81 DUP2 25DD 10 LT 25DE 15 ISZERO 25DF 61 PUSH2 0x25f2 25E2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25D8 stack[0] = 0x00 } // Block ends with conditional jump to 0x25f2, if !(0x00 < stack[-3]) label_25E3: // Incoming jump from 0x25E2, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x25E2, if not !(0x00 < stack[-3]) // Inputs[4] // { // @25E3 stack[-2] // @25E4 stack[-1] // @25E6 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @25E7 stack[-3] // } 25E3 81 DUP2 25E4 81 DUP2 25E5 01 ADD 25E6 51 MLOAD 25E7 83 DUP4 25E8 82 DUP3 25E9 01 ADD 25EA 52 MSTORE 25EB 60 PUSH1 0x20 25ED 01 ADD 25EE 61 PUSH2 0x25da 25F1 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @25EA memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @25ED stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x25da label_25F2: // Incoming jump from 0x25E2, if !(stack[-1] < stack[-4]) // Incoming jump from 0x25E2, if !(0x00 < stack[-3]) // Inputs[2] // { // @25F3 stack[-4] // @25F4 stack[-1] // } 25F2 5B JUMPDEST 25F3 83 DUP4 25F4 81 DUP2 25F5 11 GT 25F6 15 ISZERO 25F7 61 PUSH2 0x13d3 25FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13d3, if !(stack[-1] > stack[-4]) label_25FB: // Incoming jump from 0x25FA, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @25FF stack[-4] // @2600 stack[-3] // @2602 stack[-5] // } 25FB 50 POP 25FC 50 POP 25FD 60 PUSH1 0x00 25FF 91 SWAP2 2600 01 ADD 2601 52 MSTORE 2602 56 *JUMP // Stack delta = -5 // Outputs[1] { @2601 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_2603: // Incoming call from 0x0ED0, returns to 0x0895 // Incoming call from 0x0968, returns to 0x0969 // Incoming call from 0x13E5, returns to 0x0969 // Incoming call from 0x08C0, returns to 0x08C1 // Incoming call from 0x201D, returns to 0x201E // Incoming call from 0x0894, returns to 0x0895 // Incoming call from 0x146B, returns to 0x146C // Incoming call from 0x1497, returns to 0x1498 // Incoming call from 0x1C9E, returns to 0x0895 // Incoming call from 0x0994, returns to 0x0995 // Inputs[1] { @2606 stack[-1] } 2603 5B JUMPDEST 2604 60 PUSH1 0x01 2606 81 DUP2 2607 81 DUP2 2608 1C SHR 2609 90 SWAP1 260A 82 DUP3 260B 16 AND 260C 80 DUP1 260D 61 PUSH2 0x2617 2610 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2609 stack[0] = stack[-1] >> 0x01 // @260B stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2617, if stack[-1] & 0x01 label_2611: // Incoming jump from 0x2610, if not stack[-1] & 0x01 // Inputs[2] // { // @2613 stack[-2] // @261C stack[-1] // } 2611 60 PUSH1 0x7f 2613 82 DUP3 2614 16 AND 2615 91 SWAP2 2616 50 POP 2617 5B JUMPDEST 2618 60 PUSH1 0x20 261A 82 DUP3 261B 10 LT 261C 81 DUP2 261D 14 EQ 261E 15 ISZERO 261F 61 PUSH2 0x2638 2622 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2615 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x2638, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_2623: // Incoming jump from 0x2622, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x2622, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @2637 memory[0x00:0x24] } 2623 63 PUSH4 0x4e487b71 2628 60 PUSH1 0xe0 262A 1B SHL 262B 60 PUSH1 0x00 262D 52 MSTORE 262E 60 PUSH1 0x22 2630 60 PUSH1 0x04 2632 52 MSTORE 2633 60 PUSH1 0x24 2635 60 PUSH1 0x00 2637 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @262D memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2632 memory[0x04:0x24] = 0x22 // @2637 revert(memory[0x00:0x24]); // } // Block terminates label_2638: // Incoming jump from 0x2622, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x2622, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @263A stack[-4] // @263A stack[-2] // @263B stack[-3] // } 2638 5B JUMPDEST 2639 50 POP 263A 91 SWAP2 263B 90 SWAP1 263C 50 POP 263D 56 *JUMP // Stack delta = -3 // Outputs[1] { @263A stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_263E: // Incoming call from 0x1E36, returns to 0x1E37 // Incoming call from 0x1E36, returns to 0x1E37 // Inputs[1] { @2644 stack[-1] } 263E 5B JUMPDEST 263F 60 PUSH1 0x00 2641 60 PUSH1 0x00 2643 19 NOT 2644 82 DUP3 2645 14 EQ 2646 15 ISZERO 2647 61 PUSH2 0x2652 264A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @263F stack[0] = 0x00 } // Block ends with conditional jump to 0x2652, if !(stack[-1] == ~0x00) label_264B: // Incoming jump from 0x264A, if not !(stack[-1] == ~0x00) 264B 61 PUSH2 0x2652 264E 61 PUSH2 0x266d 2651 56 *JUMP // Stack delta = +1 // Outputs[1] { @264B stack[0] = 0x2652 } // Block ends with unconditional jump to 0x266d label_2652: // Incoming jump from 0x264A, if !(stack[-1] == ~0x00) // Inputs[2] // { // @2656 stack[-2] // @2657 stack[-3] // } 2652 5B JUMPDEST 2653 50 POP 2654 60 PUSH1 0x01 2656 01 ADD 2657 90 SWAP1 2658 56 *JUMP // Stack delta = -2 // Outputs[1] { @2657 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] 2659 5B JUMPDEST 265A 60 PUSH1 0x00 265C 82 DUP3 265D 61 PUSH2 0x2668 2660 57 *JUMPI 2661 61 PUSH2 0x2668 2664 61 PUSH2 0x2683 2667 56 *JUMP 2668 5B JUMPDEST 2669 50 POP 266A 06 MOD 266B 90 SWAP1 266C 56 *JUMP label_266D: // Incoming jump from 0x25BA // Incoming jump from 0x2587 // Incoming jump from 0x2651 // Inputs[1] { @2682 memory[0x00:0x24] } 266D 5B JUMPDEST 266E 63 PUSH4 0x4e487b71 2673 60 PUSH1 0xe0 2675 1B SHL 2676 60 PUSH1 0x00 2678 52 MSTORE 2679 60 PUSH1 0x11 267B 60 PUSH1 0x04 267D 52 MSTORE 267E 60 PUSH1 0x24 2680 60 PUSH1 0x00 2682 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2678 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @267D memory[0x04:0x24] = 0x11 // @2682 revert(memory[0x00:0x24]); // } // Block terminates 2683 5B JUMPDEST 2684 63 PUSH4 0x4e487b71 2689 60 PUSH1 0xe0 268B 1B SHL 268C 60 PUSH1 0x00 268E 52 MSTORE 268F 60 PUSH1 0x12 2691 60 PUSH1 0x04 2693 52 MSTORE 2694 60 PUSH1 0x24 2696 60 PUSH1 0x00 2698 FD *REVERT label_2699: // Incoming jump from 0x20C4 // Incoming jump from 0x20EC // Inputs[1] { @26AE memory[0x00:0x24] } 2699 5B JUMPDEST 269A 63 PUSH4 0x4e487b71 269F 60 PUSH1 0xe0 26A1 1B SHL 26A2 60 PUSH1 0x00 26A4 52 MSTORE 26A5 60 PUSH1 0x41 26A7 60 PUSH1 0x04 26A9 52 MSTORE 26AA 60 PUSH1 0x24 26AC 60 PUSH1 0x00 26AE FD *REVERT // Stack delta = +0 // Outputs[3] // { // @26A4 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @26A9 memory[0x04:0x24] = 0x41 // @26AE revert(memory[0x00:0x24]); // } // Block terminates label_26AF: // Incoming call from 0x237B, returns to 0x1549 // Incoming call from 0x235F, returns to 0x1549 // Inputs[1] { @26B9 stack[-1] } 26AF 5B JUMPDEST 26B0 60 PUSH1 0x01 26B2 60 PUSH1 0x01 26B4 60 PUSH1 0xe0 26B6 1B SHL 26B7 03 SUB 26B8 19 NOT 26B9 81 DUP2 26BA 16 AND 26BB 81 DUP2 26BC 14 EQ 26BD 61 PUSH2 0x1721 26C0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1721, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_26C1: // Incoming jump from 0x26C0, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @26C4 memory[0x00:0x00] } 26C1 60 PUSH1 0x00 26C3 80 DUP1 26C4 FD *REVERT // Stack delta = +0 // Outputs[1] { @26C4 revert(memory[0x00:0x00]); } // Block terminates 26C5 FE *ASSERT 26C6 A2 LOG2 26C7 64 PUSH5 0x6970667358 26CD 22 22 26CE 12 SLT 26CF 20 SHA3 26D0 F6 F6 26D1 A0 LOG0 26D2 25 25 26D3 95 SWAP6 26D4 60 PUSH1 0xa4 26D6 16 AND 26D7 B1 DUP 26D8 8F DUP16 26D9 03 SUB 26DA 53 MSTORE8 26DB 61 PUSH2 0x0188 26DE F3 *RETURN 26DF 7C PUSH29 0x6e30baee63c3c26623f96eed7944c93764736f6c63430008040033