Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x025c 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x025c, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x4ff39e26 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 0x4ff39e26 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x4ff39e26 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0x8da5cb5b 0024 11 GT 0025 61 PUSH2 0x00b6 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b6, if 0x8da5cb5b > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0x8da5cb5b > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xb8997a97 002F 11 GT 0030 61 PUSH2 0x007a 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007a, if 0xb8997a97 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xb8997a97 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xb8997a97 003A 14 EQ 003B 61 PUSH2 0x06c7 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06c7, if 0xb8997a97 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xb8997a97 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xc54e73e3 0045 14 EQ 0046 61 PUSH2 0x06ff 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06ff, if 0xc54e73e3 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xc54e73e3 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xc87b56dd 0050 14 EQ 0051 61 PUSH2 0x071f 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x071f, if 0xc87b56dd == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xe985e9c5 005B 14 EQ 005C 61 PUSH2 0x073f 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x073f, if 0xe985e9c5 == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf2fde38b 0066 14 EQ 0067 61 PUSH2 0x075f 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x075f, 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 0xfdea8e0b 0071 14 EQ 0072 61 PUSH2 0x077f 0075 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x077f, if 0xfdea8e0b == stack[-1] label_0076: // Incoming jump from 0x0075, if not 0xfdea8e0b == 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 0xb8997a97 > stack[-1] // Inputs[1] { @007B stack[-1] } 007A 5B JUMPDEST 007B 80 DUP1 007C 63 PUSH4 0x8da5cb5b 0081 14 EQ 0082 61 PUSH2 0x063c 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x063c, if 0x8da5cb5b == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0x95d89b41 008C 14 EQ 008D 61 PUSH2 0x065a 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x065a, if 0x95d89b41 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xa22cb465 0097 14 EQ 0098 61 PUSH2 0x066f 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x066f, if 0xa22cb465 == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xa22cb465 == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0xad2f852a 00A2 14 EQ 00A3 61 PUSH2 0x068f 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x068f, if 0xad2f852a == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xad2f852a == stack[-1] // Inputs[1] { @00A7 stack[-1] } 00A7 80 DUP1 00A8 63 PUSH4 0xb88d4fde 00AD 14 EQ 00AE 61 PUSH2 0x06b4 00B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06b4, if 0xb88d4fde == stack[-1] label_00B2: // Incoming jump from 0x00B1, if not 0xb88d4fde == 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 0x8da5cb5b > stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B6 5B JUMPDEST 00B7 80 DUP1 00B8 63 PUSH4 0x6198e339 00BD 11 GT 00BE 61 PUSH2 0x0108 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0108, if 0x6198e339 > stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x6198e339 > stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x6198e339 00C8 14 EQ 00C9 61 PUSH2 0x0592 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0592, if 0x6198e339 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x6198e339 == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0x6352211e 00D3 14 EQ 00D4 61 PUSH2 0x05b2 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b2, if 0x6352211e == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0x6352211e == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0x70a08231 00DE 14 EQ 00DF 61 PUSH2 0x05d2 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d2, if 0x70a08231 == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0x70a08231 == stack[-1] // Inputs[1] { @00E3 stack[-1] } 00E3 80 DUP1 00E4 63 PUSH4 0x715018a6 00E9 14 EQ 00EA 61 PUSH2 0x05f2 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f2, if 0x715018a6 == stack[-1] label_00EE: // Incoming jump from 0x00ED, if not 0x715018a6 == stack[-1] // Inputs[1] { @00EE stack[-1] } 00EE 80 DUP1 00EF 63 PUSH4 0x7cb64759 00F4 14 EQ 00F5 61 PUSH2 0x0607 00F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0607, if 0x7cb64759 == stack[-1] label_00F9: // Incoming jump from 0x00F8, if not 0x7cb64759 == stack[-1] // Inputs[1] { @00F9 stack[-1] } 00F9 80 DUP1 00FA 63 PUSH4 0x8456cb59 00FF 14 EQ 0100 61 PUSH2 0x0627 0103 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0627, if 0x8456cb59 == stack[-1] label_0104: // Incoming jump from 0x0103, if not 0x8456cb59 == 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 0x6198e339 > stack[-1] // Inputs[1] { @0109 stack[-1] } 0108 5B JUMPDEST 0109 80 DUP1 010A 63 PUSH4 0x4ff39e26 010F 14 EQ 0110 61 PUSH2 0x04f3 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f3, if 0x4ff39e26 == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x4ff39e26 == stack[-1] // Inputs[1] { @0114 stack[-1] } 0114 80 DUP1 0115 63 PUSH4 0x55f804b3 011A 14 EQ 011B 61 PUSH2 0x0513 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0513, if 0x55f804b3 == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x55f804b3 == stack[-1] // Inputs[1] { @011F stack[-1] } 011F 80 DUP1 0120 63 PUSH4 0x56e6f655 0125 14 EQ 0126 61 PUSH2 0x0533 0129 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0533, if 0x56e6f655 == stack[-1] label_012A: // Incoming jump from 0x0129, if not 0x56e6f655 == stack[-1] // Inputs[1] { @012A stack[-1] } 012A 80 DUP1 012B 63 PUSH4 0x5a546223 0130 14 EQ 0131 61 PUSH2 0x0553 0134 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0553, if 0x5a546223 == stack[-1] label_0135: // Incoming jump from 0x0134, if not 0x5a546223 == stack[-1] // Inputs[1] { @0135 stack[-1] } 0135 80 DUP1 0136 63 PUSH4 0x5c975abb 013B 14 EQ 013C 61 PUSH2 0x0573 013F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0573, if 0x5c975abb == stack[-1] label_0140: // Incoming jump from 0x013F, if not 0x5c975abb == 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 0x4ff39e26 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0145 stack[-1] } 0144 5B JUMPDEST 0145 80 DUP1 0146 63 PUSH4 0x2db11544 014B 11 GT 014C 61 PUSH2 0x01dd 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01dd, if 0x2db11544 > stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x2db11544 > stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x3ccfd60b 0156 11 GT 0157 61 PUSH2 0x01a1 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a1, if 0x3ccfd60b > stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x3ccfd60b > stack[-1] // Inputs[1] { @015B stack[-1] } 015B 80 DUP1 015C 63 PUSH4 0x3ccfd60b 0161 14 EQ 0162 61 PUSH2 0x0466 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0466, if 0x3ccfd60b == stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @0166 stack[-1] } 0166 80 DUP1 0167 63 PUSH4 0x3f4ba83a 016C 14 EQ 016D 61 PUSH2 0x047b 0170 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x047b, if 0x3f4ba83a == stack[-1] label_0171: // Incoming jump from 0x0170, if not 0x3f4ba83a == stack[-1] // Inputs[1] { @0171 stack[-1] } 0171 80 DUP1 0172 63 PUSH4 0x42842e0e 0177 14 EQ 0178 61 PUSH2 0x0490 017B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0490, if 0x42842e0e == stack[-1] label_017C: // Incoming jump from 0x017B, if not 0x42842e0e == stack[-1] // Inputs[1] { @017C stack[-1] } 017C 80 DUP1 017D 63 PUSH4 0x484b973c 0182 14 EQ 0183 61 PUSH2 0x04a3 0186 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a3, if 0x484b973c == stack[-1] label_0187: // Incoming jump from 0x0186, if not 0x484b973c == stack[-1] // Inputs[1] { @0187 stack[-1] } 0187 80 DUP1 0188 63 PUSH4 0x4bf365df 018D 14 EQ 018E 61 PUSH2 0x04c3 0191 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c3, if 0x4bf365df == stack[-1] label_0192: // Incoming jump from 0x0191, if not 0x4bf365df == stack[-1] // Inputs[1] { @0192 stack[-1] } 0192 80 DUP1 0193 63 PUSH4 0x4f5035e5 0198 14 EQ 0199 61 PUSH2 0x04dd 019C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04dd, if 0x4f5035e5 == stack[-1] label_019D: // Incoming jump from 0x019C, if not 0x4f5035e5 == 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 0x3ccfd60b > stack[-1] // Inputs[1] { @01A2 stack[-1] } 01A1 5B JUMPDEST 01A2 80 DUP1 01A3 63 PUSH4 0x2db11544 01A8 14 EQ 01A9 61 PUSH2 0x03da 01AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03da, if 0x2db11544 == stack[-1] label_01AD: // Incoming jump from 0x01AC, if not 0x2db11544 == stack[-1] // Inputs[1] { @01AD stack[-1] } 01AD 80 DUP1 01AE 63 PUSH4 0x2eb4a7ab 01B3 14 EQ 01B4 61 PUSH2 0x03fa 01B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03fa, if 0x2eb4a7ab == stack[-1] label_01B8: // Incoming jump from 0x01B7, if not 0x2eb4a7ab == stack[-1] // Inputs[1] { @01B8 stack[-1] } 01B8 80 DUP1 01B9 63 PUSH4 0x31faafb4 01BE 14 EQ 01BF 61 PUSH2 0x0410 01C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0410, if 0x31faafb4 == stack[-1] label_01C3: // Incoming jump from 0x01C2, if not 0x31faafb4 == stack[-1] // Inputs[1] { @01C3 stack[-1] } 01C3 80 DUP1 01C4 63 PUSH4 0x32cb6b0c 01C9 14 EQ 01CA 61 PUSH2 0x0430 01CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0430, if 0x32cb6b0c == stack[-1] label_01CE: // Incoming jump from 0x01CD, if not 0x32cb6b0c == stack[-1] // Inputs[1] { @01CE stack[-1] } 01CE 80 DUP1 01CF 63 PUSH4 0x3b035df6 01D4 14 EQ 01D5 61 PUSH2 0x0446 01D8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0446, if 0x3b035df6 == stack[-1] label_01D9: // Incoming jump from 0x01D8, if not 0x3b035df6 == 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 0x2db11544 > stack[-1] // Inputs[1] { @01DE stack[-1] } 01DD 5B JUMPDEST 01DE 80 DUP1 01DF 63 PUSH4 0x18160ddd 01E4 11 GT 01E5 61 PUSH2 0x0224 01E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0224, if 0x18160ddd > stack[-1] label_01E9: // Incoming jump from 0x01E8, if not 0x18160ddd > stack[-1] // Inputs[1] { @01E9 stack[-1] } 01E9 80 DUP1 01EA 63 PUSH4 0x18160ddd 01EF 14 EQ 01F0 61 PUSH2 0x0325 01F3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0325, if 0x18160ddd == stack[-1] label_01F4: // Incoming jump from 0x01F3, if not 0x18160ddd == stack[-1] // Inputs[1] { @01F4 stack[-1] } 01F4 80 DUP1 01F5 63 PUSH4 0x23b872dd 01FA 14 EQ 01FB 61 PUSH2 0x0348 01FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0348, if 0x23b872dd == stack[-1] label_01FF: // Incoming jump from 0x01FE, if not 0x23b872dd == stack[-1] // Inputs[1] { @01FF stack[-1] } 01FF 80 DUP1 0200 63 PUSH4 0x282d3fdf 0205 14 EQ 0206 61 PUSH2 0x035b 0209 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x035b, if 0x282d3fdf == stack[-1] label_020A: // Incoming jump from 0x0209, if not 0x282d3fdf == stack[-1] // Inputs[1] { @020A stack[-1] } 020A 80 DUP1 020B 63 PUSH4 0x285d70d4 0210 14 EQ 0211 61 PUSH2 0x037b 0214 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037b, if 0x285d70d4 == stack[-1] label_0215: // Incoming jump from 0x0214, if not 0x285d70d4 == stack[-1] // Inputs[1] { @0215 stack[-1] } 0215 80 DUP1 0216 63 PUSH4 0x2a55205a 021B 14 EQ 021C 61 PUSH2 0x039b 021F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039b, if 0x2a55205a == stack[-1] label_0220: // Incoming jump from 0x021F, if not 0x2a55205a == stack[-1] // Inputs[1] { @0223 memory[0x00:0x00] } 0220 60 PUSH1 0x00 0222 80 DUP1 0223 FD *REVERT // Stack delta = +0 // Outputs[1] { @0223 revert(memory[0x00:0x00]); } // Block terminates label_0224: // Incoming jump from 0x01E8, if 0x18160ddd > stack[-1] // Inputs[1] { @0225 stack[-1] } 0224 5B JUMPDEST 0225 80 DUP1 0226 63 PUSH4 0x01ffc9a7 022B 14 EQ 022C 61 PUSH2 0x0261 022F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0261, if 0x01ffc9a7 == stack[-1] label_0230: // Incoming jump from 0x022F, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0230 stack[-1] } 0230 80 DUP1 0231 63 PUSH4 0x06d254da 0236 14 EQ 0237 61 PUSH2 0x0296 023A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0296, if 0x06d254da == stack[-1] label_023B: // Incoming jump from 0x023A, if not 0x06d254da == stack[-1] // Inputs[1] { @023B stack[-1] } 023B 80 DUP1 023C 63 PUSH4 0x06fdde03 0241 14 EQ 0242 61 PUSH2 0x02b8 0245 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b8, if 0x06fdde03 == stack[-1] label_0246: // Incoming jump from 0x0245, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0246 stack[-1] } 0246 80 DUP1 0247 63 PUSH4 0x081812fc 024C 14 EQ 024D 61 PUSH2 0x02da 0250 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02da, if 0x081812fc == stack[-1] label_0251: // Incoming jump from 0x0250, if not 0x081812fc == stack[-1] // Inputs[1] { @0251 stack[-1] } 0251 80 DUP1 0252 63 PUSH4 0x095ea7b3 0257 14 EQ 0258 61 PUSH2 0x0312 025B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0312, if 0x095ea7b3 == stack[-1] label_025C: // Incoming jump from 0x025B, if not 0x095ea7b3 == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @0260 memory[0x00:0x00] } 025C 5B JUMPDEST 025D 60 PUSH1 0x00 025F 80 DUP1 0260 FD *REVERT // Stack delta = +0 // Outputs[1] { @0260 revert(memory[0x00:0x00]); } // Block terminates label_0261: // Incoming jump from 0x022F, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0262 msg.value } 0261 5B JUMPDEST 0262 34 CALLVALUE 0263 80 DUP1 0264 15 ISZERO 0265 61 PUSH2 0x026d 0268 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0262 stack[0] = msg.value } // Block ends with conditional jump to 0x026d, if !msg.value label_0269: // Incoming jump from 0x0268, if not !msg.value // Inputs[1] { @026C memory[0x00:0x00] } 0269 60 PUSH1 0x00 026B 80 DUP1 026C FD *REVERT // Stack delta = +0 // Outputs[1] { @026C revert(memory[0x00:0x00]); } // Block terminates label_026D: // Incoming jump from 0x0268, if !msg.value // Inputs[1] { @0275 msg.data.length } 026D 5B JUMPDEST 026E 50 POP 026F 61 PUSH2 0x0281 0272 61 PUSH2 0x027c 0275 36 CALLDATASIZE 0276 60 PUSH1 0x04 0278 61 PUSH2 0x1f4a 027B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @026F stack[-1] = 0x0281 // @0272 stack[0] = 0x027c // @0275 stack[1] = msg.data.length // @0276 stack[2] = 0x04 // } // Block ends with call to 0x1f4a, returns to 0x027C label_027C: // Incoming return from call to 0x1F4A at 0x027B 027C 5B JUMPDEST 027D 61 PUSH2 0x0799 0280 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0799 label_0281: // Incoming return from call to 0x075A at 0x0759 // Incoming jump from 0x04DC // Incoming return from call to 0x027C at 0x027B // Incoming jump from 0x0591 // Incoming jump from 0x0798 // Inputs[2] // { // @0284 memory[0x40:0x60] // @0285 stack[-1] // } 0281 5B JUMPDEST 0282 60 PUSH1 0x40 0284 51 MLOAD 0285 90 SWAP1 0286 15 ISZERO 0287 15 ISZERO 0288 81 DUP2 0289 52 MSTORE 028A 60 PUSH1 0x20 028C 01 ADD // Stack delta = +0 // Outputs[2] // { // @0289 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @028C stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_028D: // Incoming jump from 0x0311 // Incoming jump from 0x0347 // Incoming jump from 0x028C // Incoming jump from 0x06FE // Inputs[3] // { // @0290 memory[0x40:0x60] // @0292 stack[-1] // @0295 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 028D 5B JUMPDEST 028E 60 PUSH1 0x40 0290 51 MLOAD 0291 80 DUP1 0292 91 SWAP2 0293 03 SUB 0294 90 SWAP1 0295 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0295 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0296: // Incoming jump from 0x023A, if 0x06d254da == stack[-1] // Inputs[1] { @0297 msg.value } 0296 5B JUMPDEST 0297 34 CALLVALUE 0298 80 DUP1 0299 15 ISZERO 029A 61 PUSH2 0x02a2 029D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0297 stack[0] = msg.value } // Block ends with conditional jump to 0x02a2, if !msg.value label_029E: // Incoming jump from 0x029D, if not !msg.value // Inputs[1] { @02A1 memory[0x00:0x00] } 029E 60 PUSH1 0x00 02A0 80 DUP1 02A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @02A1 revert(memory[0x00:0x00]); } // Block terminates label_02A2: // Incoming jump from 0x029D, if !msg.value // Inputs[1] { @02AA msg.data.length } 02A2 5B JUMPDEST 02A3 50 POP 02A4 61 PUSH2 0x02b6 02A7 61 PUSH2 0x02b1 02AA 36 CALLDATASIZE 02AB 60 PUSH1 0x04 02AD 61 PUSH2 0x1f83 02B0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02A4 stack[-1] = 0x02b6 // @02A7 stack[0] = 0x02b1 // @02AA stack[1] = msg.data.length // @02AB stack[2] = 0x04 // } // Block ends with call to 0x1f83, returns to 0x02B1 label_02B1: // Incoming return from call to 0x1F83 at 0x02B0 02B1 5B JUMPDEST 02B2 61 PUSH2 0x07b9 02B5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07b9 label_02B6: // Incoming return from call to 0x05AD at 0x05AC // Incoming return from call to 0x068A at 0x0689 // Incoming return from call to 0x054E at 0x054D // Incoming return from call to 0x071A at 0x0719 // Incoming return from call to 0x0396 at 0x0395 // Incoming return from call to 0x050E at 0x050D // Incoming return from call to 0x0622 at 0x0621 02B6 5B JUMPDEST 02B7 00 *STOP // Stack delta = +0 // Outputs[1] { @02B7 stop(); } // Block terminates label_02B8: // Incoming jump from 0x0245, if 0x06fdde03 == stack[-1] // Inputs[1] { @02B9 msg.value } 02B8 5B JUMPDEST 02B9 34 CALLVALUE 02BA 80 DUP1 02BB 15 ISZERO 02BC 61 PUSH2 0x02c4 02BF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02B9 stack[0] = msg.value } // Block ends with conditional jump to 0x02c4, if !msg.value label_02C0: // Incoming jump from 0x02BF, if not !msg.value // Inputs[1] { @02C3 memory[0x00:0x00] } 02C0 60 PUSH1 0x00 02C2 80 DUP1 02C3 FD *REVERT // Stack delta = +0 // Outputs[1] { @02C3 revert(memory[0x00:0x00]); } // Block terminates label_02C4: // Incoming jump from 0x02BF, if !msg.value 02C4 5B JUMPDEST 02C5 50 POP 02C6 61 PUSH2 0x02cd 02C9 61 PUSH2 0x0808 02CC 56 *JUMP // Stack delta = +0 // Outputs[1] { @02C6 stack[-1] = 0x02cd } // Block ends with call to 0x0808, returns to 0x02CD label_02CD: // Incoming return from call to 0x1294 at 0x066E // Incoming return from call to 0x0808 at 0x02CC // Inputs[2] // { // @02D0 memory[0x40:0x60] // @02D4 stack[-1] // } 02CD 5B JUMPDEST 02CE 60 PUSH1 0x40 02D0 51 MLOAD 02D1 61 PUSH2 0x028d 02D4 91 SWAP2 02D5 90 SWAP1 02D6 61 PUSH2 0x1fee 02D9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02D4 stack[-1] = 0x028d // @02D5 stack[1] = memory[0x40:0x60] // @02D5 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1fee label_02DA: // Incoming jump from 0x0250, if 0x081812fc == stack[-1] // Inputs[1] { @02DB msg.value } 02DA 5B JUMPDEST 02DB 34 CALLVALUE 02DC 80 DUP1 02DD 15 ISZERO 02DE 61 PUSH2 0x02e6 02E1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02DB stack[0] = msg.value } // Block ends with conditional jump to 0x02e6, if !msg.value label_02E2: // Incoming jump from 0x02E1, if not !msg.value // Inputs[1] { @02E5 memory[0x00:0x00] } 02E2 60 PUSH1 0x00 02E4 80 DUP1 02E5 FD *REVERT // Stack delta = +0 // Outputs[1] { @02E5 revert(memory[0x00:0x00]); } // Block terminates label_02E6: // Incoming jump from 0x02E1, if !msg.value // Inputs[1] { @02EE msg.data.length } 02E6 5B JUMPDEST 02E7 50 POP 02E8 61 PUSH2 0x02fa 02EB 61 PUSH2 0x02f5 02EE 36 CALLDATASIZE 02EF 60 PUSH1 0x04 02F1 61 PUSH2 0x2001 02F4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02E8 stack[-1] = 0x02fa // @02EB stack[0] = 0x02f5 // @02EE stack[1] = msg.data.length // @02EF stack[2] = 0x04 // } // Block ends with call to 0x2001, returns to 0x02F5 label_02F5: // Incoming return from call to 0x2001 at 0x02F4 02F5 5B JUMPDEST 02F6 61 PUSH2 0x089a 02F9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x089a label_02FA: // Incoming return from call to 0x05CD at 0x05CC // Incoming return from call to 0x0461 at 0x0460 // Incoming return from call to 0x02F5 at 0x02F4 // Incoming jump from 0x06B3 // Incoming jump from 0x0659 // Inputs[2] // { // @02FD memory[0x40:0x60] // @0307 stack[-1] // } 02FA 5B JUMPDEST 02FB 60 PUSH1 0x40 02FD 51 MLOAD 02FE 60 PUSH1 0x01 0300 60 PUSH1 0x01 0302 60 PUSH1 0xa0 0304 1B SHL 0305 03 SUB 0306 90 SWAP1 0307 91 SWAP2 0308 16 AND 0309 81 DUP2 030A 52 MSTORE 030B 60 PUSH1 0x20 030D 01 ADD 030E 61 PUSH2 0x028d 0311 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @030A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @030D stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x028d label_0312: // Incoming jump from 0x025B, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0319 msg.data.length } 0312 5B JUMPDEST 0313 61 PUSH2 0x02b6 0316 61 PUSH2 0x0320 0319 36 CALLDATASIZE 031A 60 PUSH1 0x04 031C 61 PUSH2 0x201a 031F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0313 stack[0] = 0x02b6 // @0316 stack[1] = 0x0320 // @0319 stack[2] = msg.data.length // @031A stack[3] = 0x04 // } // Block ends with call to 0x201a, returns to 0x0320 label_0320: // Incoming return from call to 0x201A at 0x031F 0320 5B JUMPDEST 0321 61 PUSH2 0x08de 0324 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08de label_0325: // Incoming jump from 0x01F3, if 0x18160ddd == stack[-1] // Inputs[1] { @0326 msg.value } 0325 5B JUMPDEST 0326 34 CALLVALUE 0327 80 DUP1 0328 15 ISZERO 0329 61 PUSH2 0x0331 032C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0326 stack[0] = msg.value } // Block ends with conditional jump to 0x0331, if !msg.value label_032D: // Incoming jump from 0x032C, if not !msg.value // Inputs[1] { @0330 memory[0x00:0x00] } 032D 60 PUSH1 0x00 032F 80 DUP1 0330 FD *REVERT // Stack delta = +0 // Outputs[1] { @0330 revert(memory[0x00:0x00]); } // Block terminates label_0331: // Incoming jump from 0x032C, if !msg.value // Inputs[2] // { // @0335 storage[0x01] // @0338 storage[0x00] // } 0331 5B JUMPDEST 0332 50 POP 0333 60 PUSH1 0x01 0335 54 SLOAD 0336 60 PUSH1 0x00 0338 54 SLOAD 0339 03 SUB // Stack delta = +0 // Outputs[1] { @0339 stack[-1] = storage[0x00] - storage[0x01] } // Block continues label_033A: // Incoming jump from 0x040F // Incoming jump from 0x0339 // Incoming return from call to 0x05ED at 0x05EC // Incoming jump from 0x04F2 // Incoming jump from 0x0445 // Inputs[2] // { // @033D memory[0x40:0x60] // @033E stack[-1] // } 033A 5B JUMPDEST 033B 60 PUSH1 0x40 033D 51 MLOAD 033E 90 SWAP1 033F 81 DUP2 0340 52 MSTORE 0341 60 PUSH1 0x20 0343 01 ADD 0344 61 PUSH2 0x028d 0347 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0340 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0343 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x028d label_0348: // Incoming jump from 0x01FE, if 0x23b872dd == stack[-1] // Inputs[1] { @034F msg.data.length } 0348 5B JUMPDEST 0349 61 PUSH2 0x02b6 034C 61 PUSH2 0x0356 034F 36 CALLDATASIZE 0350 60 PUSH1 0x04 0352 61 PUSH2 0x2044 0355 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0349 stack[0] = 0x02b6 // @034C stack[1] = 0x0356 // @034F stack[2] = msg.data.length // @0350 stack[3] = 0x04 // } // Block ends with call to 0x2044, returns to 0x0356 label_0356: // Incoming return from call to 0x2044 at 0x0355 0356 5B JUMPDEST 0357 61 PUSH2 0x0952 035A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0952 label_035B: // Incoming jump from 0x0209, if 0x282d3fdf == stack[-1] // Inputs[1] { @035C msg.value } 035B 5B JUMPDEST 035C 34 CALLVALUE 035D 80 DUP1 035E 15 ISZERO 035F 61 PUSH2 0x0367 0362 57 *JUMPI // Stack delta = +1 // Outputs[1] { @035C stack[0] = msg.value } // Block ends with conditional jump to 0x0367, if !msg.value label_0363: // Incoming jump from 0x0362, if not !msg.value // Inputs[1] { @0366 memory[0x00:0x00] } 0363 60 PUSH1 0x00 0365 80 DUP1 0366 FD *REVERT // Stack delta = +0 // Outputs[1] { @0366 revert(memory[0x00:0x00]); } // Block terminates label_0367: // Incoming jump from 0x0362, if !msg.value // Inputs[1] { @036F msg.data.length } 0367 5B JUMPDEST 0368 50 POP 0369 61 PUSH2 0x02b6 036C 61 PUSH2 0x0376 036F 36 CALLDATASIZE 0370 60 PUSH1 0x04 0372 61 PUSH2 0x201a 0375 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0369 stack[-1] = 0x02b6 // @036C stack[0] = 0x0376 // @036F stack[1] = msg.data.length // @0370 stack[2] = 0x04 // } // Block ends with call to 0x201a, returns to 0x0376 label_0376: // Incoming return from call to 0x201A at 0x0375 0376 5B JUMPDEST 0377 61 PUSH2 0x0b04 037A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b04 label_037B: // Incoming jump from 0x0214, if 0x285d70d4 == stack[-1] // Inputs[1] { @037C msg.value } 037B 5B JUMPDEST 037C 34 CALLVALUE 037D 80 DUP1 037E 15 ISZERO 037F 61 PUSH2 0x0387 0382 57 *JUMPI // Stack delta = +1 // Outputs[1] { @037C stack[0] = msg.value } // Block ends with conditional jump to 0x0387, if !msg.value label_0383: // Incoming jump from 0x0382, if not !msg.value // Inputs[1] { @0386 memory[0x00:0x00] } 0383 60 PUSH1 0x00 0385 80 DUP1 0386 FD *REVERT // Stack delta = +0 // Outputs[1] { @0386 revert(memory[0x00:0x00]); } // Block terminates label_0387: // Incoming jump from 0x0382, if !msg.value // Inputs[1] { @038F msg.data.length } 0387 5B JUMPDEST 0388 50 POP 0389 61 PUSH2 0x02b6 038C 61 PUSH2 0x0396 038F 36 CALLDATASIZE 0390 60 PUSH1 0x04 0392 61 PUSH2 0x2090 0395 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0389 stack[-1] = 0x02b6 // @038C stack[0] = 0x0396 // @038F stack[1] = msg.data.length // @0390 stack[2] = 0x04 // } // Block ends with call to 0x2090, returns to 0x0396 label_0396: // Incoming return from call to 0x2090 at 0x0395 0396 5B JUMPDEST 0397 61 PUSH2 0x0bf6 039A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bf6 label_039B: // Incoming jump from 0x021F, if 0x2a55205a == stack[-1] // Inputs[1] { @039C msg.value } 039B 5B JUMPDEST 039C 34 CALLVALUE 039D 80 DUP1 039E 15 ISZERO 039F 61 PUSH2 0x03a7 03A2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @039C stack[0] = msg.value } // Block ends with conditional jump to 0x03a7, if !msg.value label_03A3: // Incoming jump from 0x03A2, if not !msg.value // Inputs[1] { @03A6 memory[0x00:0x00] } 03A3 60 PUSH1 0x00 03A5 80 DUP1 03A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A6 revert(memory[0x00:0x00]); } // Block terminates label_03A7: // Incoming jump from 0x03A2, if !msg.value // Inputs[1] { @03AF msg.data.length } 03A7 5B JUMPDEST 03A8 50 POP 03A9 61 PUSH2 0x03bb 03AC 61 PUSH2 0x03b6 03AF 36 CALLDATASIZE 03B0 60 PUSH1 0x04 03B2 61 PUSH2 0x20ab 03B5 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03A9 stack[-1] = 0x03bb // @03AC stack[0] = 0x03b6 // @03AF stack[1] = msg.data.length // @03B0 stack[2] = 0x04 // } // Block ends with call to 0x20ab, returns to 0x03B6 label_03B6: // Incoming return from call to 0x20AB at 0x03B5 03B6 5B JUMPDEST 03B7 61 PUSH2 0x0c11 03BA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c11 03BB 5B JUMPDEST 03BC 60 PUSH1 0x40 03BE 80 DUP1 03BF 51 MLOAD 03C0 60 PUSH1 0x01 03C2 60 PUSH1 0x01 03C4 60 PUSH1 0xa0 03C6 1B SHL 03C7 03 SUB 03C8 90 SWAP1 03C9 93 SWAP4 03CA 16 AND 03CB 83 DUP4 03CC 52 MSTORE 03CD 60 PUSH1 0x20 03CF 83 DUP4 03D0 01 ADD 03D1 91 SWAP2 03D2 90 SWAP1 03D3 91 SWAP2 03D4 52 MSTORE 03D5 01 ADD 03D6 61 PUSH2 0x028d 03D9 56 *JUMP label_03DA: // Incoming jump from 0x01AC, if 0x2db11544 == stack[-1] // Inputs[1] { @03DB msg.value } 03DA 5B JUMPDEST 03DB 34 CALLVALUE 03DC 80 DUP1 03DD 15 ISZERO 03DE 61 PUSH2 0x03e6 03E1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03DB stack[0] = msg.value } // Block ends with conditional jump to 0x03e6, if !msg.value label_03E2: // Incoming jump from 0x03E1, if not !msg.value // Inputs[1] { @03E5 memory[0x00:0x00] } 03E2 60 PUSH1 0x00 03E4 80 DUP1 03E5 FD *REVERT // Stack delta = +0 // Outputs[1] { @03E5 revert(memory[0x00:0x00]); } // Block terminates label_03E6: // Incoming jump from 0x03E1, if !msg.value // Inputs[1] { @03EE msg.data.length } 03E6 5B JUMPDEST 03E7 50 POP 03E8 61 PUSH2 0x02b6 03EB 61 PUSH2 0x03f5 03EE 36 CALLDATASIZE 03EF 60 PUSH1 0x04 03F1 61 PUSH2 0x2001 03F4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03E8 stack[-1] = 0x02b6 // @03EB stack[0] = 0x03f5 // @03EE stack[1] = msg.data.length // @03EF stack[2] = 0x04 // } // Block ends with call to 0x2001, returns to 0x03F5 label_03F5: // Incoming return from call to 0x2001 at 0x03F4 03F5 5B JUMPDEST 03F6 61 PUSH2 0x0cbf 03F9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cbf label_03FA: // Incoming jump from 0x01B7, if 0x2eb4a7ab == stack[-1] // Inputs[1] { @03FB msg.value } 03FA 5B JUMPDEST 03FB 34 CALLVALUE 03FC 80 DUP1 03FD 15 ISZERO 03FE 61 PUSH2 0x0406 0401 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03FB stack[0] = msg.value } // Block ends with conditional jump to 0x0406, if !msg.value label_0402: // Incoming jump from 0x0401, if not !msg.value // Inputs[1] { @0405 memory[0x00:0x00] } 0402 60 PUSH1 0x00 0404 80 DUP1 0405 FD *REVERT // Stack delta = +0 // Outputs[1] { @0405 revert(memory[0x00:0x00]); } // Block terminates label_0406: // Incoming jump from 0x0401, if !msg.value // Inputs[1] { @040D storage[0x11] } 0406 5B JUMPDEST 0407 50 POP 0408 61 PUSH2 0x033a 040B 60 PUSH1 0x11 040D 54 SLOAD 040E 81 DUP2 040F 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0408 stack[-1] = 0x033a // @040D stack[0] = storage[0x11] // } // Block ends with unconditional jump to 0x033a label_0410: // Incoming jump from 0x01C2, if 0x31faafb4 == stack[-1] // Inputs[1] { @0411 msg.value } 0410 5B JUMPDEST 0411 34 CALLVALUE 0412 80 DUP1 0413 15 ISZERO 0414 61 PUSH2 0x041c 0417 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0411 stack[0] = msg.value } // Block ends with conditional jump to 0x041c, if !msg.value label_0418: // Incoming jump from 0x0417, if not !msg.value // Inputs[1] { @041B memory[0x00:0x00] } 0418 60 PUSH1 0x00 041A 80 DUP1 041B FD *REVERT // Stack delta = +0 // Outputs[1] { @041B revert(memory[0x00:0x00]); } // Block terminates label_041C: // Incoming jump from 0x0417, if !msg.value // Inputs[1] { @0424 msg.data.length } 041C 5B JUMPDEST 041D 50 POP 041E 61 PUSH2 0x02b6 0421 61 PUSH2 0x042b 0424 36 CALLDATASIZE 0425 60 PUSH1 0x04 0427 61 PUSH2 0x20cd 042A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @041E stack[-1] = 0x02b6 // @0421 stack[0] = 0x042b // @0424 stack[1] = msg.data.length // @0425 stack[2] = 0x04 // } // Block ends with call to 0x20cd, returns to 0x042B label_042B: // Incoming return from call to 0x20CD at 0x042A 042B 5B JUMPDEST 042C 61 PUSH2 0x0e01 042F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e01 label_0430: // Incoming jump from 0x01CD, if 0x32cb6b0c == stack[-1] // Inputs[1] { @0431 msg.value } 0430 5B JUMPDEST 0431 34 CALLVALUE 0432 80 DUP1 0433 15 ISZERO 0434 61 PUSH2 0x043c 0437 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0431 stack[0] = msg.value } // Block ends with conditional jump to 0x043c, if !msg.value label_0438: // Incoming jump from 0x0437, if not !msg.value // Inputs[1] { @043B memory[0x00:0x00] } 0438 60 PUSH1 0x00 043A 80 DUP1 043B FD *REVERT // Stack delta = +0 // Outputs[1] { @043B revert(memory[0x00:0x00]); } // Block terminates label_043C: // Incoming jump from 0x0437, if !msg.value 043C 5B JUMPDEST 043D 50 POP 043E 61 PUSH2 0x033a 0441 61 PUSH2 0x012c 0444 81 DUP2 0445 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @043E stack[-1] = 0x033a // @0441 stack[0] = 0x012c // } // Block ends with unconditional jump to 0x033a label_0446: // Incoming jump from 0x01D8, if 0x3b035df6 == stack[-1] // Inputs[1] { @0447 msg.value } 0446 5B JUMPDEST 0447 34 CALLVALUE 0448 80 DUP1 0449 15 ISZERO 044A 61 PUSH2 0x0452 044D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0447 stack[0] = msg.value } // Block ends with conditional jump to 0x0452, if !msg.value label_044E: // Incoming jump from 0x044D, if not !msg.value // Inputs[1] { @0451 memory[0x00:0x00] } 044E 60 PUSH1 0x00 0450 80 DUP1 0451 FD *REVERT // Stack delta = +0 // Outputs[1] { @0451 revert(memory[0x00:0x00]); } // Block terminates label_0452: // Incoming jump from 0x044D, if !msg.value // Inputs[1] { @045A msg.data.length } 0452 5B JUMPDEST 0453 50 POP 0454 61 PUSH2 0x02fa 0457 61 PUSH2 0x0461 045A 36 CALLDATASIZE 045B 60 PUSH1 0x04 045D 61 PUSH2 0x2001 0460 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0454 stack[-1] = 0x02fa // @0457 stack[0] = 0x0461 // @045A stack[1] = msg.data.length // @045B stack[2] = 0x04 // } // Block ends with call to 0x2001, returns to 0x0461 label_0461: // Incoming return from call to 0x2001 at 0x0460 0461 5B JUMPDEST 0462 61 PUSH2 0x0e48 0465 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e48 label_0466: // Incoming jump from 0x0165, if 0x3ccfd60b == stack[-1] // Inputs[1] { @0467 msg.value } 0466 5B JUMPDEST 0467 34 CALLVALUE 0468 80 DUP1 0469 15 ISZERO 046A 61 PUSH2 0x0472 046D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0467 stack[0] = msg.value } // Block ends with conditional jump to 0x0472, if !msg.value label_046E: // Incoming jump from 0x046D, if not !msg.value // Inputs[1] { @0471 memory[0x00:0x00] } 046E 60 PUSH1 0x00 0470 80 DUP1 0471 FD *REVERT // Stack delta = +0 // Outputs[1] { @0471 revert(memory[0x00:0x00]); } // Block terminates label_0472: // Incoming jump from 0x046D, if !msg.value 0472 5B JUMPDEST 0473 50 POP 0474 61 PUSH2 0x02b6 0477 61 PUSH2 0x0ed1 047A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0474 stack[-1] = 0x02b6 } // Block ends with unconditional jump to 0x0ed1 label_047B: // Incoming jump from 0x0170, if 0x3f4ba83a == stack[-1] // Inputs[1] { @047C msg.value } 047B 5B JUMPDEST 047C 34 CALLVALUE 047D 80 DUP1 047E 15 ISZERO 047F 61 PUSH2 0x0487 0482 57 *JUMPI // Stack delta = +1 // Outputs[1] { @047C stack[0] = msg.value } // Block ends with conditional jump to 0x0487, if !msg.value label_0483: // Incoming jump from 0x0482, if not !msg.value // Inputs[1] { @0486 memory[0x00:0x00] } 0483 60 PUSH1 0x00 0485 80 DUP1 0486 FD *REVERT // Stack delta = +0 // Outputs[1] { @0486 revert(memory[0x00:0x00]); } // Block terminates label_0487: // Incoming jump from 0x0482, if !msg.value 0487 5B JUMPDEST 0488 50 POP 0489 61 PUSH2 0x02b6 048C 61 PUSH2 0x0ef6 048F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0489 stack[-1] = 0x02b6 } // Block ends with unconditional jump to 0x0ef6 label_0490: // Incoming jump from 0x017B, if 0x42842e0e == stack[-1] // Inputs[1] { @0497 msg.data.length } 0490 5B JUMPDEST 0491 61 PUSH2 0x02b6 0494 61 PUSH2 0x049e 0497 36 CALLDATASIZE 0498 60 PUSH1 0x04 049A 61 PUSH2 0x2044 049D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0491 stack[0] = 0x02b6 // @0494 stack[1] = 0x049e // @0497 stack[2] = msg.data.length // @0498 stack[3] = 0x04 // } // Block ends with call to 0x2044, returns to 0x049E label_049E: // Incoming return from call to 0x2044 at 0x049D 049E 5B JUMPDEST 049F 61 PUSH2 0x0f06 04A2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f06 label_04A3: // Incoming jump from 0x0186, if 0x484b973c == stack[-1] // Inputs[1] { @04A4 msg.value } 04A3 5B JUMPDEST 04A4 34 CALLVALUE 04A5 80 DUP1 04A6 15 ISZERO 04A7 61 PUSH2 0x04af 04AA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04A4 stack[0] = msg.value } // Block ends with conditional jump to 0x04af, if !msg.value label_04AB: // Incoming jump from 0x04AA, if not !msg.value // Inputs[1] { @04AE memory[0x00:0x00] } 04AB 60 PUSH1 0x00 04AD 80 DUP1 04AE FD *REVERT // Stack delta = +0 // Outputs[1] { @04AE revert(memory[0x00:0x00]); } // Block terminates label_04AF: // Incoming jump from 0x04AA, if !msg.value // Inputs[1] { @04B7 msg.data.length } 04AF 5B JUMPDEST 04B0 50 POP 04B1 61 PUSH2 0x02b6 04B4 61 PUSH2 0x04be 04B7 36 CALLDATASIZE 04B8 60 PUSH1 0x04 04BA 61 PUSH2 0x201a 04BD 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04B1 stack[-1] = 0x02b6 // @04B4 stack[0] = 0x04be // @04B7 stack[1] = msg.data.length // @04B8 stack[2] = 0x04 // } // Block ends with call to 0x201a, returns to 0x04BE label_04BE: // Incoming return from call to 0x201A at 0x04BD 04BE 5B JUMPDEST 04BF 61 PUSH2 0x0f21 04C2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f21 label_04C3: // Incoming jump from 0x0191, if 0x4bf365df == stack[-1] // Inputs[1] { @04C4 msg.value } 04C3 5B JUMPDEST 04C4 34 CALLVALUE 04C5 80 DUP1 04C6 15 ISZERO 04C7 61 PUSH2 0x04cf 04CA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04C4 stack[0] = msg.value } // Block ends with conditional jump to 0x04cf, if !msg.value label_04CB: // Incoming jump from 0x04CA, if not !msg.value // Inputs[1] { @04CE memory[0x00:0x00] } 04CB 60 PUSH1 0x00 04CD 80 DUP1 04CE FD *REVERT // Stack delta = +0 // Outputs[1] { @04CE revert(memory[0x00:0x00]); } // Block terminates label_04CF: // Incoming jump from 0x04CA, if !msg.value // Inputs[1] { @04D3 storage[0x0f] } 04CF 5B JUMPDEST 04D0 50 POP 04D1 60 PUSH1 0x0f 04D3 54 SLOAD 04D4 61 PUSH2 0x0281 04D7 90 SWAP1 04D8 60 PUSH1 0xff 04DA 16 AND 04DB 81 DUP2 04DC 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04D7 stack[-1] = 0x0281 // @04DA stack[0] = 0xff & storage[0x0f] // } // Block ends with unconditional jump to 0x0281 label_04DD: // Incoming jump from 0x019C, if 0x4f5035e5 == stack[-1] // Inputs[1] { @04DE msg.value } 04DD 5B JUMPDEST 04DE 34 CALLVALUE 04DF 80 DUP1 04E0 15 ISZERO 04E1 61 PUSH2 0x04e9 04E4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04DE stack[0] = msg.value } // Block ends with conditional jump to 0x04e9, if !msg.value label_04E5: // Incoming jump from 0x04E4, if not !msg.value // Inputs[1] { @04E8 memory[0x00:0x00] } 04E5 60 PUSH1 0x00 04E7 80 DUP1 04E8 FD *REVERT // Stack delta = +0 // Outputs[1] { @04E8 revert(memory[0x00:0x00]); } // Block terminates label_04E9: // Incoming jump from 0x04E4, if !msg.value // Inputs[1] { @04F0 storage[0x0e] } 04E9 5B JUMPDEST 04EA 50 POP 04EB 61 PUSH2 0x033a 04EE 60 PUSH1 0x0e 04F0 54 SLOAD 04F1 81 DUP2 04F2 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04EB stack[-1] = 0x033a // @04F0 stack[0] = storage[0x0e] // } // Block ends with unconditional jump to 0x033a label_04F3: // Incoming jump from 0x0113, if 0x4ff39e26 == stack[-1] // Inputs[1] { @04F4 msg.value } 04F3 5B JUMPDEST 04F4 34 CALLVALUE 04F5 80 DUP1 04F6 15 ISZERO 04F7 61 PUSH2 0x04ff 04FA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04F4 stack[0] = msg.value } // Block ends with conditional jump to 0x04ff, if !msg.value label_04FB: // Incoming jump from 0x04FA, if not !msg.value // Inputs[1] { @04FE memory[0x00:0x00] } 04FB 60 PUSH1 0x00 04FD 80 DUP1 04FE FD *REVERT // Stack delta = +0 // Outputs[1] { @04FE revert(memory[0x00:0x00]); } // Block terminates label_04FF: // Incoming jump from 0x04FA, if !msg.value // Inputs[1] { @0507 msg.data.length } 04FF 5B JUMPDEST 0500 50 POP 0501 61 PUSH2 0x02b6 0504 61 PUSH2 0x050e 0507 36 CALLDATASIZE 0508 60 PUSH1 0x04 050A 61 PUSH2 0x2001 050D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0501 stack[-1] = 0x02b6 // @0504 stack[0] = 0x050e // @0507 stack[1] = msg.data.length // @0508 stack[2] = 0x04 // } // Block ends with call to 0x2001, returns to 0x050E label_050E: // Incoming return from call to 0x2001 at 0x050D 050E 5B JUMPDEST 050F 61 PUSH2 0x0f33 0512 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f33 label_0513: // Incoming jump from 0x011E, if 0x55f804b3 == stack[-1] // Inputs[1] { @0514 msg.value } 0513 5B JUMPDEST 0514 34 CALLVALUE 0515 80 DUP1 0516 15 ISZERO 0517 61 PUSH2 0x051f 051A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0514 stack[0] = msg.value } // Block ends with conditional jump to 0x051f, if !msg.value label_051B: // Incoming jump from 0x051A, if not !msg.value // Inputs[1] { @051E memory[0x00:0x00] } 051B 60 PUSH1 0x00 051D 80 DUP1 051E FD *REVERT // Stack delta = +0 // Outputs[1] { @051E revert(memory[0x00:0x00]); } // Block terminates label_051F: // Incoming jump from 0x051A, if !msg.value // Inputs[1] { @0527 msg.data.length } 051F 5B JUMPDEST 0520 50 POP 0521 61 PUSH2 0x02b6 0524 61 PUSH2 0x052e 0527 36 CALLDATASIZE 0528 60 PUSH1 0x04 052A 61 PUSH2 0x2182 052D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0521 stack[-1] = 0x02b6 // @0524 stack[0] = 0x052e // @0527 stack[1] = msg.data.length // @0528 stack[2] = 0x04 // } // Block ends with call to 0x2182, returns to 0x052E label_052E: // Incoming return from call to 0x2182 at 0x052D 052E 5B JUMPDEST 052F 61 PUSH2 0x0f40 0532 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f40 label_0533: // Incoming jump from 0x0129, if 0x56e6f655 == stack[-1] // Inputs[1] { @0534 msg.value } 0533 5B JUMPDEST 0534 34 CALLVALUE 0535 80 DUP1 0536 15 ISZERO 0537 61 PUSH2 0x053f 053A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0534 stack[0] = msg.value } // Block ends with conditional jump to 0x053f, if !msg.value label_053B: // Incoming jump from 0x053A, if not !msg.value // Inputs[1] { @053E memory[0x00:0x00] } 053B 60 PUSH1 0x00 053D 80 DUP1 053E FD *REVERT // Stack delta = +0 // Outputs[1] { @053E revert(memory[0x00:0x00]); } // Block terminates label_053F: // Incoming jump from 0x053A, if !msg.value // Inputs[1] { @0547 msg.data.length } 053F 5B JUMPDEST 0540 50 POP 0541 61 PUSH2 0x02b6 0544 61 PUSH2 0x054e 0547 36 CALLDATASIZE 0548 60 PUSH1 0x04 054A 61 PUSH2 0x2210 054D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0541 stack[-1] = 0x02b6 // @0544 stack[0] = 0x054e // @0547 stack[1] = msg.data.length // @0548 stack[2] = 0x04 // } // Block ends with call to 0x2210, returns to 0x054E label_054E: // Incoming return from call to 0x2210 at 0x054D 054E 5B JUMPDEST 054F 61 PUSH2 0x0f54 0552 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f54 label_0553: // Incoming jump from 0x0134, if 0x5a546223 == stack[-1] // Inputs[1] { @0554 msg.value } 0553 5B JUMPDEST 0554 34 CALLVALUE 0555 80 DUP1 0556 15 ISZERO 0557 61 PUSH2 0x055f 055A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0554 stack[0] = msg.value } // Block ends with conditional jump to 0x055f, if !msg.value label_055B: // Incoming jump from 0x055A, if not !msg.value // Inputs[1] { @055E memory[0x00:0x00] } 055B 60 PUSH1 0x00 055D 80 DUP1 055E FD *REVERT // Stack delta = +0 // Outputs[1] { @055E revert(memory[0x00:0x00]); } // Block terminates label_055F: // Incoming jump from 0x055A, if !msg.value // Inputs[1] { @0567 msg.data.length } 055F 5B JUMPDEST 0560 50 POP 0561 61 PUSH2 0x02b6 0564 61 PUSH2 0x056e 0567 36 CALLDATASIZE 0568 60 PUSH1 0x04 056A 61 PUSH2 0x2263 056D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0561 stack[-1] = 0x02b6 // @0564 stack[0] = 0x056e // @0567 stack[1] = msg.data.length // @0568 stack[2] = 0x04 // } // Block ends with call to 0x2263, returns to 0x056E label_056E: // Incoming return from call to 0x2263 at 0x056D 056E 5B JUMPDEST 056F 61 PUSH2 0x0fd0 0572 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fd0 label_0573: // Incoming jump from 0x013F, if 0x5c975abb == stack[-1] // Inputs[1] { @0574 msg.value } 0573 5B JUMPDEST 0574 34 CALLVALUE 0575 80 DUP1 0576 15 ISZERO 0577 61 PUSH2 0x057f 057A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0574 stack[0] = msg.value } // Block ends with conditional jump to 0x057f, if !msg.value label_057B: // Incoming jump from 0x057A, if not !msg.value // Inputs[1] { @057E memory[0x00:0x00] } 057B 60 PUSH1 0x00 057D 80 DUP1 057E FD *REVERT // Stack delta = +0 // Outputs[1] { @057E revert(memory[0x00:0x00]); } // Block terminates label_057F: // Incoming jump from 0x057A, if !msg.value // Inputs[1] { @0583 storage[0x0b] } 057F 5B JUMPDEST 0580 50 POP 0581 60 PUSH1 0x0b 0583 54 SLOAD 0584 60 PUSH1 0x01 0586 60 PUSH1 0xa0 0588 1B SHL 0589 90 SWAP1 058A 04 DIV 058B 60 PUSH1 0xff 058D 16 AND 058E 61 PUSH2 0x0281 0591 56 *JUMP // Stack delta = +0 // Outputs[1] { @058D stack[-1] = 0xff & storage[0x0b] / (0x01 << 0xa0) } // Block ends with unconditional jump to 0x0281 label_0592: // Incoming jump from 0x00CC, if 0x6198e339 == stack[-1] // Inputs[1] { @0593 msg.value } 0592 5B JUMPDEST 0593 34 CALLVALUE 0594 80 DUP1 0595 15 ISZERO 0596 61 PUSH2 0x059e 0599 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0593 stack[0] = msg.value } // Block ends with conditional jump to 0x059e, if !msg.value label_059A: // Incoming jump from 0x0599, if not !msg.value // Inputs[1] { @059D memory[0x00:0x00] } 059A 60 PUSH1 0x00 059C 80 DUP1 059D FD *REVERT // Stack delta = +0 // Outputs[1] { @059D revert(memory[0x00:0x00]); } // Block terminates label_059E: // Incoming jump from 0x0599, if !msg.value // Inputs[1] { @05A6 msg.data.length } 059E 5B JUMPDEST 059F 50 POP 05A0 61 PUSH2 0x02b6 05A3 61 PUSH2 0x05ad 05A6 36 CALLDATASIZE 05A7 60 PUSH1 0x04 05A9 61 PUSH2 0x2001 05AC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05A0 stack[-1] = 0x02b6 // @05A3 stack[0] = 0x05ad // @05A6 stack[1] = msg.data.length // @05A7 stack[2] = 0x04 // } // Block ends with call to 0x2001, returns to 0x05AD label_05AD: // Incoming return from call to 0x2001 at 0x05AC 05AD 5B JUMPDEST 05AE 61 PUSH2 0x1198 05B1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1198 label_05B2: // Incoming jump from 0x00D7, if 0x6352211e == stack[-1] // Inputs[1] { @05B3 msg.value } 05B2 5B JUMPDEST 05B3 34 CALLVALUE 05B4 80 DUP1 05B5 15 ISZERO 05B6 61 PUSH2 0x05be 05B9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05B3 stack[0] = msg.value } // Block ends with conditional jump to 0x05be, if !msg.value label_05BA: // Incoming jump from 0x05B9, if not !msg.value // Inputs[1] { @05BD memory[0x00:0x00] } 05BA 60 PUSH1 0x00 05BC 80 DUP1 05BD FD *REVERT // Stack delta = +0 // Outputs[1] { @05BD revert(memory[0x00:0x00]); } // Block terminates label_05BE: // Incoming jump from 0x05B9, if !msg.value // Inputs[1] { @05C6 msg.data.length } 05BE 5B JUMPDEST 05BF 50 POP 05C0 61 PUSH2 0x02fa 05C3 61 PUSH2 0x05cd 05C6 36 CALLDATASIZE 05C7 60 PUSH1 0x04 05C9 61 PUSH2 0x2001 05CC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05C0 stack[-1] = 0x02fa // @05C3 stack[0] = 0x05cd // @05C6 stack[1] = msg.data.length // @05C7 stack[2] = 0x04 // } // Block ends with call to 0x2001, returns to 0x05CD label_05CD: // Incoming return from call to 0x2001 at 0x05CC 05CD 5B JUMPDEST 05CE 61 PUSH2 0x120b 05D1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x120b label_05D2: // Incoming jump from 0x00E2, if 0x70a08231 == stack[-1] // Inputs[1] { @05D3 msg.value } 05D2 5B JUMPDEST 05D3 34 CALLVALUE 05D4 80 DUP1 05D5 15 ISZERO 05D6 61 PUSH2 0x05de 05D9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05D3 stack[0] = msg.value } // Block ends with conditional jump to 0x05de, if !msg.value label_05DA: // Incoming jump from 0x05D9, if not !msg.value // Inputs[1] { @05DD memory[0x00:0x00] } 05DA 60 PUSH1 0x00 05DC 80 DUP1 05DD FD *REVERT // Stack delta = +0 // Outputs[1] { @05DD revert(memory[0x00:0x00]); } // Block terminates label_05DE: // Incoming jump from 0x05D9, if !msg.value // Inputs[1] { @05E6 msg.data.length } 05DE 5B JUMPDEST 05DF 50 POP 05E0 61 PUSH2 0x033a 05E3 61 PUSH2 0x05ed 05E6 36 CALLDATASIZE 05E7 60 PUSH1 0x04 05E9 61 PUSH2 0x1f83 05EC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05E0 stack[-1] = 0x033a // @05E3 stack[0] = 0x05ed // @05E6 stack[1] = msg.data.length // @05E7 stack[2] = 0x04 // } // Block ends with call to 0x1f83, returns to 0x05ED label_05ED: // Incoming return from call to 0x1F83 at 0x05EC 05ED 5B JUMPDEST 05EE 61 PUSH2 0x1216 05F1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1216 label_05F2: // Incoming jump from 0x00ED, if 0x715018a6 == stack[-1] // Inputs[1] { @05F3 msg.value } 05F2 5B JUMPDEST 05F3 34 CALLVALUE 05F4 80 DUP1 05F5 15 ISZERO 05F6 61 PUSH2 0x05fe 05F9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05F3 stack[0] = msg.value } // Block ends with conditional jump to 0x05fe, if !msg.value label_05FA: // Incoming jump from 0x05F9, if not !msg.value // Inputs[1] { @05FD memory[0x00:0x00] } 05FA 60 PUSH1 0x00 05FC 80 DUP1 05FD FD *REVERT // Stack delta = +0 // Outputs[1] { @05FD revert(memory[0x00:0x00]); } // Block terminates label_05FE: // Incoming jump from 0x05F9, if !msg.value 05FE 5B JUMPDEST 05FF 50 POP 0600 61 PUSH2 0x02b6 0603 61 PUSH2 0x1265 0606 56 *JUMP // Stack delta = +0 // Outputs[1] { @0600 stack[-1] = 0x02b6 } // Block ends with unconditional jump to 0x1265 label_0607: // Incoming jump from 0x00F8, if 0x7cb64759 == stack[-1] // Inputs[1] { @0608 msg.value } 0607 5B JUMPDEST 0608 34 CALLVALUE 0609 80 DUP1 060A 15 ISZERO 060B 61 PUSH2 0x0613 060E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0608 stack[0] = msg.value } // Block ends with conditional jump to 0x0613, if !msg.value label_060F: // Incoming jump from 0x060E, if not !msg.value // Inputs[1] { @0612 memory[0x00:0x00] } 060F 60 PUSH1 0x00 0611 80 DUP1 0612 FD *REVERT // Stack delta = +0 // Outputs[1] { @0612 revert(memory[0x00:0x00]); } // Block terminates label_0613: // Incoming jump from 0x060E, if !msg.value // Inputs[1] { @061B msg.data.length } 0613 5B JUMPDEST 0614 50 POP 0615 61 PUSH2 0x02b6 0618 61 PUSH2 0x0622 061B 36 CALLDATASIZE 061C 60 PUSH1 0x04 061E 61 PUSH2 0x2001 0621 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0615 stack[-1] = 0x02b6 // @0618 stack[0] = 0x0622 // @061B stack[1] = msg.data.length // @061C stack[2] = 0x04 // } // Block ends with call to 0x2001, returns to 0x0622 label_0622: // Incoming return from call to 0x2001 at 0x0621 0622 5B JUMPDEST 0623 61 PUSH2 0x1277 0626 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1277 label_0627: // Incoming jump from 0x0103, if 0x8456cb59 == stack[-1] // Inputs[1] { @0628 msg.value } 0627 5B JUMPDEST 0628 34 CALLVALUE 0629 80 DUP1 062A 15 ISZERO 062B 61 PUSH2 0x0633 062E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0628 stack[0] = msg.value } // Block ends with conditional jump to 0x0633, if !msg.value label_062F: // Incoming jump from 0x062E, if not !msg.value // Inputs[1] { @0632 memory[0x00:0x00] } 062F 60 PUSH1 0x00 0631 80 DUP1 0632 FD *REVERT // Stack delta = +0 // Outputs[1] { @0632 revert(memory[0x00:0x00]); } // Block terminates label_0633: // Incoming jump from 0x062E, if !msg.value 0633 5B JUMPDEST 0634 50 POP 0635 61 PUSH2 0x02b6 0638 61 PUSH2 0x1284 063B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0635 stack[-1] = 0x02b6 } // Block ends with unconditional jump to 0x1284 label_063C: // Incoming jump from 0x0085, if 0x8da5cb5b == stack[-1] // Inputs[1] { @063D msg.value } 063C 5B JUMPDEST 063D 34 CALLVALUE 063E 80 DUP1 063F 15 ISZERO 0640 61 PUSH2 0x0648 0643 57 *JUMPI // Stack delta = +1 // Outputs[1] { @063D stack[0] = msg.value } // Block ends with conditional jump to 0x0648, if !msg.value label_0644: // Incoming jump from 0x0643, if not !msg.value // Inputs[1] { @0647 memory[0x00:0x00] } 0644 60 PUSH1 0x00 0646 80 DUP1 0647 FD *REVERT // Stack delta = +0 // Outputs[1] { @0647 revert(memory[0x00:0x00]); } // Block terminates label_0648: // Incoming jump from 0x0643, if !msg.value // Inputs[1] { @064C storage[0x0b] } 0648 5B JUMPDEST 0649 50 POP 064A 60 PUSH1 0x0b 064C 54 SLOAD 064D 60 PUSH1 0x01 064F 60 PUSH1 0x01 0651 60 PUSH1 0xa0 0653 1B SHL 0654 03 SUB 0655 16 AND 0656 61 PUSH2 0x02fa 0659 56 *JUMP // Stack delta = +0 // Outputs[1] { @0655 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x0b] } // Block ends with unconditional jump to 0x02fa label_065A: // Incoming jump from 0x0090, if 0x95d89b41 == stack[-1] // Inputs[1] { @065B msg.value } 065A 5B JUMPDEST 065B 34 CALLVALUE 065C 80 DUP1 065D 15 ISZERO 065E 61 PUSH2 0x0666 0661 57 *JUMPI // Stack delta = +1 // Outputs[1] { @065B stack[0] = msg.value } // Block ends with conditional jump to 0x0666, if !msg.value label_0662: // Incoming jump from 0x0661, if not !msg.value // Inputs[1] { @0665 memory[0x00:0x00] } 0662 60 PUSH1 0x00 0664 80 DUP1 0665 FD *REVERT // Stack delta = +0 // Outputs[1] { @0665 revert(memory[0x00:0x00]); } // Block terminates label_0666: // Incoming jump from 0x0661, if !msg.value 0666 5B JUMPDEST 0667 50 POP 0668 61 PUSH2 0x02cd 066B 61 PUSH2 0x1294 066E 56 *JUMP // Stack delta = +0 // Outputs[1] { @0668 stack[-1] = 0x02cd } // Block ends with call to 0x1294, returns to 0x02CD label_066F: // Incoming jump from 0x009B, if 0xa22cb465 == stack[-1] // Inputs[1] { @0670 msg.value } 066F 5B JUMPDEST 0670 34 CALLVALUE 0671 80 DUP1 0672 15 ISZERO 0673 61 PUSH2 0x067b 0676 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0670 stack[0] = msg.value } // Block ends with conditional jump to 0x067b, if !msg.value label_0677: // Incoming jump from 0x0676, if not !msg.value // Inputs[1] { @067A memory[0x00:0x00] } 0677 60 PUSH1 0x00 0679 80 DUP1 067A FD *REVERT // Stack delta = +0 // Outputs[1] { @067A revert(memory[0x00:0x00]); } // Block terminates label_067B: // Incoming jump from 0x0676, if !msg.value // Inputs[1] { @0683 msg.data.length } 067B 5B JUMPDEST 067C 50 POP 067D 61 PUSH2 0x02b6 0680 61 PUSH2 0x068a 0683 36 CALLDATASIZE 0684 60 PUSH1 0x04 0686 61 PUSH2 0x2296 0689 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @067D stack[-1] = 0x02b6 // @0680 stack[0] = 0x068a // @0683 stack[1] = msg.data.length // @0684 stack[2] = 0x04 // } // Block ends with call to 0x2296, returns to 0x068A label_068A: // Incoming return from call to 0x2296 at 0x0689 068A 5B JUMPDEST 068B 61 PUSH2 0x12a3 068E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x12a3 label_068F: // Incoming jump from 0x00A6, if 0xad2f852a == stack[-1] // Inputs[1] { @0690 msg.value } 068F 5B JUMPDEST 0690 34 CALLVALUE 0691 80 DUP1 0692 15 ISZERO 0693 61 PUSH2 0x069b 0696 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0690 stack[0] = msg.value } // Block ends with conditional jump to 0x069b, if !msg.value label_0697: // Incoming jump from 0x0696, if not !msg.value // Inputs[1] { @069A memory[0x00:0x00] } 0697 60 PUSH1 0x00 0699 80 DUP1 069A FD *REVERT // Stack delta = +0 // Outputs[1] { @069A revert(memory[0x00:0x00]); } // Block terminates label_069B: // Incoming jump from 0x0696, if !msg.value // Inputs[1] { @069F storage[0x0f] } 069B 5B JUMPDEST 069C 50 POP 069D 60 PUSH1 0x0f 069F 54 SLOAD 06A0 61 PUSH2 0x02fa 06A3 90 SWAP1 06A4 61 PUSH2 0x0100 06A7 90 SWAP1 06A8 04 DIV 06A9 60 PUSH1 0x01 06AB 60 PUSH1 0x01 06AD 60 PUSH1 0xa0 06AF 1B SHL 06B0 03 SUB 06B1 16 AND 06B2 81 DUP2 06B3 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @06A3 stack[-1] = 0x02fa // @06B1 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0f] / 0x0100 // } // Block ends with unconditional jump to 0x02fa label_06B4: // Incoming jump from 0x00B1, if 0xb88d4fde == stack[-1] // Inputs[1] { @06BB msg.data.length } 06B4 5B JUMPDEST 06B5 61 PUSH2 0x02b6 06B8 61 PUSH2 0x06c2 06BB 36 CALLDATASIZE 06BC 60 PUSH1 0x04 06BE 61 PUSH2 0x22c9 06C1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06B5 stack[0] = 0x02b6 // @06B8 stack[1] = 0x06c2 // @06BB stack[2] = msg.data.length // @06BC stack[3] = 0x04 // } // Block ends with call to 0x22c9, returns to 0x06C2 label_06C2: // Incoming return from call to 0x22C9 at 0x06C1 06C2 5B JUMPDEST 06C3 61 PUSH2 0x130f 06C6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x130f label_06C7: // Incoming jump from 0x003E, if 0xb8997a97 == stack[-1] // Inputs[1] { @06C8 msg.value } 06C7 5B JUMPDEST 06C8 34 CALLVALUE 06C9 80 DUP1 06CA 15 ISZERO 06CB 61 PUSH2 0x06d3 06CE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06C8 stack[0] = msg.value } // Block ends with conditional jump to 0x06d3, if !msg.value label_06CF: // Incoming jump from 0x06CE, if not !msg.value // Inputs[1] { @06D2 memory[0x00:0x00] } 06CF 60 PUSH1 0x00 06D1 80 DUP1 06D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @06D2 revert(memory[0x00:0x00]); } // Block terminates label_06D3: // Incoming jump from 0x06CE, if !msg.value // Inputs[1] { @06D7 storage[0x10] } 06D3 5B JUMPDEST 06D4 50 POP 06D5 60 PUSH1 0x10 06D7 54 SLOAD 06D8 61 PUSH2 0x06e7 06DB 90 SWAP1 06DC 60 PUSH1 0x01 06DE 60 PUSH1 0x01 06E0 60 PUSH1 0x60 06E2 1B SHL 06E3 03 SUB 06E4 16 AND 06E5 81 DUP2 06E6 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @06DB stack[-1] = 0x06e7 // @06E4 stack[0] = (0x01 << 0x60) - 0x01 & storage[0x10] // } // Block ends with unconditional jump to 0x06e7 label_06E7: // Incoming jump from 0x06E6 // Inputs[2] // { // @06EA memory[0x40:0x60] // @06F4 stack[-1] // } 06E7 5B JUMPDEST 06E8 60 PUSH1 0x40 06EA 51 MLOAD 06EB 60 PUSH1 0x01 06ED 60 PUSH1 0x01 06EF 60 PUSH1 0x60 06F1 1B SHL 06F2 03 SUB 06F3 90 SWAP1 06F4 91 SWAP2 06F5 16 AND 06F6 81 DUP2 06F7 52 MSTORE 06F8 60 PUSH1 0x20 06FA 01 ADD 06FB 61 PUSH2 0x028d 06FE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @06F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0x60) - 0x01 // @06FA stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x028d label_06FF: // Incoming jump from 0x0049, if 0xc54e73e3 == stack[-1] // Inputs[1] { @0700 msg.value } 06FF 5B JUMPDEST 0700 34 CALLVALUE 0701 80 DUP1 0702 15 ISZERO 0703 61 PUSH2 0x070b 0706 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0700 stack[0] = msg.value } // Block ends with conditional jump to 0x070b, if !msg.value label_0707: // Incoming jump from 0x0706, if not !msg.value // Inputs[1] { @070A memory[0x00:0x00] } 0707 60 PUSH1 0x00 0709 80 DUP1 070A FD *REVERT // Stack delta = +0 // Outputs[1] { @070A revert(memory[0x00:0x00]); } // Block terminates label_070B: // Incoming jump from 0x0706, if !msg.value // Inputs[1] { @0713 msg.data.length } 070B 5B JUMPDEST 070C 50 POP 070D 61 PUSH2 0x02b6 0710 61 PUSH2 0x071a 0713 36 CALLDATASIZE 0714 60 PUSH1 0x04 0716 61 PUSH2 0x2090 0719 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @070D stack[-1] = 0x02b6 // @0710 stack[0] = 0x071a // @0713 stack[1] = msg.data.length // @0714 stack[2] = 0x04 // } // Block ends with call to 0x2090, returns to 0x071A label_071A: // Incoming return from call to 0x2090 at 0x0719 071A 5B JUMPDEST 071B 61 PUSH2 0x1353 071E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1353 label_071F: // Incoming jump from 0x0054, if 0xc87b56dd == stack[-1] // Inputs[1] { @0720 msg.value } 071F 5B JUMPDEST 0720 34 CALLVALUE 0721 80 DUP1 0722 15 ISZERO 0723 61 PUSH2 0x072b 0726 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0720 stack[0] = msg.value } // Block ends with conditional jump to 0x072b, if !msg.value label_0727: // Incoming jump from 0x0726, if not !msg.value // Inputs[1] { @072A memory[0x00:0x00] } 0727 60 PUSH1 0x00 0729 80 DUP1 072A FD *REVERT // Stack delta = +0 // Outputs[1] { @072A revert(memory[0x00:0x00]); } // Block terminates label_072B: // Incoming jump from 0x0726, if !msg.value // Inputs[1] { @0733 msg.data.length } 072B 5B JUMPDEST 072C 50 POP 072D 61 PUSH2 0x02cd 0730 61 PUSH2 0x073a 0733 36 CALLDATASIZE 0734 60 PUSH1 0x04 0736 61 PUSH2 0x2001 0739 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @072D stack[-1] = 0x02cd // @0730 stack[0] = 0x073a // @0733 stack[1] = msg.data.length // @0734 stack[2] = 0x04 // } // Block ends with call to 0x2001, returns to 0x073A label_073A: // Incoming return from call to 0x2001 at 0x0739 073A 5B JUMPDEST 073B 61 PUSH2 0x136e 073E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x136e label_073F: // Incoming jump from 0x005F, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0740 msg.value } 073F 5B JUMPDEST 0740 34 CALLVALUE 0741 80 DUP1 0742 15 ISZERO 0743 61 PUSH2 0x074b 0746 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0740 stack[0] = msg.value } // Block ends with conditional jump to 0x074b, if !msg.value label_0747: // Incoming jump from 0x0746, if not !msg.value // Inputs[1] { @074A memory[0x00:0x00] } 0747 60 PUSH1 0x00 0749 80 DUP1 074A FD *REVERT // Stack delta = +0 // Outputs[1] { @074A revert(memory[0x00:0x00]); } // Block terminates label_074B: // Incoming jump from 0x0746, if !msg.value // Inputs[1] { @0753 msg.data.length } 074B 5B JUMPDEST 074C 50 POP 074D 61 PUSH2 0x0281 0750 61 PUSH2 0x075a 0753 36 CALLDATASIZE 0754 60 PUSH1 0x04 0756 61 PUSH2 0x2345 0759 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @074D stack[-1] = 0x0281 // @0750 stack[0] = 0x075a // @0753 stack[1] = msg.data.length // @0754 stack[2] = 0x04 // } // Block ends with call to 0x2345, returns to 0x075A label_075A: // Incoming return from call to 0x2345 at 0x0759 075A 5B JUMPDEST 075B 61 PUSH2 0x13be 075E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x13be label_075F: // Incoming jump from 0x006A, if 0xf2fde38b == stack[-1] // Inputs[1] { @0760 msg.value } 075F 5B JUMPDEST 0760 34 CALLVALUE 0761 80 DUP1 0762 15 ISZERO 0763 61 PUSH2 0x076b 0766 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0760 stack[0] = msg.value } // Block ends with conditional jump to 0x076b, if !msg.value label_0767: // Incoming jump from 0x0766, if not !msg.value // Inputs[1] { @076A memory[0x00:0x00] } 0767 60 PUSH1 0x00 0769 80 DUP1 076A FD *REVERT // Stack delta = +0 // Outputs[1] { @076A revert(memory[0x00:0x00]); } // Block terminates label_076B: // Incoming jump from 0x0766, if !msg.value // Inputs[1] { @0773 msg.data.length } 076B 5B JUMPDEST 076C 50 POP 076D 61 PUSH2 0x02b6 0770 61 PUSH2 0x077a 0773 36 CALLDATASIZE 0774 60 PUSH1 0x04 0776 61 PUSH2 0x1f83 0779 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @076D stack[-1] = 0x02b6 // @0770 stack[0] = 0x077a // @0773 stack[1] = msg.data.length // @0774 stack[2] = 0x04 // } // Block ends with call to 0x1f83, returns to 0x077A label_077A: // Incoming return from call to 0x1F83 at 0x0779 077A 5B JUMPDEST 077B 61 PUSH2 0x13ec 077E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x13ec label_077F: // Incoming jump from 0x0075, if 0xfdea8e0b == stack[-1] // Inputs[1] { @0780 msg.value } 077F 5B JUMPDEST 0780 34 CALLVALUE 0781 80 DUP1 0782 15 ISZERO 0783 61 PUSH2 0x078b 0786 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0780 stack[0] = msg.value } // Block ends with conditional jump to 0x078b, if !msg.value label_0787: // Incoming jump from 0x0786, if not !msg.value // Inputs[1] { @078A memory[0x00:0x00] } 0787 60 PUSH1 0x00 0789 80 DUP1 078A FD *REVERT // Stack delta = +0 // Outputs[1] { @078A revert(memory[0x00:0x00]); } // Block terminates label_078B: // Incoming jump from 0x0786, if !msg.value // Inputs[1] { @078F storage[0x0d] } 078B 5B JUMPDEST 078C 50 POP 078D 60 PUSH1 0x0d 078F 54 SLOAD 0790 61 PUSH2 0x0281 0793 90 SWAP1 0794 60 PUSH1 0xff 0796 16 AND 0797 81 DUP2 0798 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0793 stack[-1] = 0x0281 // @0796 stack[0] = 0xff & storage[0x0d] // } // Block ends with unconditional jump to 0x0281 label_0799: // Incoming jump from 0x0280 // Inputs[1] { @079F stack[-1] } 0799 5B JUMPDEST 079A 60 PUSH1 0x00 079C 61 PUSH2 0x07a4 079F 82 DUP3 07A0 61 PUSH2 0x1462 07A3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @079A stack[0] = 0x00 // @079C stack[1] = 0x07a4 // @079F stack[2] = stack[-1] // } // Block ends with call to 0x1462, returns to 0x07A4 label_07A4: // Incoming return from call to 0x1462 at 0x07A3 // Inputs[1] { @07A5 stack[-1] } 07A4 5B JUMPDEST 07A5 80 DUP1 07A6 61 PUSH2 0x07b3 07A9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07b3, if stack[-1] label_07AA: // Incoming jump from 0x07A9, if not stack[-1] // Inputs[1] { @07AE stack[-3] } 07AA 50 POP 07AB 61 PUSH2 0x07b3 07AE 82 DUP3 07AF 61 PUSH2 0x1487 07B2 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @07AB stack[-1] = 0x07b3 // @07AE stack[0] = stack[-3] // } // Block ends with call to 0x1487, returns to 0x07B3 label_07B3: // Incoming jump from 0x07A9, if stack[-1] // Incoming jump from 0x14BB // Incoming return from call to 0x16DA at 0x1215 // Incoming jump from 0x23CE, if (stack[-2] == (stack[-2] * stack[-1]) / stack[-1]) | !stack[-1] // Incoming jump from 0x147D, if 0x072b6811 << 0xe4 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1DCB at 0x1486 // Incoming jump from 0x161F, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x14A2, if 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1487 at 0x07B2 // Incoming jump from 0x1E01, if stack[-1] // Incoming jump from 0x2538, if !(stack[-1] > stack[-2] + stack[-1]) // Incoming jump from 0x1E01, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Inputs[3] // { // @07B4 stack[-1] // @07B4 stack[-4] // @07B5 stack[-3] // } 07B3 5B JUMPDEST 07B4 92 SWAP3 07B5 91 SWAP2 07B6 50 POP 07B7 50 POP 07B8 56 *JUMP // Stack delta = -3 // Outputs[1] { @07B4 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_07B9: // Incoming jump from 0x02B5 07B9 5B JUMPDEST 07BA 61 PUSH2 0x07c1 07BD 61 PUSH2 0x14bc 07C0 56 *JUMP // Stack delta = +1 // Outputs[1] { @07BA stack[0] = 0x07c1 } // Block ends with call to 0x14bc, returns to 0x07C1 label_07C1: // Incoming return from call to 0x14BC at 0x07C0 // Inputs[3] // { // @07C5 storage[0x0f] // @07DC stack[-1] // @07EB storage[0x10] // } 07C1 5B JUMPDEST 07C2 60 PUSH1 0x0f 07C4 80 DUP1 07C5 54 SLOAD 07C6 61 PUSH2 0x0100 07C9 60 PUSH1 0x01 07CB 60 PUSH1 0xa8 07CD 1B SHL 07CE 03 SUB 07CF 19 NOT 07D0 16 AND 07D1 61 PUSH2 0x0100 07D4 60 PUSH1 0x01 07D6 60 PUSH1 0x01 07D8 60 PUSH1 0xa0 07DA 1B SHL 07DB 03 SUB 07DC 84 DUP5 07DD 81 DUP2 07DE 16 AND 07DF 82 DUP3 07E0 02 MUL 07E1 92 SWAP3 07E2 90 SWAP1 07E3 92 SWAP3 07E4 17 OR 07E5 92 SWAP3 07E6 83 DUP4 07E7 90 SWAP1 07E8 55 SSTORE 07E9 60 PUSH1 0x10 07EB 54 SLOAD 07EC 61 PUSH2 0x0805 07EF 93 SWAP4 07F0 91 SWAP2 07F1 90 SWAP1 07F2 91 SWAP2 07F3 04 DIV 07F4 90 SWAP1 07F5 91 SWAP2 07F6 16 AND 07F7 90 SWAP1 07F8 60 PUSH1 0x01 07FA 60 PUSH1 0x01 07FC 60 PUSH1 0x60 07FE 1B SHL 07FF 03 SUB 0800 16 AND 0801 61 PUSH2 0x1516 0804 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @07E8 storage[0x0f] = 0x0100 * ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa8) - 0x0100) & storage[0x0f]) // @07EF stack[0] = 0x0805 // @07F7 stack[1] = (0x01 << 0xa0) - 0x01 & (0x0100 * ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa8) - 0x0100) & storage[0x0f])) / 0x0100 // @0800 stack[2] = (0x01 << 0x60) - 0x01 & storage[0x10] // } // Block ends with call to 0x1516, returns to 0x0805 label_0805: // Incoming return from call to 0x1BCB at 0x1461 // Incoming return from call to 0x1516 at 0x0E47 // Incoming jump from 0x1F45, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1516 at 0x0804 // Inputs[1] { @0807 stack[-2] } 0805 5B JUMPDEST 0806 50 POP 0807 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0808: // Incoming call from 0x02CC, returns to 0x02CD // Inputs[1] { @080E storage[0x02] } 0808 5B JUMPDEST 0809 60 PUSH1 0x60 080B 60 PUSH1 0x02 080D 80 DUP1 080E 54 SLOAD 080F 61 PUSH2 0x0817 0812 90 SWAP1 0813 61 PUSH2 0x236f 0816 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0809 stack[0] = 0x60 // @080B stack[1] = 0x02 // @0812 stack[2] = 0x0817 // @0812 stack[3] = storage[0x02] // } // Block ends with call to 0x236f, returns to 0x0817 label_0817: // Incoming return from call to 0x236F at 0x0816 // Incoming return from call to 0x236F at 0x1EC3 // Incoming return from call to 0x236F at 0x12A2 // Inputs[4] // { // @0818 stack[-1] // @0827 memory[0x40:0x60] // @082F stack[-2] // @083A storage[stack[-2]] // } 0817 5B JUMPDEST 0818 80 DUP1 0819 60 PUSH1 0x1f 081B 01 ADD 081C 60 PUSH1 0x20 081E 80 DUP1 081F 91 SWAP2 0820 04 DIV 0821 02 MUL 0822 60 PUSH1 0x20 0824 01 ADD 0825 60 PUSH1 0x40 0827 51 MLOAD 0828 90 SWAP1 0829 81 DUP2 082A 01 ADD 082B 60 PUSH1 0x40 082D 52 MSTORE 082E 80 DUP1 082F 92 SWAP3 0830 91 SWAP2 0831 90 SWAP1 0832 81 DUP2 0833 81 DUP2 0834 52 MSTORE 0835 60 PUSH1 0x20 0837 01 ADD 0838 82 DUP3 0839 80 DUP1 083A 54 SLOAD 083B 61 PUSH2 0x0843 083E 90 SWAP1 083F 61 PUSH2 0x236f 0842 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @082D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @082F stack[-2] = memory[0x40:0x60] // @0830 stack[-1] = stack[-2] // @0831 stack[0] = stack[-1] // @0834 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0837 stack[1] = 0x20 + memory[0x40:0x60] // @0838 stack[2] = stack[-2] // @083E stack[4] = storage[stack[-2]] // @083E stack[3] = 0x0843 // } // Block ends with call to 0x236f, returns to 0x0843 label_0843: // Incoming return from call to 0x236F at 0x0842 // Inputs[1] { @0844 stack[-1] } 0843 5B JUMPDEST 0844 80 DUP1 0845 15 ISZERO 0846 61 PUSH2 0x0890 0849 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0890, if !stack[-1] label_084A: // Incoming jump from 0x0849, if not !stack[-1] // Inputs[1] { @084A stack[-1] } 084A 80 DUP1 084B 60 PUSH1 0x1f 084D 10 LT 084E 61 PUSH2 0x0865 0851 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0865, if 0x1f < stack[-1] label_0852: // Incoming jump from 0x0851, if not 0x1f < stack[-1] // Inputs[4] // { // @0856 stack[-2] // @0857 storage[stack[-2]] // @085A stack[-3] // @085C stack[-1] // } 0852 61 PUSH2 0x0100 0855 80 DUP1 0856 83 DUP4 0857 54 SLOAD 0858 04 DIV 0859 02 MUL 085A 83 DUP4 085B 52 MSTORE 085C 91 SWAP2 085D 60 PUSH1 0x20 085F 01 ADD 0860 91 SWAP2 0861 61 PUSH2 0x0890 0864 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @085B memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0860 stack[-1] = stack[-1] // @0860 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0890 label_0865: // Incoming jump from 0x0851, if 0x1f < stack[-1] // Inputs[5] // { // @0866 stack[-3] // @0867 stack[-1] // @0869 stack[-2] // @0871 memory[0x00:0x20] // @0875 storage[keccak256(memory[0x00:0x20])] // } 0865 5B JUMPDEST 0866 82 DUP3 0867 01 ADD 0868 91 SWAP2 0869 90 SWAP1 086A 60 PUSH1 0x00 086C 52 MSTORE 086D 60 PUSH1 0x20 086F 60 PUSH1 0x00 0871 20 SHA3 0872 90 SWAP1 0873 5B JUMPDEST 0874 81 DUP2 0875 54 SLOAD 0876 81 DUP2 0877 52 MSTORE 0878 90 SWAP1 0879 60 PUSH1 0x01 087B 01 ADD 087C 90 SWAP1 087D 60 PUSH1 0x20 087F 01 ADD 0880 80 DUP1 0881 83 DUP4 0882 11 GT 0883 61 PUSH2 0x0873 0886 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0868 stack[-3] = stack[-3] + stack[-1] // @086C memory[0x00:0x20] = stack[-2] // @0877 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @087C stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @087F stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0873, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0887: // Incoming jump from 0x0886, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0886, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0887 stack[-3] // @0888 stack[-1] // } 0887 82 DUP3 0888 90 SWAP1 0889 03 SUB 088A 60 PUSH1 0x1f 088C 16 AND 088D 82 DUP3 088E 01 ADD 088F 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @088F stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @088F stack[-1] = stack[-3] // } // Block continues label_0890: // Incoming jump from 0x0864 // Incoming jump from 0x0849, if !stack[-1] // Incoming jump from 0x088F // Inputs[3] // { // @0896 stack[-6] // @0896 stack[-7] // @0898 stack[-8] // } 0890 5B JUMPDEST 0891 50 POP 0892 50 POP 0893 50 POP 0894 50 POP 0895 50 POP 0896 90 SWAP1 0897 50 POP 0898 90 SWAP1 0899 56 *JUMP // Stack delta = -7 // Outputs[1] { @0898 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_089A: // Incoming jump from 0x02F9 // Inputs[1] { @08A0 stack[-1] } 089A 5B JUMPDEST 089B 60 PUSH1 0x00 089D 61 PUSH2 0x08a5 08A0 82 DUP3 08A1 61 PUSH2 0x1613 08A4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @089B stack[0] = 0x00 // @089D stack[1] = 0x08a5 // @08A0 stack[2] = stack[-1] // } // Block ends with call to 0x1613, returns to 0x08A5 label_08A5: // Incoming return from call to 0x1613 at 0x08A4 // Inputs[1] { @08A9 stack[-1] } 08A5 5B JUMPDEST 08A6 61 PUSH2 0x08c2 08A9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x08c2, if stack[-1] label_08AA: // Incoming jump from 0x08A9, if not stack[-1] // Inputs[3] // { // @08AC memory[0x40:0x60] // @08BC memory[0x40:0x60] // @08C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 08AA 60 PUSH1 0x40 08AC 51 MLOAD 08AD 63 PUSH4 0x33d1c039 08B2 60 PUSH1 0xe2 08B4 1B SHL 08B5 81 DUP2 08B6 52 MSTORE 08B7 60 PUSH1 0x04 08B9 01 ADD 08BA 60 PUSH1 0x40 08BC 51 MLOAD 08BD 80 DUP1 08BE 91 SWAP2 08BF 03 SUB 08C0 90 SWAP1 08C1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @08B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x33d1c039 << 0xe2 // @08C1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_08C2: // Incoming jump from 0x08A9, if stack[-1] // Inputs[4] // { // @08C6 stack[-2] // @08D1 memory[0x00:0x40] // @08D2 storage[keccak256(memory[0x00:0x40])] // @08DC stack[-3] // } 08C2 5B JUMPDEST 08C3 50 POP 08C4 60 PUSH1 0x00 08C6 90 SWAP1 08C7 81 DUP2 08C8 52 MSTORE 08C9 60 PUSH1 0x06 08CB 60 PUSH1 0x20 08CD 52 MSTORE 08CE 60 PUSH1 0x40 08D0 90 SWAP1 08D1 20 SHA3 08D2 54 SLOAD 08D3 60 PUSH1 0x01 08D5 60 PUSH1 0x01 08D7 60 PUSH1 0xa0 08D9 1B SHL 08DA 03 SUB 08DB 16 AND 08DC 90 SWAP1 08DD 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @08C8 memory[0x00:0x20] = stack[-2] // @08CD memory[0x20:0x40] = 0x06 // @08DC stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_08DE: // Incoming jump from 0x0324 // Inputs[1] { @08E4 stack[-1] } 08DE 5B JUMPDEST 08DF 60 PUSH1 0x00 08E1 61 PUSH2 0x08e9 08E4 82 DUP3 08E5 61 PUSH2 0x0e48 08E8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @08DF stack[0] = 0x00 // @08E1 stack[1] = 0x08e9 // @08E4 stack[2] = stack[-1] // } // Block ends with call to 0x0e48, returns to 0x08E9 label_08E9: // Incoming return from call to 0x0E48 at 0x08E8 // Inputs[2] // { // @08F2 stack[-1] // @08F3 stack[-2] // } 08E9 5B JUMPDEST 08EA 60 PUSH1 0x01 08EC 60 PUSH1 0x01 08EE 60 PUSH1 0xa0 08F0 1B SHL 08F1 03 SUB 08F2 16 AND 08F3 14 EQ 08F4 61 PUSH2 0x0944 08F7 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0944, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_08F8: // Incoming jump from 0x08F7, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @08FA memory[0x40:0x60] } 08F8 60 PUSH1 0x40 08FA 51 MLOAD 08FB 62 PUSH3 0x461bcd 08FF 60 PUSH1 0xe5 0901 1B SHL 0902 81 DUP2 0903 52 MSTORE 0904 60 PUSH1 0x20 0906 60 PUSH1 0x04 0908 82 DUP3 0909 01 ADD 090A 52 MSTORE 090B 60 PUSH1 0x1c 090D 60 PUSH1 0x24 090F 82 DUP3 0910 01 ADD 0911 52 MSTORE 0912 7F PUSH32 0x43616e206e6f7420617070726f7665206c6f636b656420746f6b656e00000000 0933 60 PUSH1 0x44 0935 82 DUP3 0936 01 ADD 0937 52 MSTORE 0938 60 PUSH1 0x64 093A 01 ADD // Stack delta = +1 // Outputs[5] // { // @0903 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @090A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0911 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1c // @0937 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616e206e6f7420617070726f7665206c6f636b656420746f6b656e00000000 // @093A stack[0] = 0x64 + memory[0x40:0x60] // } // Block continues label_093B: // Incoming jump from 0x15D9 // Incoming jump from 0x0D10 // Incoming jump from 0x17C4 // Incoming jump from 0x0D5F // Incoming jump from 0x1583 // Incoming jump from 0x0B69 // Incoming jump from 0x11EC // Incoming jump from 0x1515 // Incoming jump from 0x0DF6 // Incoming jump from 0x0EB4 // Incoming jump from 0x1841 // Incoming jump from 0x1458 // Incoming jump from 0x1077 // Incoming jump from 0x1019 // Incoming jump from 0x192E // Incoming jump from 0x0DB2 // Incoming jump from 0x0BBF // Incoming jump from 0x18EB // Incoming jump from 0x1891 // Incoming jump from 0x093A // Incoming jump from 0x1A92 // Incoming jump from 0x1B5B // Incoming jump from 0x1E68 // Inputs[3] // { // @093E memory[0x40:0x60] // @0940 stack[-1] // @0943 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 093B 5B JUMPDEST 093C 60 PUSH1 0x40 093E 51 MLOAD 093F 80 DUP1 0940 91 SWAP2 0941 03 SUB 0942 90 SWAP1 0943 FD *REVERT // Stack delta = -1 // Outputs[1] { @0943 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0944: // Incoming jump from 0x08F7, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[2] // { // @0948 stack[-2] // @0949 stack[-1] // } 0944 5B JUMPDEST 0945 61 PUSH2 0x094e 0948 82 DUP3 0949 82 DUP3 094A 61 PUSH2 0x163a 094D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0945 stack[0] = 0x094e // @0948 stack[1] = stack[-2] // @0949 stack[2] = stack[-1] // } // Block ends with call to 0x163a, returns to 0x094E label_094E: // Incoming return from call to 0x163A at 0x094D // Incoming return from call to 0x243E at 0x0F53 // Incoming jump from 0x18F4, if !(msg.value < stack[-1]) // Inputs[1] { @0951 stack[-3] } 094E 5B JUMPDEST 094F 50 POP 0950 50 POP 0951 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0952: // Incoming jump from 0x035A // Incoming jump from 0x1319 // Inputs[1] { @0958 stack[-1] } 0952 5B JUMPDEST 0953 60 PUSH1 0x00 0955 61 PUSH2 0x095d 0958 82 DUP3 0959 61 PUSH2 0x16da 095C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0953 stack[0] = 0x00 // @0955 stack[1] = 0x095d // @0958 stack[2] = stack[-1] // } // Block ends with call to 0x16da, returns to 0x095D label_095D: // Incoming return from call to 0x16DA at 0x095C // Inputs[3] // { // @095E stack[-1] // @095E stack[-2] // @0960 stack[-5] // } 095D 5B JUMPDEST 095E 90 SWAP1 095F 50 POP 0960 83 DUP4 0961 60 PUSH1 0x01 0963 60 PUSH1 0x01 0965 60 PUSH1 0xa0 0967 1B SHL 0968 03 SUB 0969 16 AND 096A 81 DUP2 096B 60 PUSH1 0x01 096D 60 PUSH1 0x01 096F 60 PUSH1 0xa0 0971 1B SHL 0972 03 SUB 0973 16 AND 0974 14 EQ 0975 61 PUSH2 0x0990 0978 57 *JUMPI // Stack delta = -1 // Outputs[1] { @095E stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0990, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] label_0979: // Incoming jump from 0x0978, if not (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @097B memory[0x40:0x60] // @098A memory[0x40:0x60] // @098F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0979 60 PUSH1 0x40 097B 51 MLOAD 097C 62 PUSH3 0xa11481 0980 60 PUSH1 0xe8 0982 1B SHL 0983 81 DUP2 0984 52 MSTORE 0985 60 PUSH1 0x04 0987 01 ADD 0988 60 PUSH1 0x40 098A 51 MLOAD 098B 80 DUP1 098C 91 SWAP2 098D 03 SUB 098E 90 SWAP1 098F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0984 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa11481 << 0xe8 // @098F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0990: // Incoming jump from 0x0978, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[5] // { // @0993 stack[-2] // @099E memory[0x00:0x40] // @09A0 storage[keccak256(memory[0x00:0x40])] // @09A1 msg.sender // @09AD stack[-4] // } 0990 5B JUMPDEST 0991 60 PUSH1 0x00 0993 82 DUP3 0994 81 DUP2 0995 52 MSTORE 0996 60 PUSH1 0x06 0998 60 PUSH1 0x20 099A 52 MSTORE 099B 60 PUSH1 0x40 099D 90 SWAP1 099E 20 SHA3 099F 80 DUP1 09A0 54 SLOAD 09A1 33 CALLER 09A2 80 DUP1 09A3 82 DUP3 09A4 14 EQ 09A5 60 PUSH1 0x01 09A7 60 PUSH1 0x01 09A9 60 PUSH1 0xa0 09AB 1B SHL 09AC 03 SUB 09AD 88 DUP9 09AE 16 AND 09AF 90 SWAP1 09B0 91 SWAP2 09B1 14 EQ 09B2 17 OR 09B3 61 PUSH2 0x09dd 09B6 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0995 memory[0x00:0x20] = stack[-2] // @099A memory[0x20:0x40] = 0x06 // @099E stack[0] = keccak256(memory[0x00:0x40]) // @09A0 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x09dd, if (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) label_09B7: // Incoming jump from 0x09B6, if not (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Inputs[2] // { // @09BA stack[-6] // @09BB msg.sender // } 09B7 61 PUSH2 0x09c0 09BA 86 DUP7 09BB 33 CALLER 09BC 61 PUSH2 0x13be 09BF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09B7 stack[0] = 0x09c0 // @09BA stack[1] = stack[-6] // @09BB stack[2] = msg.sender // } // Block ends with call to 0x13be, returns to 0x09C0 label_09C0: // Incoming return from call to 0x13BE at 0x09BF // Inputs[1] { @09C4 stack[-1] } 09C0 5B JUMPDEST 09C1 61 PUSH2 0x09dd 09C4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x09dd, if stack[-1] label_09C5: // Incoming jump from 0x09C4, if not stack[-1] // Inputs[3] // { // @09C7 memory[0x40:0x60] // @09D7 memory[0x40:0x60] // @09DC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 09C5 60 PUSH1 0x40 09C7 51 MLOAD 09C8 63 PUSH4 0x2ce44b5f 09CD 60 PUSH1 0xe1 09CF 1B SHL 09D0 81 DUP2 09D1 52 MSTORE 09D2 60 PUSH1 0x04 09D4 01 ADD 09D5 60 PUSH1 0x40 09D7 51 MLOAD 09D8 80 DUP1 09D9 91 SWAP2 09DA 03 SUB 09DB 90 SWAP1 09DC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @09D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @09DC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_09DD: // Incoming jump from 0x09B6, if (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Incoming jump from 0x09C4, if stack[-1] // Inputs[1] { @09E6 stack[-5] } 09DD 5B JUMPDEST 09DE 60 PUSH1 0x01 09E0 60 PUSH1 0x01 09E2 60 PUSH1 0xa0 09E4 1B SHL 09E5 03 SUB 09E6 85 DUP6 09E7 16 AND 09E8 61 PUSH2 0x0a04 09EB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a04, if stack[-5] & (0x01 << 0xa0) - 0x01 label_09EC: // Incoming jump from 0x09EB, if not stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @09EE memory[0x40:0x60] // @09FE memory[0x40:0x60] // @0A03 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 09EC 60 PUSH1 0x40 09EE 51 MLOAD 09EF 63 PUSH4 0x3a954ecd 09F4 60 PUSH1 0xe2 09F6 1B SHL 09F7 81 DUP2 09F8 52 MSTORE 09F9 60 PUSH1 0x04 09FB 01 ADD 09FC 60 PUSH1 0x40 09FE 51 MLOAD 09FF 80 DUP1 0A00 91 SWAP2 0A01 03 SUB 0A02 90 SWAP1 0A03 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @09F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3a954ecd << 0xe2 // @0A03 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0A04: // Incoming jump from 0x09EB, if stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0A08 stack[-6] // @0A09 stack[-5] // @0A0A stack[-4] // } 0A04 5B JUMPDEST 0A05 61 PUSH2 0x0a11 0A08 86 DUP7 0A09 86 DUP7 0A0A 86 DUP7 0A0B 60 PUSH1 0x01 0A0D 61 PUSH2 0x1748 0A10 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0A05 stack[0] = 0x0a11 // @0A08 stack[1] = stack[-6] // @0A09 stack[2] = stack[-5] // @0A0A stack[3] = stack[-4] // @0A0B stack[4] = 0x01 // } // Block ends with call to 0x1748, returns to 0x0A11 label_0A11: // Incoming return from call to 0x1748 at 0x0A10 // Inputs[1] { @0A12 stack[-1] } 0A11 5B JUMPDEST 0A12 80 DUP1 0A13 15 ISZERO 0A14 61 PUSH2 0x0a1c 0A17 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a1c, if !stack[-1] label_0A18: // Incoming jump from 0x0A17, if not !stack[-1] // Inputs[11] // { // @0A1A stack[-2] // @0A25 stack[-6] // @0A36 memory[0x00:0x40] // @0A38 storage[keccak256(memory[0x00:0x40])] // @0A40 stack[-5] // @0A47 memory[0x00:0x40] // @0A49 storage[keccak256(memory[0x00:0x40])] // @0A4F block.timestamp // @0A5C stack[-4] // @0A67 memory[0x00:0x40] // @0A71 stack[-3] // } 0A18 60 PUSH1 0x00 0A1A 82 DUP3 0A1B 55 SSTORE 0A1C 5B JUMPDEST 0A1D 60 PUSH1 0x01 0A1F 60 PUSH1 0x01 0A21 60 PUSH1 0xa0 0A23 1B SHL 0A24 03 SUB 0A25 86 DUP7 0A26 81 DUP2 0A27 16 AND 0A28 60 PUSH1 0x00 0A2A 90 SWAP1 0A2B 81 DUP2 0A2C 52 MSTORE 0A2D 60 PUSH1 0x05 0A2F 60 PUSH1 0x20 0A31 52 MSTORE 0A32 60 PUSH1 0x40 0A34 80 DUP1 0A35 82 DUP3 0A36 20 SHA3 0A37 80 DUP1 0A38 54 SLOAD 0A39 60 PUSH1 0x00 0A3B 19 NOT 0A3C 01 ADD 0A3D 90 SWAP1 0A3E 55 SSTORE 0A3F 91 SWAP2 0A40 87 DUP8 0A41 16 AND 0A42 80 DUP1 0A43 82 DUP3 0A44 52 MSTORE 0A45 91 SWAP2 0A46 90 SWAP1 0A47 20 SHA3 0A48 80 DUP1 0A49 54 SLOAD 0A4A 60 PUSH1 0x01 0A4C 01 ADD 0A4D 90 SWAP1 0A4E 55 SSTORE 0A4F 42 TIMESTAMP 0A50 60 PUSH1 0xa0 0A52 1B SHL 0A53 17 OR 0A54 60 PUSH1 0x01 0A56 60 PUSH1 0xe1 0A58 1B SHL 0A59 17 OR 0A5A 60 PUSH1 0x00 0A5C 85 DUP6 0A5D 81 DUP2 0A5E 52 MSTORE 0A5F 60 PUSH1 0x04 0A61 60 PUSH1 0x20 0A63 52 MSTORE 0A64 60 PUSH1 0x40 0A66 81 DUP2 0A67 20 SHA3 0A68 91 SWAP2 0A69 90 SWAP1 0A6A 91 SWAP2 0A6B 55 SSTORE 0A6C 60 PUSH1 0x01 0A6E 60 PUSH1 0xe1 0A70 1B SHL 0A71 84 DUP5 0A72 16 AND 0A73 90 SWAP1 0A74 03 SUB 0A75 61 PUSH2 0x0aae 0A78 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0A1B storage[stack[-2]] = 0x00 // @0A2C memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @0A31 memory[0x20:0x40] = 0x05 // @0A3E storage[keccak256(memory[0x00:0x40])] = ~0x00 + storage[keccak256(memory[0x00:0x40])] // @0A44 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @0A4E storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // @0A5E memory[0x00:0x20] = stack[-4] // @0A63 memory[0x20:0x40] = 0x04 // @0A6B storage[keccak256(memory[0x00:0x40])] = (0x01 << 0xe1) | (block.timestamp << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) // } // Block ends with conditional jump to 0x0aae, if 0x00 - (stack[-3] & (0x01 << 0xe1)) label_0A79: // Incoming jump from 0x0A78, if not 0x00 - (stack[-3] & (0x01 << 0xe1)) // Incoming jump from 0x0A78, if not 0x00 - (stack[-3] & (0x01 << 0xe1)) // Inputs[3] // { // @0A7B stack[-4] // @0A8A memory[0x00:0x40] // @0A8B storage[keccak256(memory[0x00:0x40])] // } 0A79 60 PUSH1 0x01 0A7B 84 DUP5 0A7C 01 ADD 0A7D 60 PUSH1 0x00 0A7F 81 DUP2 0A80 81 DUP2 0A81 52 MSTORE 0A82 60 PUSH1 0x04 0A84 60 PUSH1 0x20 0A86 52 MSTORE 0A87 60 PUSH1 0x40 0A89 81 DUP2 0A8A 20 SHA3 0A8B 54 SLOAD 0A8C 90 SWAP1 0A8D 03 SUB 0A8E 61 PUSH2 0x0aac 0A91 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0A7C stack[0] = stack[-4] + 0x01 // @0A81 memory[0x00:0x20] = stack[-4] + 0x01 // @0A86 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x0aac, if 0x00 - storage[keccak256(memory[0x00:0x40])] label_0A92: // Incoming jump from 0x0A91, if not 0x00 - storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @0A94 storage[0x00] // @0A95 stack[-1] // } 0A92 60 PUSH1 0x00 0A94 54 SLOAD 0A95 81 DUP2 0A96 14 EQ 0A97 61 PUSH2 0x0aac 0A9A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0aac, if stack[-1] == storage[0x00] label_0A9B: // Incoming jump from 0x0A9A, if not stack[-1] == storage[0x00] // Inputs[3] // { // @0A9D stack[-1] // @0AA8 memory[0x00:0x40] // @0AA9 stack[-4] // } 0A9B 60 PUSH1 0x00 0A9D 81 DUP2 0A9E 81 DUP2 0A9F 52 MSTORE 0AA0 60 PUSH1 0x04 0AA2 60 PUSH1 0x20 0AA4 52 MSTORE 0AA5 60 PUSH1 0x40 0AA7 90 SWAP1 0AA8 20 SHA3 0AA9 84 DUP5 0AAA 90 SWAP1 0AAB 55 SSTORE // Stack delta = +0 // Outputs[3] // { // @0A9F memory[0x00:0x20] = stack[-1] // @0AA4 memory[0x20:0x40] = 0x04 // @0AAB storage[keccak256(memory[0x00:0x40])] = stack[-4] // } // Block continues label_0AAC: // Incoming jump from 0x0A9A, if stack[-1] == storage[0x00] // Incoming jump from 0x0AAB // Incoming jump from 0x0A91, if 0x00 - storage[keccak256(memory[0x00:0x40])] 0AAC 5B JUMPDEST 0AAD 50 POP // Stack delta = -1 // Block continues label_0AAE: // Incoming jump from 0x0AAD // Incoming jump from 0x0A78, if 0x00 - (stack[-3] & (0x01 << 0xe1)) // Incoming jump from 0x0A78, if 0x00 - (stack[-3] & (0x01 << 0xe1)) // Inputs[6] // { // @0AAF stack[-4] // @0AB0 stack[-5] // @0ABA stack[-6] // @0AE7 memory[0x40:0x60] // @0AEA memory[0x40:0x60] // @0AEF memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 0AAE 5B JUMPDEST 0AAF 83 DUP4 0AB0 85 DUP6 0AB1 60 PUSH1 0x01 0AB3 60 PUSH1 0x01 0AB5 60 PUSH1 0xa0 0AB7 1B SHL 0AB8 03 SUB 0AB9 16 AND 0ABA 87 DUP8 0ABB 60 PUSH1 0x01 0ABD 60 PUSH1 0x01 0ABF 60 PUSH1 0xa0 0AC1 1B SHL 0AC2 03 SUB 0AC3 16 AND 0AC4 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0AE5 60 PUSH1 0x40 0AE7 51 MLOAD 0AE8 60 PUSH1 0x40 0AEA 51 MLOAD 0AEB 80 DUP1 0AEC 91 SWAP2 0AED 03 SUB 0AEE 90 SWAP1 0AEF A4 LOG4 0AF0 61 PUSH2 0x0afc 0AF3 86 DUP7 0AF4 86 DUP7 0AF5 86 DUP7 0AF6 60 PUSH1 0x01 0AF8 61 PUSH2 0x17c5 0AFB 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @0AEF log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5] & (0x01 << 0xa0) - 0x01, stack[-4]]); // @0AF0 stack[0] = 0x0afc // @0AF3 stack[1] = stack[-6] // @0AF4 stack[2] = stack[-5] // @0AF5 stack[3] = stack[-4] // @0AF6 stack[4] = 0x01 // } // Block ends with call to 0x17c5, returns to 0x0AFC label_0AFC: // Incoming jump from 0x2433, if !(stack[-1] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming return from call to 0x17C5 at 0x0AFB // Incoming jump from 0x24A0 // Incoming jump from 0x24A0 // Incoming jump from 0x2433, if !(stack[-1] < stack[-2]) // Incoming jump from 0x2433, if !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Inputs[1] { @0B03 stack[-7] } 0AFC 5B JUMPDEST 0AFD 50 POP 0AFE 50 POP 0AFF 50 POP 0B00 50 POP 0B01 50 POP 0B02 50 POP 0B03 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_0B04: // Incoming jump from 0x037A // Inputs[1] { @0B0A stack[-1] } 0B04 5B JUMPDEST 0B05 60 PUSH1 0x00 0B07 61 PUSH2 0x0b0f 0B0A 82 DUP3 0B0B 61 PUSH2 0x120b 0B0E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B05 stack[0] = 0x00 // @0B07 stack[1] = 0x0b0f // @0B0A stack[2] = stack[-1] // } // Block ends with call to 0x120b, returns to 0x0B0F label_0B0F: // Incoming return from call to 0x120B at 0x0B0E // Inputs[3] // { // @0B10 stack[-2] // @0B10 stack[-1] // @0B12 msg.sender // } 0B0F 5B JUMPDEST 0B10 90 SWAP1 0B11 50 POP 0B12 33 CALLER 0B13 60 PUSH1 0x01 0B15 60 PUSH1 0x01 0B17 60 PUSH1 0xa0 0B19 1B SHL 0B1A 03 SUB 0B1B 82 DUP3 0B1C 16 AND 0B1D 14 EQ 0B1E 80 DUP1 0B1F 61 PUSH2 0x0b2d 0B22 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0B10 stack[-2] = stack[-1] // @0B1D stack[-1] = stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // } // Block ends with conditional jump to 0x0b2d, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_0B23: // Incoming jump from 0x0B22, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0B27 stack[-2] // @0B28 msg.sender // } 0B23 50 POP 0B24 61 PUSH2 0x0b2d 0B27 81 DUP2 0B28 33 CALLER 0B29 61 PUSH2 0x13be 0B2C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B24 stack[-1] = 0x0b2d // @0B27 stack[0] = stack[-2] // @0B28 stack[1] = msg.sender // } // Block ends with call to 0x13be, returns to 0x0B2D label_0B2D: // Incoming return from call to 0x13BE at 0x0B2C // Incoming jump from 0x0B22, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @0B31 stack[-1] } 0B2D 5B JUMPDEST 0B2E 61 PUSH2 0x0b6a 0B31 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b6a, if stack[-1] label_0B32: // Incoming jump from 0x0B31, if not stack[-1] // Inputs[1] { @0B34 memory[0x40:0x60] } 0B32 60 PUSH1 0x40 0B34 51 MLOAD 0B35 62 PUSH3 0x461bcd 0B39 60 PUSH1 0xe5 0B3B 1B SHL 0B3C 81 DUP2 0B3D 52 MSTORE 0B3E 60 PUSH1 0x20 0B40 60 PUSH1 0x04 0B42 82 DUP3 0B43 01 ADD 0B44 52 MSTORE 0B45 60 PUSH1 0x0e 0B47 60 PUSH1 0x24 0B49 82 DUP3 0B4A 01 ADD 0B4B 52 MSTORE 0B4C 6D PUSH14 0x1393d517d055551213d492569151 0B5B 60 PUSH1 0x92 0B5D 1B SHL 0B5E 60 PUSH1 0x44 0B60 82 DUP3 0B61 01 ADD 0B62 52 MSTORE 0B63 60 PUSH1 0x64 0B65 01 ADD 0B66 61 PUSH2 0x093b 0B69 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0B3D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B44 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B4B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @0B62 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1393d517d055551213d492569151 << 0x92 // @0B65 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_0B6A: // Incoming jump from 0x0B31, if stack[-1] // Inputs[3] // { // @0B6D stack[-2] // @0B78 memory[0x00:0x40] // @0B79 storage[keccak256(memory[0x00:0x40])] // } 0B6A 5B JUMPDEST 0B6B 60 PUSH1 0x00 0B6D 82 DUP3 0B6E 81 DUP2 0B6F 52 MSTORE 0B70 60 PUSH1 0x08 0B72 60 PUSH1 0x20 0B74 52 MSTORE 0B75 60 PUSH1 0x40 0B77 90 SWAP1 0B78 20 SHA3 0B79 54 SLOAD 0B7A 60 PUSH1 0x01 0B7C 60 PUSH1 0x01 0B7E 60 PUSH1 0xa0 0B80 1B SHL 0B81 03 SUB 0B82 16 AND 0B83 15 ISZERO 0B84 61 PUSH2 0x0bc0 0B87 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0B6F memory[0x00:0x20] = stack[-2] // @0B74 memory[0x20:0x40] = 0x08 // } // Block ends with conditional jump to 0x0bc0, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_0B88: // Incoming jump from 0x0B87, if not !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0B8A memory[0x40:0x60] } 0B88 60 PUSH1 0x40 0B8A 51 MLOAD 0B8B 62 PUSH3 0x461bcd 0B8F 60 PUSH1 0xe5 0B91 1B SHL 0B92 81 DUP2 0B93 52 MSTORE 0B94 60 PUSH1 0x20 0B96 60 PUSH1 0x04 0B98 82 DUP3 0B99 01 ADD 0B9A 52 MSTORE 0B9B 60 PUSH1 0x0e 0B9D 60 PUSH1 0x24 0B9F 82 DUP3 0BA0 01 ADD 0BA1 52 MSTORE 0BA2 6D PUSH14 0x1053149150511657d313d0d2d151 0BB1 60 PUSH1 0x92 0BB3 1B SHL 0BB4 60 PUSH1 0x44 0BB6 82 DUP3 0BB7 01 ADD 0BB8 52 MSTORE 0BB9 60 PUSH1 0x64 0BBB 01 ADD 0BBC 61 PUSH2 0x093b 0BBF 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0B93 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B9A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BA1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @0BB8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1053149150511657d313d0d2d151 << 0x92 // @0BBB stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_0BC0: // Incoming jump from 0x0B87, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @0BC3 stack[-2] // @0BCE memory[0x00:0x40] // @0BD0 storage[keccak256(memory[0x00:0x40])] // @0BE3 stack[-3] // } 0BC0 5B JUMPDEST 0BC1 60 PUSH1 0x00 0BC3 82 DUP3 0BC4 81 DUP2 0BC5 52 MSTORE 0BC6 60 PUSH1 0x08 0BC8 60 PUSH1 0x20 0BCA 52 MSTORE 0BCB 60 PUSH1 0x40 0BCD 90 SWAP1 0BCE 20 SHA3 0BCF 80 DUP1 0BD0 54 SLOAD 0BD1 60 PUSH1 0x01 0BD3 60 PUSH1 0x01 0BD5 60 PUSH1 0xa0 0BD7 1B SHL 0BD8 03 SUB 0BD9 19 NOT 0BDA 16 AND 0BDB 60 PUSH1 0x01 0BDD 60 PUSH1 0x01 0BDF 60 PUSH1 0xa0 0BE1 1B SHL 0BE2 03 SUB 0BE3 85 DUP6 0BE4 16 AND 0BE5 17 OR 0BE6 90 SWAP1 0BE7 55 SSTORE 0BE8 61 PUSH2 0x0bf1 0BEB 83 DUP4 0BEC 83 DUP4 0BED 61 PUSH2 0x163a 0BF0 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @0BC5 memory[0x00:0x20] = stack[-2] // @0BCA memory[0x20:0x40] = 0x08 // @0BE7 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @0BE8 stack[0] = 0x0bf1 // @0BEB stack[1] = stack[-3] // @0BEC stack[2] = stack[-2] // } // Block ends with call to 0x163a, returns to 0x0BF1 label_0BF1: // Incoming jump from 0x1AEE, if stack[-3] // Incoming jump from 0x1AEE, if stack[-3] // Incoming return from call to 0x163A at 0x0BF0 // Incoming return from call to 0x17C5 at 0x1A42 // Incoming jump from 0x2401, if !(stack[-2] > 0x1f) // Inputs[1] { @0BF5 stack[-4] } 0BF1 5B JUMPDEST 0BF2 50 POP 0BF3 50 POP 0BF4 50 POP 0BF5 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0BF6: // Incoming jump from 0x039A 0BF6 5B JUMPDEST 0BF7 61 PUSH2 0x0bfe 0BFA 61 PUSH2 0x14bc 0BFD 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BF7 stack[0] = 0x0bfe } // Block ends with call to 0x14bc, returns to 0x0BFE label_0BFE: // Incoming return from call to 0x14BC at 0x0BFD // Inputs[3] // { // @0C02 storage[0x0f] // @0C07 stack[-1] // @0C10 stack[-2] // } 0BFE 5B JUMPDEST 0BFF 60 PUSH1 0x0f 0C01 80 DUP1 0C02 54 SLOAD 0C03 60 PUSH1 0xff 0C05 19 NOT 0C06 16 AND 0C07 91 SWAP2 0C08 15 ISZERO 0C09 15 ISZERO 0C0A 91 SWAP2 0C0B 90 SWAP1 0C0C 91 SWAP2 0C0D 17 OR 0C0E 90 SWAP1 0C0F 55 SSTORE 0C10 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C0F storage[0x0f] = !!stack[-1] | (~0xff & storage[0x0f]) } // Block ends with unconditional jump to stack[-2] label_0C11: // Incoming jump from 0x03BA // Inputs[4] // { // @0C14 stack[-2] // @0C22 memory[0x00:0x40] // @0C24 memory[0x40:0x60] // @0C2B storage[keccak256(memory[0x00:0x40])] // } 0C11 5B JUMPDEST 0C12 60 PUSH1 0x00 0C14 82 DUP3 0C15 81 DUP2 0C16 52 MSTORE 0C17 60 PUSH1 0x0a 0C19 60 PUSH1 0x20 0C1B 90 SWAP1 0C1C 81 DUP2 0C1D 52 MSTORE 0C1E 60 PUSH1 0x40 0C20 80 DUP1 0C21 83 DUP4 0C22 20 SHA3 0C23 81 DUP2 0C24 51 MLOAD 0C25 80 DUP1 0C26 83 DUP4 0C27 01 ADD 0C28 90 SWAP1 0C29 92 SWAP3 0C2A 52 MSTORE 0C2B 54 SLOAD 0C2C 60 PUSH1 0x01 0C2E 60 PUSH1 0x01 0C30 60 PUSH1 0xa0 0C32 1B SHL 0C33 03 SUB 0C34 81 DUP2 0C35 16 AND 0C36 80 DUP1 0C37 83 DUP4 0C38 52 MSTORE 0C39 60 PUSH1 0x01 0C3B 60 PUSH1 0xa0 0C3D 1B SHL 0C3E 90 SWAP1 0C3F 91 SWAP2 0C40 04 DIV 0C41 60 PUSH1 0x01 0C43 60 PUSH1 0x01 0C45 60 PUSH1 0x60 0C47 1B SHL 0C48 03 SUB 0C49 16 AND 0C4A 92 SWAP3 0C4B 82 DUP3 0C4C 01 ADD 0C4D 92 SWAP3 0C4E 90 SWAP1 0C4F 92 SWAP3 0C50 52 MSTORE 0C51 82 DUP3 0C52 91 SWAP2 0C53 61 PUSH2 0x0c86 0C56 57 *JUMPI // Stack delta = +3 // Outputs[8] // { // @0C12 stack[0] = 0x00 // @0C16 memory[0x00:0x20] = stack[-2] // @0C1D memory[0x20:0x40] = 0x0a // @0C29 stack[2] = memory[0x40:0x60] // @0C2A memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0C38 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @0C50 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x60) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @0C52 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0c86, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_0C57: // Incoming jump from 0x0C56, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0C5B memory[0x40:0x60] // @0C64 storage[0x09] // @0C8B memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @0CA0 stack[-4] // } 0C57 50 POP 0C58 60 PUSH1 0x40 0C5A 80 DUP1 0C5B 51 MLOAD 0C5C 80 DUP1 0C5D 82 DUP3 0C5E 01 ADD 0C5F 90 SWAP1 0C60 91 SWAP2 0C61 52 MSTORE 0C62 60 PUSH1 0x09 0C64 54 SLOAD 0C65 60 PUSH1 0x01 0C67 60 PUSH1 0x01 0C69 60 PUSH1 0xa0 0C6B 1B SHL 0C6C 03 SUB 0C6D 81 DUP2 0C6E 16 AND 0C6F 82 DUP3 0C70 52 MSTORE 0C71 60 PUSH1 0x01 0C73 60 PUSH1 0xa0 0C75 1B SHL 0C76 90 SWAP1 0C77 04 DIV 0C78 60 PUSH1 0x01 0C7A 60 PUSH1 0x01 0C7C 60 PUSH1 0x60 0C7E 1B SHL 0C7F 03 SUB 0C80 16 AND 0C81 60 PUSH1 0x20 0C83 82 DUP3 0C84 01 ADD 0C85 52 MSTORE 0C86 5B JUMPDEST 0C87 60 PUSH1 0x20 0C89 81 DUP2 0C8A 01 ADD 0C8B 51 MLOAD 0C8C 60 PUSH1 0x00 0C8E 90 SWAP1 0C8F 61 PUSH2 0x2710 0C92 90 SWAP1 0C93 61 PUSH2 0x0ca5 0C96 90 SWAP1 0C97 60 PUSH1 0x01 0C99 60 PUSH1 0x01 0C9B 60 PUSH1 0x60 0C9D 1B SHL 0C9E 03 SUB 0C9F 16 AND 0CA0 87 DUP8 0CA1 61 PUSH2 0x23bf 0CA4 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0C60 stack[-1] = memory[0x40:0x60] // @0C61 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0C70 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x09] & (0x01 << 0xa0) - 0x01 // @0C85 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x60) - 0x01 & storage[0x09] / (0x01 << 0xa0) // @0C8E stack[0] = 0x00 // @0C92 stack[1] = 0x2710 // @0C96 stack[2] = 0x0ca5 // @0C9F stack[3] = (0x01 << 0x60) - 0x01 & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @0CA0 stack[4] = stack[-4] // } // Block ends with call to 0x23bf, returns to 0x0CA5 label_0CA5: // Incoming return from call to 0x23BF at 0x0CA4 // Incoming return from call to 0x23BF at 0x0CA4 // Inputs[2] // { // @0CA9 stack[-2] // @0CAA stack[-1] // } 0CA5 5B JUMPDEST 0CA6 61 PUSH2 0x0caf 0CA9 91 SWAP2 0CAA 90 SWAP1 0CAB 61 PUSH2 0x23d6 0CAE 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0CA9 stack[-2] = 0x0caf // @0CAA stack[-1] = stack[-2] // @0CAA stack[0] = stack[-1] // } // Block ends with call to 0x23d6, returns to 0x0CAF label_0CAF: // Incoming return from call to 0x23D6 at 0x0CAE // Inputs[6] // { // @0CB0 stack[-1] // @0CB0 stack[-3] // @0CB1 memory[stack[-3]:stack[-3] + 0x20] // @0CB2 stack[-5] // @0CB4 stack[-2] // @0CB5 stack[-4] // } 0CAF 5B JUMPDEST 0CB0 91 SWAP2 0CB1 51 MLOAD 0CB2 93 SWAP4 0CB3 50 POP 0CB4 90 SWAP1 0CB5 91 SWAP2 0CB6 50 POP 0CB7 50 POP // Stack delta = -3 // Outputs[2] // { // @0CB2 stack[-5] = memory[stack[-3]:stack[-3] + 0x20] // @0CB5 stack[-4] = stack[-1] // } // Block continues label_0CB8: // Incoming jump from 0x0CB7 // Incoming jump from 0x220B, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Inputs[5] // { // @0CB9 stack[-1] // @0CB9 stack[-4] // @0CBB stack[-2] // @0CBB stack[-5] // @0CBC stack[-3] // } 0CB8 5B JUMPDEST 0CB9 92 SWAP3 0CBA 50 POP 0CBB 92 SWAP3 0CBC 90 SWAP1 0CBD 50 POP 0CBE 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0CB9 stack[-4] = stack[-1] // @0CBB stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_0CBF: // Incoming jump from 0x03F9 0CBF 5B JUMPDEST 0CC0 61 PUSH2 0x0cc7 0CC3 61 PUSH2 0x17f5 0CC6 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CC0 stack[0] = 0x0cc7 } // Block ends with call to 0x17f5, returns to 0x0CC7 label_0CC7: // Incoming return from call to 0x17F5 at 0x0CC6 // Inputs[1] { @0CCA storage[0x0f] } 0CC7 5B JUMPDEST 0CC8 60 PUSH1 0x0f 0CCA 54 SLOAD 0CCB 60 PUSH1 0xff 0CCD 16 AND 0CCE 15 ISZERO 0CCF 15 ISZERO 0CD0 60 PUSH1 0x01 0CD2 14 EQ 0CD3 61 PUSH2 0x0d11 0CD6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d11, if 0x01 == !!(0xff & storage[0x0f]) label_0CD7: // Incoming jump from 0x0CD6, if not 0x01 == !!(0xff & storage[0x0f]) // Inputs[1] { @0CD9 memory[0x40:0x60] } 0CD7 60 PUSH1 0x40 0CD9 51 MLOAD 0CDA 62 PUSH3 0x461bcd 0CDE 60 PUSH1 0xe5 0CE0 1B SHL 0CE1 81 DUP2 0CE2 52 MSTORE 0CE3 60 PUSH1 0x20 0CE5 60 PUSH1 0x04 0CE7 82 DUP3 0CE8 01 ADD 0CE9 52 MSTORE 0CEA 60 PUSH1 0x10 0CEC 60 PUSH1 0x24 0CEE 82 DUP3 0CEF 01 ADD 0CF0 52 MSTORE 0CF1 6F PUSH16 0x135a5b9d18589b194e881c185d5cd959 0D02 60 PUSH1 0x82 0D04 1B SHL 0D05 60 PUSH1 0x44 0D07 82 DUP3 0D08 01 ADD 0D09 52 MSTORE 0D0A 60 PUSH1 0x64 0D0C 01 ADD 0D0D 61 PUSH2 0x093b 0D10 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0CE2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CE9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0CF0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @0D09 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x135a5b9d18589b194e881c185d5cd959 << 0x82 // @0D0C stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_0D11: // Incoming jump from 0x0CD6, if 0x01 == !!(0xff & storage[0x0f]) // Inputs[2] // { // @0D12 tx.origin // @0D13 msg.sender // } 0D11 5B JUMPDEST 0D12 32 ORIGIN 0D13 33 CALLER 0D14 14 EQ 0D15 61 PUSH2 0x0d60 0D18 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d60, if msg.sender == tx.origin label_0D19: // Incoming jump from 0x0D18, if not msg.sender == tx.origin // Inputs[1] { @0D1B memory[0x40:0x60] } 0D19 60 PUSH1 0x40 0D1B 51 MLOAD 0D1C 62 PUSH3 0x461bcd 0D20 60 PUSH1 0xe5 0D22 1B SHL 0D23 81 DUP2 0D24 52 MSTORE 0D25 60 PUSH1 0x20 0D27 60 PUSH1 0x04 0D29 82 DUP3 0D2A 01 ADD 0D2B 52 MSTORE 0D2C 60 PUSH1 0x1e 0D2E 60 PUSH1 0x24 0D30 82 DUP3 0D31 01 ADD 0D32 52 MSTORE 0D33 7F PUSH32 0x5468652063616c6c657220697320616e6f7468657220636f6e74726163740000 0D54 60 PUSH1 0x44 0D56 82 DUP3 0D57 01 ADD 0D58 52 MSTORE 0D59 60 PUSH1 0x64 0D5B 01 ADD 0D5C 61 PUSH2 0x093b 0D5F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0D24 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D2B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D32 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @0D58 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5468652063616c6c657220697320616e6f7468657220636f6e74726163740000 // @0D5B stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_0D60: // Incoming jump from 0x0D18, if msg.sender == tx.origin // Inputs[1] { @0D64 stack[-1] } 0D60 5B JUMPDEST 0D61 61 PUSH2 0x0d6b 0D64 81 DUP2 0D65 60 PUSH1 0x00 0D67 61 PUSH2 0x1842 0D6A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D61 stack[0] = 0x0d6b // @0D64 stack[1] = stack[-1] // @0D65 stack[2] = 0x00 // } // Block ends with call to 0x1842, returns to 0x0D6B label_0D6B: // Incoming return from call to 0x1842 at 0x0D6A // Inputs[1] { @0D6E storage[0x0d] } 0D6B 5B JUMPDEST 0D6C 60 PUSH1 0x0d 0D6E 54 SLOAD 0D6F 60 PUSH1 0xff 0D71 16 AND 0D72 15 ISZERO 0D73 61 PUSH2 0x0db3 0D76 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0db3, if !(0xff & storage[0x0d]) label_0D77: // Incoming jump from 0x0D76, if not !(0xff & storage[0x0d]) // Inputs[1] { @0D79 memory[0x40:0x60] } 0D77 60 PUSH1 0x40 0D79 51 MLOAD 0D7A 62 PUSH3 0x461bcd 0D7E 60 PUSH1 0xe5 0D80 1B SHL 0D81 81 DUP2 0D82 52 MSTORE 0D83 60 PUSH1 0x20 0D85 60 PUSH1 0x04 0D87 82 DUP3 0D88 01 ADD 0D89 52 MSTORE 0D8A 60 PUSH1 0x12 0D8C 60 PUSH1 0x24 0D8E 82 DUP3 0D8F 01 ADD 0D90 52 MSTORE 0D91 71 PUSH18 0x283932b9b0b6329034b99030b1ba34bb3297 0DA4 60 PUSH1 0x71 0DA6 1B SHL 0DA7 60 PUSH1 0x44 0DA9 82 DUP3 0DAA 01 ADD 0DAB 52 MSTORE 0DAC 60 PUSH1 0x64 0DAE 01 ADD 0DAF 61 PUSH2 0x093b 0DB2 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0D82 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D89 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D90 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @0DAB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x283932b9b0b6329034b99030b1ba34bb3297 << 0x71 // @0DAE stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_0DB3: // Incoming jump from 0x0D76, if !(0xff & storage[0x0d]) // Inputs[1] { @0DB6 stack[-1] } 0DB3 5B JUMPDEST 0DB4 60 PUSH1 0x01 0DB6 81 DUP2 0DB7 11 GT 0DB8 15 ISZERO 0DB9 61 PUSH2 0x0df7 0DBC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0df7, if !(stack[-1] > 0x01) label_0DBD: // Incoming jump from 0x0DBC, if not !(stack[-1] > 0x01) // Inputs[1] { @0DBF memory[0x40:0x60] } 0DBD 60 PUSH1 0x40 0DBF 51 MLOAD 0DC0 62 PUSH3 0x461bcd 0DC4 60 PUSH1 0xe5 0DC6 1B SHL 0DC7 81 DUP2 0DC8 52 MSTORE 0DC9 60 PUSH1 0x20 0DCB 60 PUSH1 0x04 0DCD 82 DUP3 0DCE 01 ADD 0DCF 52 MSTORE 0DD0 60 PUSH1 0x10 0DD2 60 PUSH1 0x24 0DD4 82 DUP3 0DD5 01 ADD 0DD6 52 MSTORE 0DD7 6F PUSH16 0x26b4b73a1030b6b7bab73a1037bb32b9 0DE8 60 PUSH1 0x81 0DEA 1B SHL 0DEB 60 PUSH1 0x44 0DED 82 DUP3 0DEE 01 ADD 0DEF 52 MSTORE 0DF0 60 PUSH1 0x64 0DF2 01 ADD 0DF3 61 PUSH2 0x093b 0DF6 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0DC8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DCF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DD6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @0DEF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x26b4b73a1030b6b7bab73a1037bb32b9 << 0x81 // @0DF2 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_0DF7: // Incoming jump from 0x0DBC, if !(stack[-1] > 0x01) // Inputs[2] // { // @0DFB msg.sender // @0DFC stack[-1] // } 0DF7 5B JUMPDEST 0DF8 61 PUSH2 0x0805 0DFB 33 CALLER 0DFC 82 DUP3 0DFD 61 PUSH2 0x192f 0E00 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DF8 stack[0] = 0x0805 // @0DFB stack[1] = msg.sender // @0DFC stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x192f label_0E01: // Incoming jump from 0x042F 0E01 5B JUMPDEST 0E02 61 PUSH2 0x0e09 0E05 61 PUSH2 0x14bc 0E08 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E02 stack[0] = 0x0e09 } // Block ends with call to 0x14bc, returns to 0x0E09 label_0E09: // Incoming return from call to 0x14BC at 0x0E08 // Inputs[3] // { // @0E0D storage[0x10] // @0E25 stack[-1] // @0E2F storage[0x0f] // } 0E09 5B JUMPDEST 0E0A 60 PUSH1 0x10 0E0C 80 DUP1 0E0D 54 SLOAD 0E0E 6B PUSH12 0xffffffffffffffffffffffff 0E1B 19 NOT 0E1C 16 AND 0E1D 60 PUSH1 0x01 0E1F 60 PUSH1 0x01 0E21 60 PUSH1 0x60 0E23 1B SHL 0E24 03 SUB 0E25 83 DUP4 0E26 16 AND 0E27 90 SWAP1 0E28 81 DUP2 0E29 17 OR 0E2A 90 SWAP1 0E2B 91 SWAP2 0E2C 55 SSTORE 0E2D 60 PUSH1 0x0f 0E2F 54 SLOAD 0E30 61 PUSH2 0x0805 0E33 91 SWAP2 0E34 61 PUSH2 0x0100 0E37 90 SWAP1 0E38 91 SWAP2 0E39 04 DIV 0E3A 60 PUSH1 0x01 0E3C 60 PUSH1 0x01 0E3E 60 PUSH1 0xa0 0E40 1B SHL 0E41 03 SUB 0E42 16 AND 0E43 90 SWAP1 0E44 61 PUSH2 0x1516 0E47 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0E2C storage[0x10] = (stack[-1] & (0x01 << 0x60) - 0x01) | (~0xffffffffffffffffffffffff & storage[0x10]) // @0E33 stack[0] = 0x0805 // @0E43 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x0f] / 0x0100 // @0E43 stack[2] = stack[-1] & (0x01 << 0x60) - 0x01 // } // Block ends with call to 0x1516, returns to 0x0805 label_0E48: // Incoming jump from 0x0465 // Incoming call from 0x177A, returns to 0x177B // Incoming call from 0x08E8, returns to 0x08E9 // Incoming call from 0x1761, returns to 0x1762 // Inputs[1] { @0E4E stack[-1] } 0E48 5B JUMPDEST 0E49 60 PUSH1 0x00 0E4B 61 PUSH2 0x0e53 0E4E 82 DUP3 0E4F 61 PUSH2 0x1613 0E52 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E49 stack[0] = 0x00 // @0E4B stack[1] = 0x0e53 // @0E4E stack[2] = stack[-1] // } // Block ends with call to 0x1613, returns to 0x0E53 label_0E53: // Incoming return from call to 0x1613 at 0x0E52 // Inputs[1] { @0E57 stack[-1] } 0E53 5B JUMPDEST 0E54 61 PUSH2 0x0eb5 0E57 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0eb5, if stack[-1] label_0E58: // Incoming jump from 0x0E57, if not stack[-1] // Inputs[1] { @0E5A memory[0x40:0x60] } 0E58 60 PUSH1 0x40 0E5A 51 MLOAD 0E5B 62 PUSH3 0x461bcd 0E5F 60 PUSH1 0xe5 0E61 1B SHL 0E62 81 DUP2 0E63 52 MSTORE 0E64 60 PUSH1 0x20 0E66 60 PUSH1 0x04 0E68 82 DUP3 0E69 01 ADD 0E6A 52 MSTORE 0E6B 60 PUSH1 0x2d 0E6D 60 PUSH1 0x24 0E6F 82 DUP3 0E70 01 ADD 0E71 52 MSTORE 0E72 7F PUSH32 0x4c6f636b61626c653a206c6f636b696e6720717565727920666f72206e6f6e65 0E93 60 PUSH1 0x44 0E95 82 DUP3 0E96 01 ADD 0E97 52 MSTORE 0E98 6C PUSH13 0x3c34b9ba32b73a103a37b5b2b7 0EA6 60 PUSH1 0x99 0EA8 1B SHL 0EA9 60 PUSH1 0x64 0EAB 82 DUP3 0EAC 01 ADD 0EAD 52 MSTORE 0EAE 60 PUSH1 0x84 0EB0 01 ADD 0EB1 61 PUSH2 0x093b 0EB4 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0E63 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E6A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E71 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2d // @0E97 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4c6f636b61626c653a206c6f636b696e6720717565727920666f72206e6f6e65 // @0EAD memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3c34b9ba32b73a103a37b5b2b7 << 0x99 // @0EB0 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_0EB5: // Incoming jump from 0x0E57, if stack[-1] // Inputs[4] // { // @0EB9 stack[-2] // @0EC4 memory[0x00:0x40] // @0EC5 storage[keccak256(memory[0x00:0x40])] // @0ECF stack[-3] // } 0EB5 5B JUMPDEST 0EB6 50 POP 0EB7 60 PUSH1 0x00 0EB9 90 SWAP1 0EBA 81 DUP2 0EBB 52 MSTORE 0EBC 60 PUSH1 0x08 0EBE 60 PUSH1 0x20 0EC0 52 MSTORE 0EC1 60 PUSH1 0x40 0EC3 90 SWAP1 0EC4 20 SHA3 0EC5 54 SLOAD 0EC6 60 PUSH1 0x01 0EC8 60 PUSH1 0x01 0ECA 60 PUSH1 0xa0 0ECC 1B SHL 0ECD 03 SUB 0ECE 16 AND 0ECF 90 SWAP1 0ED0 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0EBB memory[0x00:0x20] = stack[-2] // @0EC0 memory[0x20:0x40] = 0x08 // @0ECF stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0ED1: // Incoming jump from 0x047A 0ED1 5B JUMPDEST 0ED2 61 PUSH2 0x0ed9 0ED5 61 PUSH2 0x14bc 0ED8 56 *JUMP // Stack delta = +1 // Outputs[1] { @0ED2 stack[0] = 0x0ed9 } // Block ends with call to 0x14bc, returns to 0x0ED9 label_0ED9: // Incoming return from call to 0x14BC at 0x0ED8 // Inputs[1] { @0EE2 storage[0x0b] } 0ED9 5B JUMPDEST 0EDA 61 PUSH2 0x0ef4 0EDD 61 PUSH2 0x0eee 0EE0 60 PUSH1 0x0b 0EE2 54 SLOAD 0EE3 60 PUSH1 0x01 0EE5 60 PUSH1 0x01 0EE7 60 PUSH1 0xa0 0EE9 1B SHL 0EEA 03 SUB 0EEB 16 AND 0EEC 90 SWAP1 0EED 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0EDA stack[0] = 0x0ef4 // @0EEC stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x0b] // } // Block ends with call to 0x0eee, returns to 0x0EF4 label_0EEE: // Incoming call from 0x0EED, returns to 0x0EF4 // Inputs[2] // { // @0EEF address(this).balance // @0EEF address(this) // } 0EEE 5B JUMPDEST 0EEF 47 SELFBALANCE 0EF0 61 PUSH2 0x1a43 0EF3 56 *JUMP // Stack delta = +1 // Outputs[1] { @0EEF stack[0] = address(this).balance } // Block ends with unconditional jump to 0x1a43 label_0EF4: // Incoming return from call to 0x0EEE at 0x0EED // Incoming return from call to 0x1B5C at 0x0F05 // Incoming return from call to 0x1BCB at 0x1276 // Incoming return from call to 0x1C1D at 0x1293 // Incoming jump from 0x14CE, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0b] // Incoming jump from 0x1E2A, if 0xff & storage[0x0b] / (0x01 << 0xa0) // Incoming jump from 0x1807, if !(0xff & storage[0x0b] / (0x01 << 0xa0)) // Inputs[1] { @0EF5 stack[-1] } 0EF4 5B JUMPDEST 0EF5 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0EF6: // Incoming jump from 0x048F 0EF6 5B JUMPDEST 0EF7 61 PUSH2 0x0efe 0EFA 61 PUSH2 0x14bc 0EFD 56 *JUMP // Stack delta = +1 // Outputs[1] { @0EF7 stack[0] = 0x0efe } // Block ends with call to 0x14bc, returns to 0x0EFE label_0EFE: // Incoming return from call to 0x14BC at 0x0EFD 0EFE 5B JUMPDEST 0EFF 61 PUSH2 0x0ef4 0F02 61 PUSH2 0x1b5c 0F05 56 *JUMP // Stack delta = +1 // Outputs[1] { @0EFF stack[0] = 0x0ef4 } // Block ends with call to 0x1b5c, returns to 0x0EF4 label_0F06: // Incoming jump from 0x04A2 // Inputs[4] // { // @0F0A stack[-3] // @0F0B stack[-2] // @0F0C stack[-1] // @0F0F memory[0x40:0x60] // } 0F06 5B JUMPDEST 0F07 61 PUSH2 0x0bf1 0F0A 83 DUP4 0F0B 83 DUP4 0F0C 83 DUP4 0F0D 60 PUSH1 0x40 0F0F 51 MLOAD 0F10 80 DUP1 0F11 60 PUSH1 0x20 0F13 01 ADD 0F14 60 PUSH1 0x40 0F16 52 MSTORE 0F17 80 DUP1 0F18 60 PUSH1 0x00 0F1A 81 DUP2 0F1B 52 MSTORE 0F1C 50 POP 0F1D 61 PUSH2 0x130f 0F20 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0F07 stack[0] = 0x0bf1 // @0F0A stack[1] = stack[-3] // @0F0B stack[2] = stack[-2] // @0F0C stack[3] = stack[-1] // @0F0F stack[4] = memory[0x40:0x60] // @0F16 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0F1B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x130f label_0F21: // Incoming jump from 0x04C2 0F21 5B JUMPDEST 0F22 61 PUSH2 0x0f29 0F25 61 PUSH2 0x14bc 0F28 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F22 stack[0] = 0x0f29 } // Block ends with call to 0x14bc, returns to 0x0F29 label_0F29: // Incoming return from call to 0x14BC at 0x0F28 // Inputs[2] // { // @0F2D stack[-2] // @0F2E stack[-1] // } 0F29 5B JUMPDEST 0F2A 61 PUSH2 0x094e 0F2D 82 DUP3 0F2E 82 DUP3 0F2F 61 PUSH2 0x192f 0F32 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F2A stack[0] = 0x094e // @0F2D stack[1] = stack[-2] // @0F2E stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x192f label_0F33: // Incoming jump from 0x0512 0F33 5B JUMPDEST 0F34 61 PUSH2 0x0f3b 0F37 61 PUSH2 0x14bc 0F3A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F34 stack[0] = 0x0f3b } // Block ends with call to 0x14bc, returns to 0x0F3B label_0F3B: // Incoming return from call to 0x14BC at 0x0F3A // Inputs[2] // { // @0F3E stack[-1] // @0F3F stack[-2] // } 0F3B 5B JUMPDEST 0F3C 60 PUSH1 0x0e 0F3E 55 SSTORE 0F3F 56 *JUMP // Stack delta = -2 // Outputs[1] { @0F3E storage[0x0e] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0F40: // Incoming jump from 0x0532 0F40 5B JUMPDEST 0F41 61 PUSH2 0x0f48 0F44 61 PUSH2 0x14bc 0F47 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F41 stack[0] = 0x0f48 } // Block ends with call to 0x14bc, returns to 0x0F48 label_0F48: // Incoming return from call to 0x14BC at 0x0F47 // Inputs[1] { @0F4E stack[-1] } 0F48 5B JUMPDEST 0F49 60 PUSH1 0x0c 0F4B 61 PUSH2 0x094e 0F4E 82 DUP3 0F4F 82 DUP3 0F50 61 PUSH2 0x243e 0F53 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F49 stack[0] = 0x0c // @0F4B stack[1] = 0x094e // @0F4E stack[2] = stack[-1] // @0F4F stack[3] = 0x0c // } // Block ends with call to 0x243e, returns to 0x094E label_0F54: // Incoming jump from 0x0552 0F54 5B JUMPDEST 0F55 61 PUSH2 0x0f5c 0F58 61 PUSH2 0x14bc 0F5B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F55 stack[0] = 0x0f5c } // Block ends with call to 0x14bc, returns to 0x0F5C label_0F5C: // Incoming return from call to 0x14BC at 0x0F5B // Inputs[1] { @0F60 stack[-1] } 0F5C 5B JUMPDEST 0F5D 60 PUSH1 0x00 0F5F 5B JUMPDEST 0F60 81 DUP2 0F61 81 DUP2 0F62 10 LT 0F63 15 ISZERO 0F64 61 PUSH2 0x0fca 0F67 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0F5D stack[0] = 0x00 } // Block ends with conditional jump to 0x0fca, if !(0x00 < stack[-1]) label_0F68: // Incoming jump from 0x0F67, if not !(0x00 < stack[-1]) // Incoming jump from 0x0F67, if not !(stack[-1] < stack[-2]) // Inputs[4] // { // @0F68 stack[-4] // @0F6D stack[-3] // @0F6E stack[-2] // @0F6F stack[-1] // } 0F68 83 DUP4 0F69 60 PUSH1 0x08 0F6B 60 PUSH1 0x00 0F6D 85 DUP6 0F6E 85 DUP6 0F6F 85 DUP6 0F70 81 DUP2 0F71 81 DUP2 0F72 10 LT 0F73 61 PUSH2 0x0f7e 0F76 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @0F68 stack[0] = stack[-4] // @0F69 stack[1] = 0x08 // @0F6B stack[2] = 0x00 // @0F6D stack[3] = stack[-3] // @0F6E stack[4] = stack[-2] // @0F6F stack[5] = stack[-1] // } // Block ends with conditional jump to 0x0f7e, if stack[-1] < stack[-2] label_0F77: // Incoming jump from 0x0F76, if not stack[-1] < stack[-2] 0F77 61 PUSH2 0x0f7e 0F7A 61 PUSH2 0x24fe 0F7D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F77 stack[0] = 0x0f7e } // Block ends with unconditional jump to 0x24fe label_0F7E: // Incoming jump from 0x0F76, if stack[-1] < stack[-2] // Inputs[10] // { // @0F7F stack[-1] // @0F7F stack[-2] // @0F84 stack[-3] // @0F85 msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0F86 stack[-4] // @0F8B stack[-5] // @0F93 memory[0x00:0x00 + 0x20 + 0x20 + stack[-4]] // @0F9B storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-4]])] // @0FA9 stack[-6] // @0FB8 stack[-7] // } 0F7E 5B JUMPDEST 0F7F 90 SWAP1 0F80 50 POP 0F81 60 PUSH1 0x20 0F83 02 MUL 0F84 01 ADD 0F85 35 CALLDATALOAD 0F86 81 DUP2 0F87 52 MSTORE 0F88 60 PUSH1 0x20 0F8A 01 ADD 0F8B 90 SWAP1 0F8C 81 DUP2 0F8D 52 MSTORE 0F8E 60 PUSH1 0x20 0F90 01 ADD 0F91 60 PUSH1 0x00 0F93 20 SHA3 0F94 60 PUSH1 0x00 0F96 61 PUSH2 0x0100 0F99 0A EXP 0F9A 81 DUP2 0F9B 54 SLOAD 0F9C 81 DUP2 0F9D 60 PUSH1 0x01 0F9F 60 PUSH1 0x01 0FA1 60 PUSH1 0xa0 0FA3 1B SHL 0FA4 03 SUB 0FA5 02 MUL 0FA6 19 NOT 0FA7 16 AND 0FA8 90 SWAP1 0FA9 83 DUP4 0FAA 60 PUSH1 0x01 0FAC 60 PUSH1 0x01 0FAE 60 PUSH1 0xa0 0FB0 1B SHL 0FB1 03 SUB 0FB2 16 AND 0FB3 02 MUL 0FB4 17 OR 0FB5 90 SWAP1 0FB6 55 SSTORE 0FB7 50 POP 0FB8 80 DUP1 0FB9 80 DUP1 0FBA 61 PUSH2 0x0fc2 0FBD 90 SWAP1 0FBE 61 PUSH2 0x2514 0FC1 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @0F87 memory[stack[-4]:stack[-4] + 0x20] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0F8D memory[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] = stack[-5] // @0FB6 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-4]])] = ((0x01 << 0xa0) - 0x01 & stack[-6]) * 0x0100 ** 0x00 | (~((0x01 << 0xa0) - 0x01 * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-4]])]) // @0FB8 stack[-6] = stack[-7] // @0FBD stack[-4] = stack[-7] // @0FBD stack[-5] = 0x0fc2 // } // Block ends with call to 0x2514, returns to 0x0FC2 label_0FC2: // Incoming return from call to 0x2514 at 0x0FC1 // Inputs[2] // { // @0FC3 stack[-1] // @0FC3 stack[-3] // } 0FC2 5B JUMPDEST 0FC3 91 SWAP2 0FC4 50 POP 0FC5 50 POP 0FC6 61 PUSH2 0x0f5f 0FC9 56 *JUMP // Stack delta = -2 // Outputs[1] { @0FC3 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0f5f label_0FCA: // Incoming jump from 0x0F67, if !(0x00 < stack[-1]) // Incoming jump from 0x1757, if !(stack[-4] & (0x01 << 0xa0) - 0x01) // Incoming jump from 0x1794, if stack[-1] // Incoming jump from 0x17D4, if !(stack[-4] & (0x01 << 0xa0) - 0x01) // Incoming jump from 0x0F67, if !(stack[-1] < stack[-2]) // Inputs[1] { @0FCF stack[-5] } 0FCA 5B JUMPDEST 0FCB 50 POP 0FCC 50 POP 0FCD 50 POP 0FCE 50 POP 0FCF 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0FD0: // Incoming jump from 0x0572 // Inputs[1] { @0FD3 storage[0x0f] } 0FD0 5B JUMPDEST 0FD1 60 PUSH1 0x0f 0FD3 54 SLOAD 0FD4 60 PUSH1 0xff 0FD6 16 AND 0FD7 15 ISZERO 0FD8 15 ISZERO 0FD9 60 PUSH1 0x01 0FDB 14 EQ 0FDC 61 PUSH2 0x101a 0FDF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x101a, if 0x01 == !!(0xff & storage[0x0f]) label_0FE0: // Incoming jump from 0x0FDF, if not 0x01 == !!(0xff & storage[0x0f]) // Inputs[1] { @0FE2 memory[0x40:0x60] } 0FE0 60 PUSH1 0x40 0FE2 51 MLOAD 0FE3 62 PUSH3 0x461bcd 0FE7 60 PUSH1 0xe5 0FE9 1B SHL 0FEA 81 DUP2 0FEB 52 MSTORE 0FEC 60 PUSH1 0x20 0FEE 60 PUSH1 0x04 0FF0 82 DUP3 0FF1 01 ADD 0FF2 52 MSTORE 0FF3 60 PUSH1 0x10 0FF5 60 PUSH1 0x24 0FF7 82 DUP3 0FF8 01 ADD 0FF9 52 MSTORE 0FFA 6F PUSH16 0x135a5b9d18589b194e881c185d5cd959 100B 60 PUSH1 0x82 100D 1B SHL 100E 60 PUSH1 0x44 1010 82 DUP3 1011 01 ADD 1012 52 MSTORE 1013 60 PUSH1 0x64 1015 01 ADD 1016 61 PUSH2 0x093b 1019 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0FEB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FF2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0FF9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @1012 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x135a5b9d18589b194e881c185d5cd959 << 0x82 // @1015 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_101A: // Incoming jump from 0x0FDF, if 0x01 == !!(0xff & storage[0x0f]) 101A 5B JUMPDEST 101B 61 PUSH2 0x1022 101E 61 PUSH2 0x17f5 1021 56 *JUMP // Stack delta = +1 // Outputs[1] { @101B stack[0] = 0x1022 } // Block ends with call to 0x17f5, returns to 0x1022 label_1022: // Incoming return from call to 0x17F5 at 0x1021 // Inputs[1] { @1026 stack[-3] } 1022 5B JUMPDEST 1023 61 PUSH2 0x102d 1026 83 DUP4 1027 60 PUSH1 0x00 1029 61 PUSH2 0x1842 102C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1023 stack[0] = 0x102d // @1026 stack[1] = stack[-3] // @1027 stack[2] = 0x00 // } // Block ends with call to 0x1842, returns to 0x102D label_102D: // Incoming return from call to 0x1842 at 0x102C // Inputs[1] { @1030 storage[0x0d] } 102D 5B JUMPDEST 102E 60 PUSH1 0x0d 1030 54 SLOAD 1031 60 PUSH1 0xff 1033 16 AND 1034 61 PUSH2 0x1078 1037 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1078, if 0xff & storage[0x0d] label_1038: // Incoming jump from 0x1037, if not 0xff & storage[0x0d] // Inputs[1] { @103A memory[0x40:0x60] } 1038 60 PUSH1 0x40 103A 51 MLOAD 103B 62 PUSH3 0x461bcd 103F 60 PUSH1 0xe5 1041 1B SHL 1042 81 DUP2 1043 52 MSTORE 1044 60 PUSH1 0x20 1046 60 PUSH1 0x04 1048 82 DUP3 1049 01 ADD 104A 52 MSTORE 104B 60 PUSH1 0x16 104D 60 PUSH1 0x24 104F 82 DUP3 1050 01 ADD 1051 52 MSTORE 1052 75 PUSH22 0x283932b9b0b6329034b9903737ba1030b1ba34bb3297 1069 60 PUSH1 0x51 106B 1B SHL 106C 60 PUSH1 0x44 106E 82 DUP3 106F 01 ADD 1070 52 MSTORE 1071 60 PUSH1 0x64 1073 01 ADD 1074 61 PUSH2 0x093b 1077 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1043 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @104A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1051 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x16 // @1070 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x283932b9b0b6329034b9903737ba1030b1ba34bb3297 << 0x51 // @1073 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_1078: // Incoming jump from 0x1037, if 0xff & storage[0x0d] // Inputs[8] // { // @107B memory[0x40:0x60] // @108A msg.sender // @109C memory[0x40:0x60] // @10AA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @10AF memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @10B5 stack[-2] // @10B6 stack[-1] // @10B9 storage[0x11] // } 1078 5B JUMPDEST 1079 60 PUSH1 0x40 107B 51 MLOAD 107C 6B PUSH12 0xffffffffffffffffffffffff 1089 19 NOT 108A 33 CALLER 108B 60 PUSH1 0x60 108D 1B SHL 108E 16 AND 108F 60 PUSH1 0x20 1091 82 DUP3 1092 01 ADD 1093 52 MSTORE 1094 60 PUSH1 0x00 1096 90 SWAP1 1097 60 PUSH1 0x34 1099 01 ADD 109A 60 PUSH1 0x40 109C 51 MLOAD 109D 60 PUSH1 0x20 109F 81 DUP2 10A0 83 DUP4 10A1 03 SUB 10A2 03 SUB 10A3 81 DUP2 10A4 52 MSTORE 10A5 90 SWAP1 10A6 60 PUSH1 0x40 10A8 52 MSTORE 10A9 80 DUP1 10AA 51 MLOAD 10AB 90 SWAP1 10AC 60 PUSH1 0x20 10AE 01 ADD 10AF 20 SHA3 10B0 90 SWAP1 10B1 50 POP 10B2 61 PUSH2 0x10bf 10B5 83 DUP4 10B6 83 DUP4 10B7 60 PUSH1 0x11 10B9 54 SLOAD 10BA 84 DUP5 10BB 61 PUSH2 0x1bb1 10BE 56 *JUMP // Stack delta = +6 // Outputs[9] // { // @1093 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (msg.sender << 0x60) & ~0xffffffffffffffffffffffff // @10A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x34 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @10A8 memory[0x40:0x60] = 0x34 + memory[0x40:0x60] // @10B0 stack[0] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @10B2 stack[1] = 0x10bf // @10B5 stack[2] = stack[-2] // @10B6 stack[3] = stack[-1] // @10B9 stack[4] = storage[0x11] // @10BA stack[5] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with unconditional jump to 0x1bb1 10BF 5B JUMPDEST 10C0 61 PUSH2 0x1102 10C3 57 *JUMPI 10C4 60 PUSH1 0x40 10C6 51 MLOAD 10C7 62 PUSH3 0x461bcd 10CB 60 PUSH1 0xe5 10CD 1B SHL 10CE 81 DUP2 10CF 52 MSTORE 10D0 60 PUSH1 0x20 10D2 60 PUSH1 0x04 10D4 82 DUP3 10D5 01 ADD 10D6 52 MSTORE 10D7 60 PUSH1 0x14 10D9 60 PUSH1 0x24 10DB 82 DUP3 10DC 01 ADD 10DD 52 MSTORE 10DE 73 PUSH20 0x24b73b30b634b21026b2b935b63290283937b7b3 10F3 60 PUSH1 0x61 10F5 1B SHL 10F6 60 PUSH1 0x44 10F8 82 DUP3 10F9 01 ADD 10FA 52 MSTORE 10FB 60 PUSH1 0x64 10FD 01 ADD 10FE 61 PUSH2 0x093b 1101 56 *JUMP 1102 5B JUMPDEST 1103 60 PUSH1 0x0e 1105 54 SLOAD 1106 33 CALLER 1107 60 PUSH1 0x00 1109 90 SWAP1 110A 81 DUP2 110B 52 MSTORE 110C 60 PUSH1 0x12 110E 60 PUSH1 0x20 1110 52 MSTORE 1111 60 PUSH1 0x40 1113 90 SWAP1 1114 20 SHA3 1115 54 SLOAD 1116 61 PUSH2 0x1120 1119 90 SWAP1 111A 86 DUP7 111B 90 SWAP1 111C 61 PUSH2 0x252d 111F 56 *JUMP 1120 5B JUMPDEST 1121 11 GT 1122 15 ISZERO 1123 61 PUSH2 0x1164 1126 57 *JUMPI 1127 60 PUSH1 0x40 1129 51 MLOAD 112A 62 PUSH3 0x461bcd 112E 60 PUSH1 0xe5 1130 1B SHL 1131 81 DUP2 1132 52 MSTORE 1133 60 PUSH1 0x20 1135 60 PUSH1 0x04 1137 82 DUP3 1138 01 ADD 1139 52 MSTORE 113A 60 PUSH1 0x13 113C 60 PUSH1 0x24 113E 82 DUP3 113F 01 ADD 1140 52 MSTORE 1141 72 PUSH19 0x082d8e4cac2c8f240c6d8c2d2dacac840dac2f 1155 60 PUSH1 0x6b 1157 1B SHL 1158 60 PUSH1 0x44 115A 82 DUP3 115B 01 ADD 115C 52 MSTORE 115D 60 PUSH1 0x64 115F 01 ADD 1160 61 PUSH2 0x093b 1163 56 *JUMP 1164 5B JUMPDEST 1165 61 PUSH2 0x116e 1168 33 CALLER 1169 85 DUP6 116A 61 PUSH2 0x192f 116D 56 *JUMP 116E 5B JUMPDEST 116F 33 CALLER 1170 60 PUSH1 0x00 1172 90 SWAP1 1173 81 DUP2 1174 52 MSTORE 1175 60 PUSH1 0x12 1177 60 PUSH1 0x20 1179 52 MSTORE 117A 60 PUSH1 0x40 117C 81 DUP2 117D 20 SHA3 117E 80 DUP1 117F 54 SLOAD 1180 86 DUP7 1181 92 SWAP3 1182 90 SWAP1 1183 61 PUSH2 0x118d 1186 90 SWAP1 1187 84 DUP5 1188 90 SWAP1 1189 61 PUSH2 0x252d 118C 56 *JUMP 118D 5B JUMPDEST 118E 90 SWAP1 118F 91 SWAP2 1190 55 SSTORE 1191 50 POP 1192 50 POP 1193 50 POP 1194 50 POP 1195 50 POP 1196 50 POP 1197 56 *JUMP label_1198: // Incoming jump from 0x05B1 // Inputs[4] // { // @119B stack[-1] // @11A6 memory[0x00:0x40] // @11A7 storage[keccak256(memory[0x00:0x40])] // @11B1 msg.sender // } 1198 5B JUMPDEST 1199 60 PUSH1 0x00 119B 81 DUP2 119C 81 DUP2 119D 52 MSTORE 119E 60 PUSH1 0x08 11A0 60 PUSH1 0x20 11A2 52 MSTORE 11A3 60 PUSH1 0x40 11A5 90 SWAP1 11A6 20 SHA3 11A7 54 SLOAD 11A8 60 PUSH1 0x01 11AA 60 PUSH1 0x01 11AC 60 PUSH1 0xa0 11AE 1B SHL 11AF 03 SUB 11B0 16 AND 11B1 33 CALLER 11B2 14 EQ 11B3 61 PUSH2 0x11ed 11B6 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @119D memory[0x00:0x20] = stack[-1] // @11A2 memory[0x20:0x40] = 0x08 // } // Block ends with conditional jump to 0x11ed, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_11B7: // Incoming jump from 0x11B6, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @11B9 memory[0x40:0x60] } 11B7 60 PUSH1 0x40 11B9 51 MLOAD 11BA 62 PUSH3 0x461bcd 11BE 60 PUSH1 0xe5 11C0 1B SHL 11C1 81 DUP2 11C2 52 MSTORE 11C3 60 PUSH1 0x20 11C5 60 PUSH1 0x04 11C7 82 DUP3 11C8 01 ADD 11C9 52 MSTORE 11CA 60 PUSH1 0x0c 11CC 60 PUSH1 0x24 11CE 82 DUP3 11CF 01 ADD 11D0 52 MSTORE 11D1 6B PUSH12 0x2727aa2faaa72627a1a5a2a9 11DE 60 PUSH1 0xa1 11E0 1B SHL 11E1 60 PUSH1 0x44 11E3 82 DUP3 11E4 01 ADD 11E5 52 MSTORE 11E6 60 PUSH1 0x64 11E8 01 ADD 11E9 61 PUSH2 0x093b 11EC 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @11C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11C9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11D0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @11E5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x2727aa2faaa72627a1a5a2a9 << 0xa1 // @11E8 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_11ED: // Incoming jump from 0x11B6, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @11F0 stack[-1] // @11FB memory[0x00:0x40] // @11FD storage[keccak256(memory[0x00:0x40])] // @120A stack[-2] // } 11ED 5B JUMPDEST 11EE 60 PUSH1 0x00 11F0 90 SWAP1 11F1 81 DUP2 11F2 52 MSTORE 11F3 60 PUSH1 0x08 11F5 60 PUSH1 0x20 11F7 52 MSTORE 11F8 60 PUSH1 0x40 11FA 90 SWAP1 11FB 20 SHA3 11FC 80 DUP1 11FD 54 SLOAD 11FE 60 PUSH1 0x01 1200 60 PUSH1 0x01 1202 60 PUSH1 0xa0 1204 1B SHL 1205 03 SUB 1206 19 NOT 1207 16 AND 1208 90 SWAP1 1209 55 SSTORE 120A 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @11F2 memory[0x00:0x20] = stack[-1] // @11F7 memory[0x20:0x40] = 0x08 // @1209 storage[keccak256(memory[0x00:0x40])] = ~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_120B: // Incoming jump from 0x05D1 // Incoming call from 0x1644, returns to 0x1645 // Incoming call from 0x0B0E, returns to 0x0B0F // Inputs[1] { @1211 stack[-1] } 120B 5B JUMPDEST 120C 60 PUSH1 0x00 120E 61 PUSH2 0x07b3 1211 82 DUP3 1212 61 PUSH2 0x16da 1215 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @120C stack[0] = 0x00 // @120E stack[1] = 0x07b3 // @1211 stack[2] = stack[-1] // } // Block ends with call to 0x16da, returns to 0x07B3 label_1216: // Incoming jump from 0x05F1 // Inputs[1] { @1221 stack[-1] } 1216 5B JUMPDEST 1217 60 PUSH1 0x00 1219 60 PUSH1 0x01 121B 60 PUSH1 0x01 121D 60 PUSH1 0xa0 121F 1B SHL 1220 03 SUB 1221 82 DUP3 1222 16 AND 1223 61 PUSH2 0x123f 1226 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1217 stack[0] = 0x00 } // Block ends with conditional jump to 0x123f, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1227: // Incoming jump from 0x1226, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1229 memory[0x40:0x60] // @1239 memory[0x40:0x60] // @123E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1227 60 PUSH1 0x40 1229 51 MLOAD 122A 63 PUSH4 0x23d3ad81 122F 60 PUSH1 0xe2 1231 1B SHL 1232 81 DUP2 1233 52 MSTORE 1234 60 PUSH1 0x04 1236 01 ADD 1237 60 PUSH1 0x40 1239 51 MLOAD 123A 80 DUP1 123B 91 SWAP2 123C 03 SUB 123D 90 SWAP1 123E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1233 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x23d3ad81 << 0xe2 // @123E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_123F: // Incoming jump from 0x1226, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @1249 stack[-2] // @1257 memory[0x00:0x40] // @1258 storage[keccak256(memory[0x00:0x40])] // @1263 stack[-3] // } 123F 5B JUMPDEST 1240 50 POP 1241 60 PUSH1 0x01 1243 60 PUSH1 0x01 1245 60 PUSH1 0xa0 1247 1B SHL 1248 03 SUB 1249 16 AND 124A 60 PUSH1 0x00 124C 90 SWAP1 124D 81 DUP2 124E 52 MSTORE 124F 60 PUSH1 0x05 1251 60 PUSH1 0x20 1253 52 MSTORE 1254 60 PUSH1 0x40 1256 90 SWAP1 1257 20 SHA3 1258 54 SLOAD 1259 67 PUSH8 0xffffffffffffffff 1262 16 AND 1263 90 SWAP1 1264 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @124E memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1253 memory[0x20:0x40] = 0x05 // @1263 stack[-3] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1265: // Incoming jump from 0x0606 1265 5B JUMPDEST 1266 61 PUSH2 0x126d 1269 61 PUSH2 0x14bc 126C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1266 stack[0] = 0x126d } // Block ends with call to 0x14bc, returns to 0x126D label_126D: // Incoming return from call to 0x14BC at 0x126C 126D 5B JUMPDEST 126E 61 PUSH2 0x0ef4 1271 60 PUSH1 0x00 1273 61 PUSH2 0x1bcb 1276 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @126E stack[0] = 0x0ef4 // @1271 stack[1] = 0x00 // } // Block ends with call to 0x1bcb, returns to 0x0EF4 label_1277: // Incoming jump from 0x0626 1277 5B JUMPDEST 1278 61 PUSH2 0x127f 127B 61 PUSH2 0x14bc 127E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1278 stack[0] = 0x127f } // Block ends with call to 0x14bc, returns to 0x127F label_127F: // Incoming return from call to 0x14BC at 0x127E // Inputs[2] // { // @1282 stack[-1] // @1283 stack[-2] // } 127F 5B JUMPDEST 1280 60 PUSH1 0x11 1282 55 SSTORE 1283 56 *JUMP // Stack delta = -2 // Outputs[1] { @1282 storage[0x11] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_1284: // Incoming jump from 0x063B 1284 5B JUMPDEST 1285 61 PUSH2 0x128c 1288 61 PUSH2 0x14bc 128B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1285 stack[0] = 0x128c } // Block ends with call to 0x14bc, returns to 0x128C label_128C: // Incoming return from call to 0x14BC at 0x128B 128C 5B JUMPDEST 128D 61 PUSH2 0x0ef4 1290 61 PUSH2 0x1c1d 1293 56 *JUMP // Stack delta = +1 // Outputs[1] { @128D stack[0] = 0x0ef4 } // Block ends with call to 0x1c1d, returns to 0x0EF4 label_1294: // Incoming call from 0x066E, returns to 0x02CD // Inputs[1] { @129A storage[0x03] } 1294 5B JUMPDEST 1295 60 PUSH1 0x60 1297 60 PUSH1 0x03 1299 80 DUP1 129A 54 SLOAD 129B 61 PUSH2 0x0817 129E 90 SWAP1 129F 61 PUSH2 0x236f 12A2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1295 stack[0] = 0x60 // @1297 stack[1] = 0x03 // @129E stack[2] = 0x0817 // @129E stack[3] = storage[0x03] // } // Block ends with call to 0x236f, returns to 0x0817 label_12A3: // Incoming jump from 0x068E // Inputs[10] // { // @12A4 msg.sender // @12B5 memory[0x00:0x40] // @12BE stack[-2] // @12C9 memory[0x00:0x40] // @12CB storage[keccak256(memory[0x00:0x40])] // @12D0 stack[-1] // @12DA memory[0x40:0x60] // @1306 memory[0x40:0x60] // @130B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @130E stack[-3] // } 12A3 5B JUMPDEST 12A4 33 CALLER 12A5 60 PUSH1 0x00 12A7 81 DUP2 12A8 81 DUP2 12A9 52 MSTORE 12AA 60 PUSH1 0x07 12AC 60 PUSH1 0x20 12AE 90 SWAP1 12AF 81 DUP2 12B0 52 MSTORE 12B1 60 PUSH1 0x40 12B3 80 DUP1 12B4 83 DUP4 12B5 20 SHA3 12B6 60 PUSH1 0x01 12B8 60 PUSH1 0x01 12BA 60 PUSH1 0xa0 12BC 1B SHL 12BD 03 SUB 12BE 87 DUP8 12BF 16 AND 12C0 80 DUP1 12C1 85 DUP6 12C2 52 MSTORE 12C3 90 SWAP1 12C4 83 DUP4 12C5 52 MSTORE 12C6 92 SWAP3 12C7 81 DUP2 12C8 90 SWAP1 12C9 20 SHA3 12CA 80 DUP1 12CB 54 SLOAD 12CC 60 PUSH1 0xff 12CE 19 NOT 12CF 16 AND 12D0 86 DUP7 12D1 15 ISZERO 12D2 15 ISZERO 12D3 90 SWAP1 12D4 81 DUP2 12D5 17 OR 12D6 90 SWAP1 12D7 91 SWAP2 12D8 55 SSTORE 12D9 90 SWAP1 12DA 51 MLOAD 12DB 90 SWAP1 12DC 81 DUP2 12DD 52 MSTORE 12DE 91 SWAP2 12DF 92 SWAP3 12E0 91 SWAP2 12E1 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1302 91 SWAP2 1303 01 ADD 1304 60 PUSH1 0x40 1306 51 MLOAD 1307 80 DUP1 1308 91 SWAP2 1309 03 SUB 130A 90 SWAP1 130B A3 LOG3 130C 50 POP 130D 50 POP 130E 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @12A9 memory[0x00:0x20] = msg.sender // @12B0 memory[0x20:0x40] = 0x07 // @12C2 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @12C5 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @12D8 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @12DD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @130B 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_130F: // Incoming jump from 0x0F20 // Incoming jump from 0x06C6 // Inputs[3] // { // @1313 stack[-4] // @1314 stack[-3] // @1315 stack[-2] // } 130F 5B JUMPDEST 1310 61 PUSH2 0x131a 1313 84 DUP5 1314 84 DUP5 1315 84 DUP5 1316 61 PUSH2 0x0952 1319 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1310 stack[0] = 0x131a // @1313 stack[1] = stack[-4] // @1314 stack[2] = stack[-3] // @1315 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x0952 131A 5B JUMPDEST 131B 60 PUSH1 0x01 131D 60 PUSH1 0x01 131F 60 PUSH1 0xa0 1321 1B SHL 1322 03 SUB 1323 83 DUP4 1324 16 AND 1325 3B EXTCODESIZE 1326 15 ISZERO 1327 61 PUSH2 0x0fca 132A 57 *JUMPI 132B 61 PUSH2 0x1336 132E 84 DUP5 132F 84 DUP5 1330 84 DUP5 1331 84 DUP5 1332 61 PUSH2 0x1c60 1335 56 *JUMP 1336 5B JUMPDEST 1337 61 PUSH2 0x0fca 133A 57 *JUMPI 133B 60 PUSH1 0x40 133D 51 MLOAD 133E 63 PUSH4 0x68d2bf6b 1343 60 PUSH1 0xe1 1345 1B SHL 1346 81 DUP2 1347 52 MSTORE 1348 60 PUSH1 0x04 134A 01 ADD 134B 60 PUSH1 0x40 134D 51 MLOAD 134E 80 DUP1 134F 91 SWAP2 1350 03 SUB 1351 90 SWAP1 1352 FD *REVERT label_1353: // Incoming jump from 0x071E 1353 5B JUMPDEST 1354 61 PUSH2 0x135b 1357 61 PUSH2 0x14bc 135A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1354 stack[0] = 0x135b } // Block ends with call to 0x14bc, returns to 0x135B label_135B: // Incoming return from call to 0x14BC at 0x135A // Inputs[3] // { // @135F storage[0x0d] // @1364 stack[-1] // @136D stack[-2] // } 135B 5B JUMPDEST 135C 60 PUSH1 0x0d 135E 80 DUP1 135F 54 SLOAD 1360 60 PUSH1 0xff 1362 19 NOT 1363 16 AND 1364 91 SWAP2 1365 15 ISZERO 1366 15 ISZERO 1367 91 SWAP2 1368 90 SWAP1 1369 91 SWAP2 136A 17 OR 136B 90 SWAP1 136C 55 SSTORE 136D 56 *JUMP // Stack delta = -2 // Outputs[1] { @136C storage[0x0d] = !!stack[-1] | (~0xff & storage[0x0d]) } // Block ends with unconditional jump to stack[-2] label_136E: // Incoming jump from 0x073E // Inputs[1] { @1374 stack[-1] } 136E 5B JUMPDEST 136F 60 PUSH1 0x60 1371 61 PUSH2 0x1379 1374 82 DUP3 1375 61 PUSH2 0x1d48 1378 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @136F stack[0] = 0x60 // @1371 stack[1] = 0x1379 // @1374 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x1d48 1379 5B JUMPDEST 137A 60 PUSH1 0x40 137C 51 MLOAD 137D 80 DUP1 137E 60 PUSH1 0x40 1380 01 ADD 1381 60 PUSH1 0x40 1383 52 MSTORE 1384 80 DUP1 1385 60 PUSH1 0x05 1387 81 DUP2 1388 52 MSTORE 1389 60 PUSH1 0x20 138B 01 ADD 138C 64 PUSH5 0x173539b7b7 1392 60 PUSH1 0xd9 1394 1B SHL 1395 81 DUP2 1396 52 MSTORE 1397 50 POP 1398 60 PUSH1 0x40 139A 51 MLOAD 139B 60 PUSH1 0x20 139D 01 ADD 139E 61 PUSH2 0x13a8 13A1 92 SWAP3 13A2 91 SWAP2 13A3 90 SWAP1 13A4 61 PUSH2 0x2540 13A7 56 *JUMP 13A8 5B JUMPDEST 13A9 60 PUSH1 0x40 13AB 51 MLOAD 13AC 60 PUSH1 0x20 13AE 81 DUP2 13AF 83 DUP4 13B0 03 SUB 13B1 03 SUB 13B2 81 DUP2 13B3 52 MSTORE 13B4 90 SWAP1 13B5 60 PUSH1 0x40 13B7 52 MSTORE 13B8 90 SWAP1 13B9 50 POP 13BA 91 SWAP2 13BB 90 SWAP1 13BC 50 POP 13BD 56 *JUMP label_13BE: // Incoming jump from 0x075E // Incoming call from 0x09BF, returns to 0x09C0 // Incoming call from 0x0B2C, returns to 0x0B2D // Incoming call from 0x1660, returns to 0x1661 // Inputs[6] // { // @13C7 stack[-2] // @13DA memory[0x00:0x40] // @13DB stack[-1] // @13E5 memory[0x00:0x40] // @13E6 storage[keccak256(memory[0x00:0x40])] // @13EA stack[-3] // } 13BE 5B JUMPDEST 13BF 60 PUSH1 0x01 13C1 60 PUSH1 0x01 13C3 60 PUSH1 0xa0 13C5 1B SHL 13C6 03 SUB 13C7 91 SWAP2 13C8 82 DUP3 13C9 16 AND 13CA 60 PUSH1 0x00 13CC 90 SWAP1 13CD 81 DUP2 13CE 52 MSTORE 13CF 60 PUSH1 0x07 13D1 60 PUSH1 0x20 13D3 90 SWAP1 13D4 81 DUP2 13D5 52 MSTORE 13D6 60 PUSH1 0x40 13D8 80 DUP1 13D9 83 DUP4 13DA 20 SHA3 13DB 93 SWAP4 13DC 90 SWAP1 13DD 94 SWAP5 13DE 16 AND 13DF 82 DUP3 13E0 52 MSTORE 13E1 91 SWAP2 13E2 90 SWAP1 13E3 91 SWAP2 13E4 52 MSTORE 13E5 20 SHA3 13E6 54 SLOAD 13E7 60 PUSH1 0xff 13E9 16 AND 13EA 90 SWAP1 13EB 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @13CE memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @13D5 memory[0x20:0x40] = 0x07 // @13E0 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @13E4 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @13EA stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_13EC: // Incoming jump from 0x077E 13EC 5B JUMPDEST 13ED 61 PUSH2 0x13f4 13F0 61 PUSH2 0x14bc 13F3 56 *JUMP // Stack delta = +1 // Outputs[1] { @13ED stack[0] = 0x13f4 } // Block ends with call to 0x14bc, returns to 0x13F4 label_13F4: // Incoming return from call to 0x14BC at 0x13F3 // Inputs[1] { @13FD stack[-1] } 13F4 5B JUMPDEST 13F5 60 PUSH1 0x01 13F7 60 PUSH1 0x01 13F9 60 PUSH1 0xa0 13FB 1B SHL 13FC 03 SUB 13FD 81 DUP2 13FE 16 AND 13FF 61 PUSH2 0x1459 1402 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1459, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1403: // Incoming jump from 0x1402, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1405 memory[0x40:0x60] } 1403 60 PUSH1 0x40 1405 51 MLOAD 1406 62 PUSH3 0x461bcd 140A 60 PUSH1 0xe5 140C 1B SHL 140D 81 DUP2 140E 52 MSTORE 140F 60 PUSH1 0x20 1411 60 PUSH1 0x04 1413 82 DUP3 1414 01 ADD 1415 52 MSTORE 1416 60 PUSH1 0x26 1418 60 PUSH1 0x24 141A 82 DUP3 141B 01 ADD 141C 52 MSTORE 141D 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 143E 60 PUSH1 0x44 1440 82 DUP3 1441 01 ADD 1442 52 MSTORE 1443 65 PUSH6 0x646472657373 144A 60 PUSH1 0xd0 144C 1B SHL 144D 60 PUSH1 0x64 144F 82 DUP3 1450 01 ADD 1451 52 MSTORE 1452 60 PUSH1 0x84 1454 01 ADD 1455 61 PUSH2 0x093b 1458 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @140E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1415 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @141C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1442 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @1451 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @1454 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_1459: // Incoming jump from 0x1402, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @145D stack[-1] } 1459 5B JUMPDEST 145A 61 PUSH2 0x0805 145D 81 DUP2 145E 61 PUSH2 0x1bcb 1461 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @145A stack[0] = 0x0805 // @145D stack[1] = stack[-1] // } // Block ends with call to 0x1bcb, returns to 0x0805 label_1462: // Incoming call from 0x07A3, returns to 0x07A4 // Inputs[1] { @146E stack[-1] } 1462 5B JUMPDEST 1463 60 PUSH1 0x00 1465 60 PUSH1 0x01 1467 60 PUSH1 0x01 1469 60 PUSH1 0xe0 146B 1B SHL 146C 03 SUB 146D 19 NOT 146E 82 DUP3 146F 16 AND 1470 63 PUSH4 0x072b6811 1475 60 PUSH1 0xe4 1477 1B SHL 1478 14 EQ 1479 80 DUP1 147A 61 PUSH2 0x07b3 147D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1463 stack[0] = 0x00 // @1478 stack[1] = 0x072b6811 << 0xe4 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x07b3, if 0x072b6811 << 0xe4 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_147E: // Incoming jump from 0x147D, if not 0x072b6811 << 0xe4 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1482 stack[-3] } 147E 50 POP 147F 61 PUSH2 0x07b3 1482 82 DUP3 1483 61 PUSH2 0x1dcb 1486 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @147F stack[-1] = 0x07b3 // @1482 stack[0] = stack[-3] // } // Block ends with call to 0x1dcb, returns to 0x07B3 label_1487: // Incoming call from 0x07B2, returns to 0x07B3 // Inputs[1] { @1493 stack[-1] } 1487 5B JUMPDEST 1488 60 PUSH1 0x00 148A 60 PUSH1 0x01 148C 60 PUSH1 0x01 148E 60 PUSH1 0xe0 1490 1B SHL 1491 03 SUB 1492 19 NOT 1493 82 DUP3 1494 16 AND 1495 63 PUSH4 0x152a902d 149A 60 PUSH1 0xe1 149C 1B SHL 149D 14 EQ 149E 80 DUP1 149F 61 PUSH2 0x07b3 14A2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1488 stack[0] = 0x00 // @149D stack[1] = 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x07b3, if 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_14A3: // Incoming jump from 0x14A2, if not 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @14B5 stack[-3] } 14A3 50 POP 14A4 63 PUSH4 0x01ffc9a7 14A9 60 PUSH1 0xe0 14AB 1B SHL 14AC 60 PUSH1 0x01 14AE 60 PUSH1 0x01 14B0 60 PUSH1 0xe0 14B2 1B SHL 14B3 03 SUB 14B4 19 NOT 14B5 83 DUP4 14B6 16 AND 14B7 14 EQ 14B8 61 PUSH2 0x07b3 14BB 56 *JUMP // Stack delta = +0 // Outputs[1] { @14B7 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to 0x07b3 label_14BC: // Incoming call from 0x126C, returns to 0x126D // Incoming call from 0x128B, returns to 0x128C // Incoming call from 0x135A, returns to 0x135B // Incoming call from 0x0EFD, returns to 0x0EFE // Incoming call from 0x13F3, returns to 0x13F4 // Incoming call from 0x07C0, returns to 0x07C1 // Incoming call from 0x0F3A, returns to 0x0F3B // Incoming call from 0x0BFD, returns to 0x0BFE // Incoming call from 0x0F28, returns to 0x0F29 // Incoming call from 0x0F47, returns to 0x0F48 // Incoming call from 0x0ED8, returns to 0x0ED9 // Incoming call from 0x127E, returns to 0x127F // Incoming call from 0x0F5B, returns to 0x0F5C // Incoming call from 0x0E08, returns to 0x0E09 // Inputs[2] // { // @14BF storage[0x0b] // @14C9 msg.sender // } 14BC 5B JUMPDEST 14BD 60 PUSH1 0x0b 14BF 54 SLOAD 14C0 60 PUSH1 0x01 14C2 60 PUSH1 0x01 14C4 60 PUSH1 0xa0 14C6 1B SHL 14C7 03 SUB 14C8 16 AND 14C9 33 CALLER 14CA 14 EQ 14CB 61 PUSH2 0x0ef4 14CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ef4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0b] label_14CF: // Incoming jump from 0x14CE, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0b] // Inputs[1] { @14D1 memory[0x40:0x60] } 14CF 60 PUSH1 0x40 14D1 51 MLOAD 14D2 62 PUSH3 0x461bcd 14D6 60 PUSH1 0xe5 14D8 1B SHL 14D9 81 DUP2 14DA 52 MSTORE 14DB 60 PUSH1 0x20 14DD 60 PUSH1 0x04 14DF 82 DUP3 14E0 01 ADD 14E1 81 DUP2 14E2 90 SWAP1 14E3 52 MSTORE 14E4 60 PUSH1 0x24 14E6 82 DUP3 14E7 01 ADD 14E8 52 MSTORE 14E9 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 150A 60 PUSH1 0x44 150C 82 DUP3 150D 01 ADD 150E 52 MSTORE 150F 60 PUSH1 0x64 1511 01 ADD 1512 61 PUSH2 0x093b 1515 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @14DA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @14E3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @14E8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @150E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1511 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_1516: // Incoming call from 0x0804, returns to 0x0805 // Incoming call from 0x0E47, returns to 0x0805 // Inputs[1] { @1522 stack[-1] } 1516 5B JUMPDEST 1517 61 PUSH2 0x2710 151A 60 PUSH1 0x01 151C 60 PUSH1 0x01 151E 60 PUSH1 0x60 1520 1B SHL 1521 03 SUB 1522 82 DUP3 1523 16 AND 1524 11 GT 1525 15 ISZERO 1526 61 PUSH2 0x1584 1529 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1584, if !(stack[-1] & (0x01 << 0x60) - 0x01 > 0x2710) label_152A: // Incoming jump from 0x1529, if not !(stack[-1] & (0x01 << 0x60) - 0x01 > 0x2710) // Inputs[1] { @152C memory[0x40:0x60] } 152A 60 PUSH1 0x40 152C 51 MLOAD 152D 62 PUSH3 0x461bcd 1531 60 PUSH1 0xe5 1533 1B SHL 1534 81 DUP2 1535 52 MSTORE 1536 60 PUSH1 0x20 1538 60 PUSH1 0x04 153A 82 DUP3 153B 01 ADD 153C 52 MSTORE 153D 60 PUSH1 0x2a 153F 60 PUSH1 0x24 1541 82 DUP3 1542 01 ADD 1543 52 MSTORE 1544 7F PUSH32 0x455243323938313a20726f79616c7479206665652077696c6c20657863656564 1565 60 PUSH1 0x44 1567 82 DUP3 1568 01 ADD 1569 52 MSTORE 156A 69 PUSH10 0x2073616c655072696365 1575 60 PUSH1 0xb0 1577 1B SHL 1578 60 PUSH1 0x64 157A 82 DUP3 157B 01 ADD 157C 52 MSTORE 157D 60 PUSH1 0x84 157F 01 ADD 1580 61 PUSH2 0x093b 1583 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1535 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @153C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1543 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @1569 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243323938313a20726f79616c7479206665652077696c6c20657863656564 // @157C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x2073616c655072696365 << 0xb0 // @157F stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_1584: // Incoming jump from 0x1529, if !(stack[-1] & (0x01 << 0x60) - 0x01 > 0x2710) // Inputs[1] { @158D stack[-2] } 1584 5B JUMPDEST 1585 60 PUSH1 0x01 1587 60 PUSH1 0x01 1589 60 PUSH1 0xa0 158B 1B SHL 158C 03 SUB 158D 82 DUP3 158E 16 AND 158F 61 PUSH2 0x15da 1592 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15da, if stack[-2] & (0x01 << 0xa0) - 0x01 label_1593: // Incoming jump from 0x1592, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1595 memory[0x40:0x60] } 1593 60 PUSH1 0x40 1595 51 MLOAD 1596 62 PUSH3 0x461bcd 159A 60 PUSH1 0xe5 159C 1B SHL 159D 81 DUP2 159E 52 MSTORE 159F 60 PUSH1 0x20 15A1 60 PUSH1 0x04 15A3 82 DUP3 15A4 01 ADD 15A5 52 MSTORE 15A6 60 PUSH1 0x19 15A8 60 PUSH1 0x24 15AA 82 DUP3 15AB 01 ADD 15AC 52 MSTORE 15AD 7F PUSH32 0x455243323938313a20696e76616c696420726563656976657200000000000000 15CE 60 PUSH1 0x44 15D0 82 DUP3 15D1 01 ADD 15D2 52 MSTORE 15D3 60 PUSH1 0x64 15D5 01 ADD 15D6 61 PUSH2 0x093b 15D9 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @159E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @15A5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @15AC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @15D2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243323938313a20696e76616c696420726563656976657200000000000000 // @15D5 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_15DA: // Incoming jump from 0x1592, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @15DE memory[0x40:0x60] // @15EE stack[-2] // @15FC stack[-1] // @1612 stack[-3] // } 15DA 5B JUMPDEST 15DB 60 PUSH1 0x40 15DD 80 DUP1 15DE 51 MLOAD 15DF 80 DUP1 15E0 82 DUP3 15E1 01 ADD 15E2 90 SWAP1 15E3 91 SWAP2 15E4 52 MSTORE 15E5 60 PUSH1 0x01 15E7 60 PUSH1 0x01 15E9 60 PUSH1 0xa0 15EB 1B SHL 15EC 03 SUB 15ED 90 SWAP1 15EE 92 SWAP3 15EF 16 AND 15F0 80 DUP1 15F1 83 DUP4 15F2 52 MSTORE 15F3 60 PUSH1 0x01 15F5 60 PUSH1 0x01 15F7 60 PUSH1 0x60 15F9 1B SHL 15FA 03 SUB 15FB 90 SWAP1 15FC 91 SWAP2 15FD 16 AND 15FE 60 PUSH1 0x20 1600 90 SWAP1 1601 92 SWAP3 1602 01 ADD 1603 82 DUP3 1604 90 SWAP1 1605 52 MSTORE 1606 60 PUSH1 0x01 1608 60 PUSH1 0xa0 160A 1B SHL 160B 90 SWAP1 160C 91 SWAP2 160D 02 MUL 160E 17 OR 160F 60 PUSH1 0x09 1611 55 SSTORE 1612 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @15E4 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @15F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1605 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] & (0x01 << 0x60) - 0x01 // @1611 storage[0x09] = (stack[-1] & (0x01 << 0x60) - 0x01) * (0x01 << 0xa0) | (stack[-2] & (0x01 << 0xa0) - 0x01) // } // Block ends with unconditional jump to stack[-3] label_1613: // Incoming call from 0x08A4, returns to 0x08A5 // Incoming call from 0x1D52, returns to 0x1D53 // Incoming call from 0x0E52, returns to 0x0E53 // Inputs[2] // { // @1617 storage[0x00] // @1618 stack[-1] // } 1613 5B JUMPDEST 1614 60 PUSH1 0x00 1616 80 DUP1 1617 54 SLOAD 1618 82 DUP3 1619 10 LT 161A 80 DUP1 161B 15 ISZERO 161C 61 PUSH2 0x07b3 161F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1614 stack[0] = 0x00 // @1619 stack[1] = stack[-1] < storage[0x00] // } // Block ends with conditional jump to 0x07b3, if !(stack[-1] < storage[0x00]) label_1620: // Incoming jump from 0x161F, if not !(stack[-1] < storage[0x00]) // Inputs[4] // { // @1624 stack[-3] // @162F memory[0x00:0x40] // @1630 storage[keccak256(memory[0x00:0x40])] // @1638 stack[-4] // } 1620 50 POP 1621 50 POP 1622 60 PUSH1 0x00 1624 90 SWAP1 1625 81 DUP2 1626 52 MSTORE 1627 60 PUSH1 0x04 1629 60 PUSH1 0x20 162B 52 MSTORE 162C 60 PUSH1 0x40 162E 90 SWAP1 162F 20 SHA3 1630 54 SLOAD 1631 60 PUSH1 0x01 1633 60 PUSH1 0xe0 1635 1B SHL 1636 16 AND 1637 15 ISZERO 1638 90 SWAP1 1639 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1626 memory[0x00:0x20] = stack[-3] // @162B memory[0x20:0x40] = 0x04 // @1638 stack[-4] = !((0x01 << 0xe0) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-4] label_163A: // Incoming call from 0x0BF0, returns to 0x0BF1 // Incoming call from 0x094D, returns to 0x094E // Inputs[1] { @1640 stack[-1] } 163A 5B JUMPDEST 163B 60 PUSH1 0x00 163D 61 PUSH2 0x1645 1640 82 DUP3 1641 61 PUSH2 0x120b 1644 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @163B stack[0] = 0x00 // @163D stack[1] = 0x1645 // @1640 stack[2] = stack[-1] // } // Block ends with call to 0x120b, returns to 0x1645 label_1645: // Incoming return from call to 0x120B at 0x1644 // Inputs[3] // { // @1646 stack[-2] // @1646 stack[-1] // @1648 msg.sender // } 1645 5B JUMPDEST 1646 90 SWAP1 1647 50 POP 1648 33 CALLER 1649 60 PUSH1 0x01 164B 60 PUSH1 0x01 164D 60 PUSH1 0xa0 164F 1B SHL 1650 03 SUB 1651 82 DUP3 1652 16 AND 1653 14 EQ 1654 61 PUSH2 0x167e 1657 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1646 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x167e, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_1658: // Incoming jump from 0x1657, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @165B stack[-1] // @165C msg.sender // } 1658 61 PUSH2 0x1661 165B 81 DUP2 165C 33 CALLER 165D 61 PUSH2 0x13be 1660 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1658 stack[0] = 0x1661 // @165B stack[1] = stack[-1] // @165C stack[2] = msg.sender // } // Block ends with call to 0x13be, returns to 0x1661 label_1661: // Incoming return from call to 0x13BE at 0x1660 // Inputs[1] { @1665 stack[-1] } 1661 5B JUMPDEST 1662 61 PUSH2 0x167e 1665 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x167e, if stack[-1] label_1666: // Incoming jump from 0x1665, if not stack[-1] // Inputs[3] // { // @1668 memory[0x40:0x60] // @1678 memory[0x40:0x60] // @167D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1666 60 PUSH1 0x40 1668 51 MLOAD 1669 63 PUSH4 0x67d9dca1 166E 60 PUSH1 0xe1 1670 1B SHL 1671 81 DUP2 1672 52 MSTORE 1673 60 PUSH1 0x04 1675 01 ADD 1676 60 PUSH1 0x40 1678 51 MLOAD 1679 80 DUP1 167A 91 SWAP2 167B 03 SUB 167C 90 SWAP1 167D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1672 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x67d9dca1 << 0xe1 // @167D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_167E: // Incoming jump from 0x1665, if stack[-1] // Incoming jump from 0x1657, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[8] // { // @1681 stack[-2] // @168D memory[0x00:0x40] // @168F storage[keccak256(memory[0x00:0x40])] // @16A2 stack[-3] // @16AC memory[0x40:0x60] // @16B0 stack[-1] // @16D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @16D9 stack[-4] // } 167E 5B JUMPDEST 167F 60 PUSH1 0x00 1681 82 DUP3 1682 81 DUP2 1683 52 MSTORE 1684 60 PUSH1 0x06 1686 60 PUSH1 0x20 1688 52 MSTORE 1689 60 PUSH1 0x40 168B 80 DUP1 168C 82 DUP3 168D 20 SHA3 168E 80 DUP1 168F 54 SLOAD 1690 60 PUSH1 0x01 1692 60 PUSH1 0x01 1694 60 PUSH1 0xa0 1696 1B SHL 1697 03 SUB 1698 19 NOT 1699 16 AND 169A 60 PUSH1 0x01 169C 60 PUSH1 0x01 169E 60 PUSH1 0xa0 16A0 1B SHL 16A1 03 SUB 16A2 87 DUP8 16A3 81 DUP2 16A4 16 AND 16A5 91 SWAP2 16A6 82 DUP3 16A7 17 OR 16A8 90 SWAP1 16A9 92 SWAP3 16AA 55 SSTORE 16AB 91 SWAP2 16AC 51 MLOAD 16AD 85 DUP6 16AE 93 SWAP4 16AF 91 SWAP2 16B0 85 DUP6 16B1 16 AND 16B2 91 SWAP2 16B3 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 16D4 91 SWAP2 16D5 A4 LOG4 16D6 50 POP 16D7 50 POP 16D8 50 POP 16D9 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1683 memory[0x00:0x20] = stack[-2] // @1688 memory[0x20:0x40] = 0x06 // @16AA storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @16D5 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_16DA: // Incoming call from 0x1215, returns to 0x07B3 // Incoming call from 0x095C, returns to 0x095D // Inputs[2] // { // @16DD stack[-1] // @16E0 storage[0x00] // } 16DA 5B JUMPDEST 16DB 60 PUSH1 0x00 16DD 81 DUP2 16DE 60 PUSH1 0x00 16E0 54 SLOAD 16E1 81 DUP2 16E2 10 LT 16E3 15 ISZERO 16E4 61 PUSH2 0x172f 16E7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @16DB stack[0] = 0x00 // @16DD stack[1] = stack[-1] // } // Block ends with conditional jump to 0x172f, if !(stack[-1] < storage[0x00]) label_16E8: // Incoming jump from 0x16E7, if not !(stack[-1] < storage[0x00]) // Inputs[3] // { // @16EA stack[-1] // @16F5 memory[0x00:0x40] // @16F6 storage[keccak256(memory[0x00:0x40])] // } 16E8 60 PUSH1 0x00 16EA 81 DUP2 16EB 81 DUP2 16EC 52 MSTORE 16ED 60 PUSH1 0x04 16EF 60 PUSH1 0x20 16F1 52 MSTORE 16F2 60 PUSH1 0x40 16F4 81 DUP2 16F5 20 SHA3 16F6 54 SLOAD 16F7 90 SWAP1 16F8 60 PUSH1 0x01 16FA 60 PUSH1 0xe0 16FC 1B SHL 16FD 82 DUP3 16FE 16 AND 16FF 90 SWAP1 1700 03 SUB 1701 61 PUSH2 0x172d 1704 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @16EC memory[0x00:0x20] = stack[-1] // @16F1 memory[0x20:0x40] = 0x04 // @16F7 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x172d, if 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) label_1705: // Incoming jump from 0x1704, if not 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) // Incoming jump from 0x1725 // Inputs[1] { @1706 stack[-1] } 1705 5B JUMPDEST 1706 80 DUP1 1707 60 PUSH1 0x00 1709 03 SUB 170A 61 PUSH2 0x1726 170D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1726, if 0x00 - stack[-1] label_170E: // Incoming jump from 0x170D, if not 0x00 - stack[-1] // Inputs[3] // { // @1712 stack[-2] // @1720 memory[0x00:0x40] // @1721 storage[keccak256(memory[0x00:0x40])] // } 170E 50 POP 170F 60 PUSH1 0x00 1711 19 NOT 1712 01 ADD 1713 60 PUSH1 0x00 1715 81 DUP2 1716 81 DUP2 1717 52 MSTORE 1718 60 PUSH1 0x04 171A 60 PUSH1 0x20 171C 52 MSTORE 171D 60 PUSH1 0x40 171F 90 SWAP1 1720 20 SHA3 1721 54 SLOAD 1722 61 PUSH2 0x1705 1725 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1712 stack[-2] = ~0x00 + stack[-2] // @1717 memory[0x00:0x20] = ~0x00 + stack[-2] // @171C memory[0x20:0x40] = 0x04 // @1721 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x1705 label_1726: // Incoming return from call to 0x1F34 at 0x1F66 // Incoming jump from 0x20F1, if msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0x60) - 0x01 // Incoming return from call to 0x1FC2 at 0x2000 // Incoming jump from 0x170D, if 0x00 - stack[-1] // Incoming return from call to 0x1F67 at 0x1F9D // Incoming jump from 0x1F23 // Incoming return from call to 0x2080 at 0x20AA // Inputs[3] // { // @1727 stack[-5] // @1727 stack[-1] // @1728 stack[-4] // } 1726 5B JUMPDEST 1727 93 SWAP4 1728 92 SWAP3 1729 50 POP 172A 50 POP 172B 50 POP 172C 56 *JUMP // Stack delta = -4 // Outputs[1] { @1727 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_172D: // Incoming jump from 0x1704, if 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) 172D 5B JUMPDEST 172E 50 POP // Stack delta = -1 // Block continues label_172F: // Incoming jump from 0x172E // Incoming jump from 0x16E7, if !(stack[-1] < storage[0x00]) // Inputs[3] // { // @1732 memory[0x40:0x60] // @1742 memory[0x40:0x60] // @1747 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 172F 5B JUMPDEST 1730 60 PUSH1 0x40 1732 51 MLOAD 1733 63 PUSH4 0x6f96cda1 1738 60 PUSH1 0xe1 173A 1B SHL 173B 81 DUP2 173C 52 MSTORE 173D 60 PUSH1 0x04 173F 01 ADD 1740 60 PUSH1 0x40 1742 51 MLOAD 1743 80 DUP1 1744 91 SWAP2 1745 03 SUB 1746 90 SWAP1 1747 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @173C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @1747 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1748: // Incoming call from 0x1960, returns to 0x1961 // Incoming call from 0x0A10, returns to 0x0A11 // Inputs[1] { @1751 stack[-4] } 1748 5B JUMPDEST 1749 60 PUSH1 0x01 174B 60 PUSH1 0x01 174D 60 PUSH1 0xa0 174F 1B SHL 1750 03 SUB 1751 84 DUP5 1752 16 AND 1753 15 ISZERO 1754 61 PUSH2 0x0fca 1757 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fca, if !(stack[-4] & (0x01 << 0xa0) - 0x01) label_1758: // Incoming jump from 0x1757, if not !(stack[-4] & (0x01 << 0xa0) - 0x01) // Inputs[1] { @175D stack[-2] } 1758 60 PUSH1 0x00 175A 61 PUSH2 0x1762 175D 83 DUP4 175E 61 PUSH2 0x0e48 1761 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1758 stack[0] = 0x00 // @175A stack[1] = 0x1762 // @175D stack[2] = stack[-2] // } // Block ends with call to 0x0e48, returns to 0x1762 label_1762: // Incoming return from call to 0x0E48 at 0x1761 // Inputs[2] // { // @176B stack[-1] // @176C stack[-2] // } 1762 5B JUMPDEST 1763 60 PUSH1 0x01 1765 60 PUSH1 0x01 1767 60 PUSH1 0xa0 1769 1B SHL 176A 03 SUB 176B 16 AND 176C 14 EQ 176D 80 DUP1 176E 61 PUSH2 0x1790 1771 57 *JUMPI // Stack delta = -1 // Outputs[1] { @176C stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x1790, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_1772: // Incoming jump from 0x1771, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1776 stack[-3] } 1772 50 POP 1773 61 PUSH2 0x177b 1776 82 DUP3 1777 61 PUSH2 0x0e48 177A 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1773 stack[-1] = 0x177b // @1776 stack[0] = stack[-3] // } // Block ends with call to 0x0e48, returns to 0x177B label_177B: // Incoming return from call to 0x0E48 at 0x177A // Inputs[2] // { // @1784 stack[-1] // @1785 msg.sender // } 177B 5B JUMPDEST 177C 60 PUSH1 0x01 177E 60 PUSH1 0x01 1780 60 PUSH1 0xa0 1782 1B SHL 1783 03 SUB 1784 16 AND 1785 33 CALLER 1786 60 PUSH1 0x01 1788 60 PUSH1 0x01 178A 60 PUSH1 0xa0 178C 1B SHL 178D 03 SUB 178E 16 AND 178F 14 EQ // Stack delta = +0 // Outputs[1] { @178F stack[-1] = (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] } // Block continues label_1790: // Incoming jump from 0x178F // Incoming jump from 0x1771, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1794 stack[-1] } 1790 5B JUMPDEST 1791 61 PUSH2 0x0fca 1794 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0fca, if stack[-1] label_1795: // Incoming jump from 0x1794, if not stack[-1] // Inputs[1] { @1797 memory[0x40:0x60] } 1795 60 PUSH1 0x40 1797 51 MLOAD 1798 62 PUSH3 0x461bcd 179C 60 PUSH1 0xe5 179E 1B SHL 179F 81 DUP2 17A0 52 MSTORE 17A1 60 PUSH1 0x20 17A3 60 PUSH1 0x04 17A5 82 DUP3 17A6 01 ADD 17A7 52 MSTORE 17A8 60 PUSH1 0x06 17AA 60 PUSH1 0x24 17AC 82 DUP3 17AD 01 ADD 17AE 52 MSTORE 17AF 65 PUSH6 0x1313d0d2d151 17B6 60 PUSH1 0xd2 17B8 1B SHL 17B9 60 PUSH1 0x44 17BB 82 DUP3 17BC 01 ADD 17BD 52 MSTORE 17BE 60 PUSH1 0x64 17C0 01 ADD 17C1 61 PUSH2 0x093b 17C4 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @17A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @17A7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @17AE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x06 // @17BD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1313d0d2d151 << 0xd2 // @17C0 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_17C5: // Incoming call from 0x1A42, returns to 0x0BF1 // Incoming call from 0x0AFB, returns to 0x0AFC // Inputs[1] { @17CE stack[-4] } 17C5 5B JUMPDEST 17C6 60 PUSH1 0x01 17C8 60 PUSH1 0x01 17CA 60 PUSH1 0xa0 17CC 1B SHL 17CD 03 SUB 17CE 84 DUP5 17CF 16 AND 17D0 15 ISZERO 17D1 61 PUSH2 0x0fca 17D4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fca, if !(stack[-4] & (0x01 << 0xa0) - 0x01) label_17D5: // Incoming jump from 0x17D4, if not !(stack[-4] & (0x01 << 0xa0) - 0x01) // Inputs[4] // { // @17D8 stack[-2] // @17E3 memory[0x00:0x40] // @17E5 storage[keccak256(memory[0x00:0x40])] // @17F4 stack[-5] // } 17D5 50 POP 17D6 60 PUSH1 0x00 17D8 90 SWAP1 17D9 81 DUP2 17DA 52 MSTORE 17DB 60 PUSH1 0x08 17DD 60 PUSH1 0x20 17DF 52 MSTORE 17E0 60 PUSH1 0x40 17E2 90 SWAP1 17E3 20 SHA3 17E4 80 DUP1 17E5 54 SLOAD 17E6 60 PUSH1 0x01 17E8 60 PUSH1 0x01 17EA 60 PUSH1 0xa0 17EC 1B SHL 17ED 03 SUB 17EE 19 NOT 17EF 16 AND 17F0 90 SWAP1 17F1 55 SSTORE 17F2 50 POP 17F3 50 POP 17F4 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @17DA memory[0x00:0x20] = stack[-2] // @17DF memory[0x20:0x40] = 0x08 // @17F1 storage[keccak256(memory[0x00:0x40])] = ~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-5] label_17F5: // Incoming call from 0x1C24, returns to 0x1C25 // Incoming call from 0x0CC6, returns to 0x0CC7 // Incoming call from 0x1021, returns to 0x1022 // Inputs[1] { @17F8 storage[0x0b] } 17F5 5B JUMPDEST 17F6 60 PUSH1 0x0b 17F8 54 SLOAD 17F9 60 PUSH1 0x01 17FB 60 PUSH1 0xa0 17FD 1B SHL 17FE 90 SWAP1 17FF 04 DIV 1800 60 PUSH1 0xff 1802 16 AND 1803 15 ISZERO 1804 61 PUSH2 0x0ef4 1807 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ef4, if !(0xff & storage[0x0b] / (0x01 << 0xa0)) label_1808: // Incoming jump from 0x1807, if not !(0xff & storage[0x0b] / (0x01 << 0xa0)) // Inputs[1] { @180A memory[0x40:0x60] } 1808 60 PUSH1 0x40 180A 51 MLOAD 180B 62 PUSH3 0x461bcd 180F 60 PUSH1 0xe5 1811 1B SHL 1812 81 DUP2 1813 52 MSTORE 1814 60 PUSH1 0x20 1816 60 PUSH1 0x04 1818 82 DUP3 1819 01 ADD 181A 52 MSTORE 181B 60 PUSH1 0x10 181D 60 PUSH1 0x24 181F 82 DUP3 1820 01 ADD 1821 52 MSTORE 1822 6F PUSH16 0x14185d5cd8589b194e881c185d5cd959 1833 60 PUSH1 0x82 1835 1B SHL 1836 60 PUSH1 0x44 1838 82 DUP3 1839 01 ADD 183A 52 MSTORE 183B 60 PUSH1 0x64 183D 01 ADD 183E 61 PUSH2 0x093b 1841 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1813 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @181A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1821 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @183A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14185d5cd8589b194e881c185d5cd959 << 0x82 // @183D stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_1842: // Incoming call from 0x102C, returns to 0x102D // Incoming call from 0x0D6A, returns to 0x0D6B // Inputs[1] { @1845 stack[-2] } 1842 5B JUMPDEST 1843 60 PUSH1 0x00 1845 82 DUP3 1846 11 GT 1847 61 PUSH2 0x1892 184A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1892, if stack[-2] > 0x00 label_184B: // Incoming jump from 0x184A, if not stack[-2] > 0x00 // Inputs[1] { @184D memory[0x40:0x60] } 184B 60 PUSH1 0x40 184D 51 MLOAD 184E 62 PUSH3 0x461bcd 1852 60 PUSH1 0xe5 1854 1B SHL 1855 81 DUP2 1856 52 MSTORE 1857 60 PUSH1 0x20 1859 60 PUSH1 0x04 185B 82 DUP3 185C 01 ADD 185D 52 MSTORE 185E 60 PUSH1 0x1a 1860 60 PUSH1 0x24 1862 82 DUP3 1863 01 ADD 1864 52 MSTORE 1865 7F PUSH32 0x4d696e7420616d6f756e742063616e6e6f74206265207a65726f000000000000 1886 60 PUSH1 0x44 1888 82 DUP3 1889 01 ADD 188A 52 MSTORE 188B 60 PUSH1 0x64 188D 01 ADD 188E 61 PUSH2 0x093b 1891 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1856 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @185D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1864 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1a // @188A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d696e7420616d6f756e742063616e6e6f74206265207a65726f000000000000 // @188D stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_1892: // Incoming jump from 0x184A, if stack[-2] > 0x00 // Inputs[3] // { // @1896 stack[-2] // @189C storage[0x01] // @189F storage[0x00] // } 1892 5B JUMPDEST 1893 61 PUSH2 0x012c 1896 82 DUP3 1897 61 PUSH2 0x18a3 189A 60 PUSH1 0x01 189C 54 SLOAD 189D 60 PUSH1 0x00 189F 54 SLOAD 18A0 03 SUB 18A1 90 SWAP1 18A2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1893 stack[0] = 0x012c // @1896 stack[1] = stack[-2] // @18A1 stack[2] = storage[0x00] - storage[0x01] // } // Block ends with unconditional jump to 0x18a3 label_18A3: // Incoming jump from 0x18A2 // Inputs[2] // { // @18A7 stack[-2] // @18A8 stack[-1] // } 18A3 5B JUMPDEST 18A4 61 PUSH2 0x18ad 18A7 91 SWAP2 18A8 90 SWAP1 18A9 61 PUSH2 0x252d 18AC 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @18A7 stack[-2] = 0x18ad // @18A8 stack[-1] = stack[-2] // @18A8 stack[0] = stack[-1] // } // Block ends with call to 0x252d, returns to 0x18AD label_18AD: // Incoming return from call to 0x252D at 0x18AC // Inputs[2] // { // @18AE stack[-2] // @18AE stack[-1] // } 18AD 5B JUMPDEST 18AE 11 GT 18AF 15 ISZERO 18B0 61 PUSH2 0x18ec 18B3 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x18ec, if !(stack[-1] > stack[-2]) label_18B4: // Incoming jump from 0x18B3, if not !(stack[-1] > stack[-2]) // Inputs[1] { @18B6 memory[0x40:0x60] } 18B4 60 PUSH1 0x40 18B6 51 MLOAD 18B7 62 PUSH3 0x461bcd 18BB 60 PUSH1 0xe5 18BD 1B SHL 18BE 81 DUP2 18BF 52 MSTORE 18C0 60 PUSH1 0x20 18C2 60 PUSH1 0x04 18C4 82 DUP3 18C5 01 ADD 18C6 52 MSTORE 18C7 60 PUSH1 0x0e 18C9 60 PUSH1 0x24 18CB 82 DUP3 18CC 01 ADD 18CD 52 MSTORE 18CE 6D PUSH14 0x26a0ac29aaa828262c9037bb32b9 18DD 60 PUSH1 0x91 18DF 1B SHL 18E0 60 PUSH1 0x44 18E2 82 DUP3 18E3 01 ADD 18E4 52 MSTORE 18E5 60 PUSH1 0x64 18E7 01 ADD 18E8 61 PUSH2 0x093b 18EB 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @18BF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @18C6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @18CD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @18E4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x26a0ac29aaa828262c9037bb32b9 << 0x91 // @18E7 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_18EC: // Incoming jump from 0x18B3, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @18ED stack[-1] // @18EE msg.value // } 18EC 5B JUMPDEST 18ED 80 DUP1 18EE 34 CALLVALUE 18EF 10 LT 18F0 15 ISZERO 18F1 61 PUSH2 0x094e 18F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x094e, if !(msg.value < stack[-1]) label_18F5: // Incoming jump from 0x18F4, if not !(msg.value < stack[-1]) // Inputs[1] { @18F7 memory[0x40:0x60] } 18F5 60 PUSH1 0x40 18F7 51 MLOAD 18F8 62 PUSH3 0x461bcd 18FC 60 PUSH1 0xe5 18FE 1B SHL 18FF 81 DUP2 1900 52 MSTORE 1901 60 PUSH1 0x20 1903 60 PUSH1 0x04 1905 82 DUP3 1906 01 ADD 1907 52 MSTORE 1908 60 PUSH1 0x10 190A 60 PUSH1 0x24 190C 82 DUP3 190D 01 ADD 190E 52 MSTORE 190F 6F PUSH16 0x4e6f7420656e6f7567682066756e6473 1920 60 PUSH1 0x80 1922 1B SHL 1923 60 PUSH1 0x44 1925 82 DUP3 1926 01 ADD 1927 52 MSTORE 1928 60 PUSH1 0x64 192A 01 ADD 192B 61 PUSH2 0x093b 192E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1900 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1907 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @190E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @1927 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4e6f7420656e6f7567682066756e6473 << 0x80 // @192A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_192F: // Incoming jump from 0x0E00 // Incoming jump from 0x0F32 // Inputs[2] // { // @1933 storage[0x00] // @1935 stack[-1] // } 192F 5B JUMPDEST 1930 60 PUSH1 0x00 1932 80 DUP1 1933 54 SLOAD 1934 90 SWAP1 1935 82 DUP3 1936 90 SWAP1 1937 03 SUB 1938 61 PUSH2 0x1954 193B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1934 stack[0] = storage[0x00] } // Block ends with conditional jump to 0x1954, if 0x00 - stack[-1] label_193C: // Incoming jump from 0x193B, if not 0x00 - stack[-1] // Inputs[3] // { // @193E memory[0x40:0x60] // @194E memory[0x40:0x60] // @1953 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 193C 60 PUSH1 0x40 193E 51 MLOAD 193F 63 PUSH4 0xb562e8dd 1944 60 PUSH1 0xe0 1946 1B SHL 1947 81 DUP2 1948 52 MSTORE 1949 60 PUSH1 0x04 194B 01 ADD 194C 60 PUSH1 0x40 194E 51 MLOAD 194F 80 DUP1 1950 91 SWAP2 1951 03 SUB 1952 90 SWAP1 1953 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1948 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd << 0xe0 // @1953 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1954: // Incoming jump from 0x193B, if 0x00 - stack[-1] // Inputs[3] // { // @195A stack[-3] // @195B stack[-1] // @195C stack[-2] // } 1954 5B JUMPDEST 1955 61 PUSH2 0x1961 1958 60 PUSH1 0x00 195A 84 DUP5 195B 83 DUP4 195C 85 DUP6 195D 61 PUSH2 0x1748 1960 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1955 stack[0] = 0x1961 // @1958 stack[1] = 0x00 // @195A stack[2] = stack[-3] // @195B stack[3] = stack[-1] // @195C stack[4] = stack[-2] // } // Block ends with call to 0x1748, returns to 0x1961 label_1961: // Incoming return from call to 0x1748 at 0x1960 // Inputs[8] // { // @196A stack[-3] // @197C memory[0x00:0x40] // @197E storage[keccak256(memory[0x00:0x40])] // @1989 stack[-2] // @198E stack[-1] // @1997 memory[0x00:0x40] // @199F block.timestamp // @19D3 memory[0x00:0x00] // } 1961 5B JUMPDEST 1962 60 PUSH1 0x01 1964 60 PUSH1 0x01 1966 60 PUSH1 0xa0 1968 1B SHL 1969 03 SUB 196A 83 DUP4 196B 16 AND 196C 60 PUSH1 0x00 196E 81 DUP2 196F 81 DUP2 1970 52 MSTORE 1971 60 PUSH1 0x05 1973 60 PUSH1 0x20 1975 90 SWAP1 1976 81 DUP2 1977 52 MSTORE 1978 60 PUSH1 0x40 197A 80 DUP1 197B 83 DUP4 197C 20 SHA3 197D 80 DUP1 197E 54 SLOAD 197F 68 PUSH9 0x010000000000000001 1989 88 DUP9 198A 02 MUL 198B 01 ADD 198C 90 SWAP1 198D 55 SSTORE 198E 84 DUP5 198F 83 DUP4 1990 52 MSTORE 1991 60 PUSH1 0x04 1993 90 SWAP1 1994 91 SWAP2 1995 52 MSTORE 1996 81 DUP2 1997 20 SHA3 1998 60 PUSH1 0x01 199A 85 DUP6 199B 14 EQ 199C 60 PUSH1 0xe1 199E 1B SHL 199F 42 TIMESTAMP 19A0 60 PUSH1 0xa0 19A2 1B SHL 19A3 17 OR 19A4 83 DUP4 19A5 17 OR 19A6 90 SWAP1 19A7 55 SSTORE 19A8 82 DUP3 19A9 84 DUP5 19AA 01 ADD 19AB 90 SWAP1 19AC 83 DUP4 19AD 90 SWAP1 19AE 83 DUP4 19AF 90 SWAP1 19B0 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 19D1 81 DUP2 19D2 80 DUP1 19D3 A4 LOG4 19D4 60 PUSH1 0x01 19D6 83 DUP4 19D7 01 ADD 19D8 5B JUMPDEST 19D9 81 DUP2 19DA 81 DUP2 19DB 14 EQ 19DC 61 PUSH2 0x1a10 19DF 57 *JUMPI // Stack delta = +3 // Outputs[10] // { // @196B stack[0] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1970 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1977 memory[0x20:0x40] = 0x05 // @198D storage[keccak256(memory[0x00:0x40])] = stack[-2] * 0x010000000000000001 + storage[keccak256(memory[0x00:0x40])] // @1990 memory[0x00:0x20] = stack[-1] // @1995 memory[0x20:0x40] = 0x04 // @19A7 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (block.timestamp << 0xa0) | ((stack[-2] == 0x01) << 0xe1) // @19AB stack[1] = stack[-2] + stack[-1] // @19D3 log(memory[0x00:0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-1]]); // @19D7 stack[2] = stack[-1] + 0x01 // } // Block ends with conditional jump to 0x1a10, if stack[-1] + 0x01 == stack[-2] + stack[-1] label_19E0: // Incoming jump from 0x19DF, if not stack[-1] + 0x01 == stack[-2] + stack[-1] // Incoming jump from 0x19DF, if not stack[-1] == stack[-2] // Inputs[3] // { // @19E0 stack[-1] // @19E1 stack[-3] // @1A08 memory[0x00:0x00] // } 19E0 80 DUP1 19E1 83 DUP4 19E2 60 PUSH1 0x00 19E4 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1A05 60 PUSH1 0x00 1A07 80 DUP1 1A08 A4 LOG4 1A09 60 PUSH1 0x01 1A0B 01 ADD 1A0C 61 PUSH2 0x19d8 1A0F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1A08 log(memory[0x00:0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-3], stack[-1]]); // @1A0B stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x19d8 label_1A10: // Incoming jump from 0x19DF, if stack[-1] + 0x01 == stack[-2] + stack[-1] // Incoming jump from 0x19DF, if stack[-1] == stack[-2] // Inputs[1] { @1A12 stack[-3] } 1A10 5B JUMPDEST 1A11 50 POP 1A12 81 DUP2 1A13 60 PUSH1 0x00 1A15 03 SUB 1A16 61 PUSH2 0x1a31 1A19 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1a31, if 0x00 - stack[-3] label_1A1A: // Incoming jump from 0x1A19, if not 0x00 - stack[-3] // Inputs[3] // { // @1A1C memory[0x40:0x60] // @1A2B memory[0x40:0x60] // @1A30 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1A1A 60 PUSH1 0x40 1A1C 51 MLOAD 1A1D 62 PUSH3 0x2e0763 1A21 60 PUSH1 0xe8 1A23 1B SHL 1A24 81 DUP2 1A25 52 MSTORE 1A26 60 PUSH1 0x04 1A28 01 ADD 1A29 60 PUSH1 0x40 1A2B 51 MLOAD 1A2C 80 DUP1 1A2D 91 SWAP2 1A2E 03 SUB 1A2F 90 SWAP1 1A30 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1A25 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e0763 << 0xe8 // @1A30 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1A31: // Incoming jump from 0x1A19, if 0x00 - stack[-3] // Inputs[5] // { // @1A34 stack[-1] // @1A3A stack[-2] // @1A3C stack[-5] // @1A3D stack[-3] // @1A3E stack[-4] // } 1A31 5B JUMPDEST 1A32 60 PUSH1 0x00 1A34 90 SWAP1 1A35 81 DUP2 1A36 55 SSTORE 1A37 61 PUSH2 0x0bf1 1A3A 91 SWAP2 1A3B 50 POP 1A3C 84 DUP5 1A3D 83 DUP4 1A3E 85 DUP6 1A3F 61 PUSH2 0x17c5 1A42 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @1A34 stack[-1] = 0x00 // @1A36 storage[0x00] = stack[-1] // @1A3A stack[-2] = 0x0bf1 // @1A3C stack[0] = stack[-5] // @1A3D stack[1] = stack[-3] // @1A3E stack[2] = stack[-4] // } // Block ends with call to 0x17c5, returns to 0x0BF1 label_1A43: // Incoming jump from 0x0EF3 // Inputs[3] // { // @1A44 stack[-1] // @1A45 address(this) // @1A45 address(this).balance // } 1A43 5B JUMPDEST 1A44 80 DUP1 1A45 47 SELFBALANCE 1A46 10 LT 1A47 15 ISZERO 1A48 61 PUSH2 0x1a93 1A4B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1a93, if !(address(this).balance < stack[-1]) label_1A4C: // Incoming jump from 0x1A4B, if not !(address(this).balance < stack[-1]) // Inputs[1] { @1A4E memory[0x40:0x60] } 1A4C 60 PUSH1 0x40 1A4E 51 MLOAD 1A4F 62 PUSH3 0x461bcd 1A53 60 PUSH1 0xe5 1A55 1B SHL 1A56 81 DUP2 1A57 52 MSTORE 1A58 60 PUSH1 0x20 1A5A 60 PUSH1 0x04 1A5C 82 DUP3 1A5D 01 ADD 1A5E 52 MSTORE 1A5F 60 PUSH1 0x1d 1A61 60 PUSH1 0x24 1A63 82 DUP3 1A64 01 ADD 1A65 52 MSTORE 1A66 7F PUSH32 0x416464726573733a20696e73756666696369656e742062616c616e6365000000 1A87 60 PUSH1 0x44 1A89 82 DUP3 1A8A 01 ADD 1A8B 52 MSTORE 1A8C 60 PUSH1 0x64 1A8E 01 ADD 1A8F 61 PUSH2 0x093b 1A92 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1A57 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1A5E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1A65 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1d // @1A8B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416464726573733a20696e73756666696369656e742062616c616e6365000000 // @1A8E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_1A93: // Incoming jump from 0x1A4B, if !(address(this).balance < stack[-1]) // Inputs[8] // { // @1A96 stack[-2] // @1AA0 stack[-1] // @1AA3 memory[0x40:0x60] // @1AA8 memory[0x40:0x60] // @1AAF msg.gas // @1AB0 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1AB0 address((0x01 << 0xa0) - 0x01 & stack[-2]).call.gas(msg.gas).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @1AB5 returndata.length // } 1A93 5B JUMPDEST 1A94 60 PUSH1 0x00 1A96 82 DUP3 1A97 60 PUSH1 0x01 1A99 60 PUSH1 0x01 1A9B 60 PUSH1 0xa0 1A9D 1B SHL 1A9E 03 SUB 1A9F 16 AND 1AA0 82 DUP3 1AA1 60 PUSH1 0x40 1AA3 51 MLOAD 1AA4 60 PUSH1 0x00 1AA6 60 PUSH1 0x40 1AA8 51 MLOAD 1AA9 80 DUP1 1AAA 83 DUP4 1AAB 03 SUB 1AAC 81 DUP2 1AAD 85 DUP6 1AAE 87 DUP8 1AAF 5A GAS 1AB0 F1 CALL 1AB1 92 SWAP3 1AB2 50 POP 1AB3 50 POP 1AB4 50 POP 1AB5 3D RETURNDATASIZE 1AB6 80 DUP1 1AB7 60 PUSH1 0x00 1AB9 81 DUP2 1ABA 14 EQ 1ABB 61 PUSH2 0x1ae0 1ABE 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @1A94 stack[0] = 0x00 // @1AB0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address((0x01 << 0xa0) - 0x01 & stack[-2]).call.gas(msg.gas).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @1AB1 stack[1] = address((0x01 << 0xa0) - 0x01 & stack[-2]).call.gas(msg.gas).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @1AB5 stack[2] = returndata.length // @1AB6 stack[3] = returndata.length // } // Block ends with conditional jump to 0x1ae0, if returndata.length == 0x00 label_1ABF: // Incoming jump from 0x1ABE, if not returndata.length == 0x00 // Inputs[6] // { // @1AC1 memory[0x40:0x60] // @1AC2 stack[-2] // @1AC9 returndata.length // @1AD1 returndata.length // @1AD4 returndata.length // @1ADB returndata[0x00:0x00 + returndata.length] // } 1ABF 60 PUSH1 0x40 1AC1 51 MLOAD 1AC2 91 SWAP2 1AC3 50 POP 1AC4 60 PUSH1 0x1f 1AC6 19 NOT 1AC7 60 PUSH1 0x3f 1AC9 3D RETURNDATASIZE 1ACA 01 ADD 1ACB 16 AND 1ACC 82 DUP3 1ACD 01 ADD 1ACE 60 PUSH1 0x40 1AD0 52 MSTORE 1AD1 3D RETURNDATASIZE 1AD2 82 DUP3 1AD3 52 MSTORE 1AD4 3D RETURNDATASIZE 1AD5 60 PUSH1 0x00 1AD7 60 PUSH1 0x20 1AD9 84 DUP5 1ADA 01 ADD 1ADB 3E RETURNDATACOPY 1ADC 61 PUSH2 0x1ae5 1ADF 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1AC2 stack[-2] = memory[0x40:0x60] // @1AD0 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1AD3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1ADB memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1ae5 label_1AE0: // Incoming jump from 0x1ABE, if returndata.length == 0x00 // Inputs[3] // { // @1AE3 stack[-2] // @1AE8 stack[-4] // @1AE8 stack[-3] // } 1AE0 5B JUMPDEST 1AE1 60 PUSH1 0x60 1AE3 91 SWAP2 1AE4 50 POP 1AE5 5B JUMPDEST 1AE6 50 POP 1AE7 50 POP 1AE8 90 SWAP1 1AE9 50 POP 1AEA 80 DUP1 1AEB 61 PUSH2 0x0bf1 1AEE 57 *JUMPI // Stack delta = -3 // Outputs[1] { @1AE8 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x0bf1, if stack[-3] label_1AEF: // Incoming jump from 0x1AEE, if not stack[-3] // Incoming jump from 0x1AEE, if not stack[-3] // Inputs[1] { @1AF1 memory[0x40:0x60] } 1AEF 60 PUSH1 0x40 1AF1 51 MLOAD 1AF2 62 PUSH3 0x461bcd 1AF6 60 PUSH1 0xe5 1AF8 1B SHL 1AF9 81 DUP2 1AFA 52 MSTORE 1AFB 60 PUSH1 0x20 1AFD 60 PUSH1 0x04 1AFF 82 DUP3 1B00 01 ADD 1B01 52 MSTORE 1B02 60 PUSH1 0x3a 1B04 60 PUSH1 0x24 1B06 82 DUP3 1B07 01 ADD 1B08 52 MSTORE 1B09 7F PUSH32 0x416464726573733a20756e61626c6520746f2073656e642076616c75652c2072 1B2A 60 PUSH1 0x44 1B2C 82 DUP3 1B2D 01 ADD 1B2E 52 MSTORE 1B2F 7F PUSH32 0x6563697069656e74206d61792068617665207265766572746564000000000000 1B50 60 PUSH1 0x64 1B52 82 DUP3 1B53 01 ADD 1B54 52 MSTORE 1B55 60 PUSH1 0x84 1B57 01 ADD 1B58 61 PUSH2 0x093b 1B5B 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1AFA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B01 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1B08 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x3a // @1B2E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416464726573733a20756e61626c6520746f2073656e642076616c75652c2072 // @1B54 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6563697069656e74206d61792068617665207265766572746564000000000000 // @1B57 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_1B5C: // Incoming call from 0x0F05, returns to 0x0EF4 1B5C 5B JUMPDEST 1B5D 61 PUSH2 0x1b64 1B60 61 PUSH2 0x1e19 1B63 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B5D stack[0] = 0x1b64 } // Block ends with call to 0x1e19, returns to 0x1B64 label_1B64: // Incoming return from call to 0x1E19 at 0x1B63 // Inputs[6] // { // @1B68 storage[0x0b] // @1B93 msg.sender // @1B97 memory[0x40:0x60] // @1BAA memory[0x40:0x60] // @1BAF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1BB0 stack[-1] // } 1B64 5B JUMPDEST 1B65 60 PUSH1 0x0b 1B67 80 DUP1 1B68 54 SLOAD 1B69 60 PUSH1 0xff 1B6B 60 PUSH1 0xa0 1B6D 1B SHL 1B6E 19 NOT 1B6F 16 AND 1B70 90 SWAP1 1B71 55 SSTORE 1B72 7F PUSH32 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa 1B93 33 CALLER 1B94 5B JUMPDEST 1B95 60 PUSH1 0x40 1B97 51 MLOAD 1B98 60 PUSH1 0x01 1B9A 60 PUSH1 0x01 1B9C 60 PUSH1 0xa0 1B9E 1B SHL 1B9F 03 SUB 1BA0 90 SWAP1 1BA1 91 SWAP2 1BA2 16 AND 1BA3 81 DUP2 1BA4 52 MSTORE 1BA5 60 PUSH1 0x20 1BA7 01 ADD 1BA8 60 PUSH1 0x40 1BAA 51 MLOAD 1BAB 80 DUP1 1BAC 91 SWAP2 1BAD 03 SUB 1BAE 90 SWAP1 1BAF A1 LOG1 1BB0 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1B71 storage[0x0b] = ~(0xff << 0xa0) & storage[0x0b] // @1BA4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.sender & (0x01 << 0xa0) - 0x01 // @1BAF log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa]); // } // Block ends with unconditional jump to stack[-1] label_1BB1: // Incoming jump from 0x10BE // Inputs[4] // { // @1BB4 stack[-2] // @1BB8 stack[-4] // @1BB9 stack[-3] // @1BBA stack[-1] // } 1BB1 5B JUMPDEST 1BB2 60 PUSH1 0x00 1BB4 82 DUP3 1BB5 61 PUSH2 0x1bbf 1BB8 86 DUP7 1BB9 86 DUP7 1BBA 85 DUP6 1BBB 61 PUSH2 0x1e69 1BBE 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1BB2 stack[0] = 0x00 // @1BB4 stack[1] = stack[-2] // @1BB5 stack[2] = 0x1bbf // @1BB8 stack[3] = stack[-4] // @1BB9 stack[4] = stack[-3] // @1BBA stack[5] = stack[-1] // } // Block ends with call to 0x1e69, returns to 0x1BBF label_1BBF: // Incoming return from call to 0x1E69 at 0x1BBE // Inputs[3] // { // @1BC0 stack[-2] // @1BC0 stack[-1] // @1BC1 stack[-3] // } 1BBF 5B JUMPDEST 1BC0 14 EQ 1BC1 90 SWAP1 1BC2 50 POP // Stack delta = -2 // Outputs[1] { @1BC1 stack[-3] = stack[-1] == stack[-2] } // Block continues label_1BC3: // Incoming jump from 0x1BC2 // Incoming return from call to 0x210C at 0x21CA // Inputs[3] // { // @1BC4 stack[-1] // @1BC4 stack[-6] // @1BC5 stack[-5] // } 1BC3 5B JUMPDEST 1BC4 94 SWAP5 1BC5 93 SWAP4 1BC6 50 POP 1BC7 50 POP 1BC8 50 POP 1BC9 50 POP 1BCA 56 *JUMP // Stack delta = -5 // Outputs[1] { @1BC4 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1BCB: // Incoming call from 0x1461, returns to 0x0805 // Incoming call from 0x1276, returns to 0x0EF4 // Inputs[5] // { // @1BCF storage[0x0b] // @1BD8 stack[-1] // @1BED memory[0x40:0x60] // @1C19 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1C1C stack[-2] // } 1BCB 5B JUMPDEST 1BCC 60 PUSH1 0x0b 1BCE 80 DUP1 1BCF 54 SLOAD 1BD0 60 PUSH1 0x01 1BD2 60 PUSH1 0x01 1BD4 60 PUSH1 0xa0 1BD6 1B SHL 1BD7 03 SUB 1BD8 83 DUP4 1BD9 81 DUP2 1BDA 16 AND 1BDB 60 PUSH1 0x01 1BDD 60 PUSH1 0x01 1BDF 60 PUSH1 0xa0 1BE1 1B SHL 1BE2 03 SUB 1BE3 19 NOT 1BE4 83 DUP4 1BE5 16 AND 1BE6 81 DUP2 1BE7 17 OR 1BE8 90 SWAP1 1BE9 93 SWAP4 1BEA 55 SSTORE 1BEB 60 PUSH1 0x40 1BED 51 MLOAD 1BEE 91 SWAP2 1BEF 16 AND 1BF0 91 SWAP2 1BF1 90 SWAP1 1BF2 82 DUP3 1BF3 90 SWAP1 1BF4 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1C15 90 SWAP1 1C16 60 PUSH1 0x00 1C18 90 SWAP1 1C19 A3 LOG3 1C1A 50 POP 1C1B 50 POP 1C1C 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1BEA storage[0x0b] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x0b] & ~((0x01 << 0xa0) - 0x01)) // @1C19 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0b] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_1C1D: // Incoming call from 0x1293, returns to 0x0EF4 1C1D 5B JUMPDEST 1C1E 61 PUSH2 0x1c25 1C21 61 PUSH2 0x17f5 1C24 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C1E stack[0] = 0x1c25 } // Block ends with call to 0x17f5, returns to 0x1C25 label_1C25: // Incoming return from call to 0x17F5 at 0x1C24 // Inputs[2] // { // @1C29 storage[0x0b] // @1C5D msg.sender // } 1C25 5B JUMPDEST 1C26 60 PUSH1 0x0b 1C28 80 DUP1 1C29 54 SLOAD 1C2A 60 PUSH1 0xff 1C2C 60 PUSH1 0xa0 1C2E 1B SHL 1C2F 19 NOT 1C30 16 AND 1C31 60 PUSH1 0x01 1C33 60 PUSH1 0xa0 1C35 1B SHL 1C36 17 OR 1C37 90 SWAP1 1C38 55 SSTORE 1C39 7F PUSH32 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 1C5A 61 PUSH2 0x1b94 1C5D 33 CALLER 1C5E 90 SWAP1 1C5F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1C38 storage[0x0b] = (0x01 << 0xa0) | (~(0xff << 0xa0) & storage[0x0b]) // @1C39 stack[0] = 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 // @1C5E stack[1] = msg.sender // } // Block ends with unconditional jump to 0x1b94 1C60 5B JUMPDEST 1C61 60 PUSH1 0x40 1C63 51 MLOAD 1C64 63 PUSH4 0x0a85bd01 1C69 60 PUSH1 0xe1 1C6B 1B SHL 1C6C 81 DUP2 1C6D 52 MSTORE 1C6E 60 PUSH1 0x00 1C70 90 SWAP1 1C71 60 PUSH1 0x01 1C73 60 PUSH1 0x01 1C75 60 PUSH1 0xa0 1C77 1B SHL 1C78 03 SUB 1C79 85 DUP6 1C7A 16 AND 1C7B 90 SWAP1 1C7C 63 PUSH4 0x150b7a02 1C81 90 SWAP1 1C82 61 PUSH2 0x1c95 1C85 90 SWAP1 1C86 33 CALLER 1C87 90 SWAP1 1C88 89 DUP10 1C89 90 SWAP1 1C8A 88 DUP9 1C8B 90 SWAP1 1C8C 88 DUP9 1C8D 90 SWAP1 1C8E 60 PUSH1 0x04 1C90 01 ADD 1C91 61 PUSH2 0x256f 1C94 56 *JUMP 1C95 5B JUMPDEST 1C96 60 PUSH1 0x20 1C98 60 PUSH1 0x40 1C9A 51 MLOAD 1C9B 80 DUP1 1C9C 83 DUP4 1C9D 03 SUB 1C9E 81 DUP2 1C9F 60 PUSH1 0x00 1CA1 87 DUP8 1CA2 5A GAS 1CA3 F1 CALL 1CA4 92 SWAP3 1CA5 50 POP 1CA6 50 POP 1CA7 50 POP 1CA8 80 DUP1 1CA9 15 ISZERO 1CAA 61 PUSH2 0x1cd0 1CAD 57 *JUMPI 1CAE 50 POP 1CAF 60 PUSH1 0x40 1CB1 80 DUP1 1CB2 51 MLOAD 1CB3 60 PUSH1 0x1f 1CB5 3D RETURNDATASIZE 1CB6 90 SWAP1 1CB7 81 DUP2 1CB8 01 ADD 1CB9 60 PUSH1 0x1f 1CBB 19 NOT 1CBC 16 AND 1CBD 82 DUP3 1CBE 01 ADD 1CBF 90 SWAP1 1CC0 92 SWAP3 1CC1 52 MSTORE 1CC2 61 PUSH2 0x1ccd 1CC5 91 SWAP2 1CC6 81 DUP2 1CC7 01 ADD 1CC8 90 SWAP1 1CC9 61 PUSH2 0x25ac 1CCC 56 *JUMP 1CCD 5B JUMPDEST 1CCE 60 PUSH1 0x01 1CD0 5B JUMPDEST 1CD1 61 PUSH2 0x1d2e 1CD4 57 *JUMPI 1CD5 3D RETURNDATASIZE 1CD6 80 DUP1 1CD7 80 DUP1 1CD8 15 ISZERO 1CD9 61 PUSH2 0x1cfe 1CDC 57 *JUMPI 1CDD 60 PUSH1 0x40 1CDF 51 MLOAD 1CE0 91 SWAP2 1CE1 50 POP 1CE2 60 PUSH1 0x1f 1CE4 19 NOT 1CE5 60 PUSH1 0x3f 1CE7 3D RETURNDATASIZE 1CE8 01 ADD 1CE9 16 AND 1CEA 82 DUP3 1CEB 01 ADD 1CEC 60 PUSH1 0x40 1CEE 52 MSTORE 1CEF 3D RETURNDATASIZE 1CF0 82 DUP3 1CF1 52 MSTORE 1CF2 3D RETURNDATASIZE 1CF3 60 PUSH1 0x00 1CF5 60 PUSH1 0x20 1CF7 84 DUP5 1CF8 01 ADD 1CF9 3E RETURNDATACOPY 1CFA 61 PUSH2 0x1d03 1CFD 56 *JUMP 1CFE 5B JUMPDEST 1CFF 60 PUSH1 0x60 1D01 91 SWAP2 1D02 50 POP 1D03 5B JUMPDEST 1D04 50 POP 1D05 80 DUP1 1D06 51 MLOAD 1D07 60 PUSH1 0x00 1D09 03 SUB 1D0A 61 PUSH2 0x1d26 1D0D 57 *JUMPI 1D0E 60 PUSH1 0x40 1D10 51 MLOAD 1D11 63 PUSH4 0x68d2bf6b 1D16 60 PUSH1 0xe1 1D18 1B SHL 1D19 81 DUP2 1D1A 52 MSTORE 1D1B 60 PUSH1 0x04 1D1D 01 ADD 1D1E 60 PUSH1 0x40 1D20 51 MLOAD 1D21 80 DUP1 1D22 91 SWAP2 1D23 03 SUB 1D24 90 SWAP1 1D25 FD *REVERT 1D26 5B JUMPDEST 1D27 80 DUP1 1D28 51 MLOAD 1D29 81 DUP2 1D2A 60 PUSH1 0x20 1D2C 01 ADD 1D2D FD *REVERT 1D2E 5B JUMPDEST 1D2F 60 PUSH1 0x01 1D31 60 PUSH1 0x01 1D33 60 PUSH1 0xe0 1D35 1B SHL 1D36 03 SUB 1D37 19 NOT 1D38 16 AND 1D39 63 PUSH4 0x0a85bd01 1D3E 60 PUSH1 0xe1 1D40 1B SHL 1D41 14 EQ 1D42 90 SWAP1 1D43 50 POP 1D44 61 PUSH2 0x1bc3 1D47 56 *JUMP label_1D48: // Incoming jump from 0x1378 // Inputs[1] { @1D4E stack[-1] } 1D48 5B JUMPDEST 1D49 60 PUSH1 0x60 1D4B 61 PUSH2 0x1d53 1D4E 82 DUP3 1D4F 61 PUSH2 0x1613 1D52 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D49 stack[0] = 0x60 // @1D4B stack[1] = 0x1d53 // @1D4E stack[2] = stack[-1] // } // Block ends with call to 0x1613, returns to 0x1D53 label_1D53: // Incoming return from call to 0x1613 at 0x1D52 // Inputs[1] { @1D57 stack[-1] } 1D53 5B JUMPDEST 1D54 61 PUSH2 0x1d70 1D57 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1d70, if stack[-1] label_1D58: // Incoming jump from 0x1D57, if not stack[-1] // Inputs[3] // { // @1D5A memory[0x40:0x60] // @1D6A memory[0x40:0x60] // @1D6F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1D58 60 PUSH1 0x40 1D5A 51 MLOAD 1D5B 63 PUSH4 0x0a14c4b5 1D60 60 PUSH1 0xe4 1D62 1B SHL 1D63 81 DUP2 1D64 52 MSTORE 1D65 60 PUSH1 0x04 1D67 01 ADD 1D68 60 PUSH1 0x40 1D6A 51 MLOAD 1D6B 80 DUP1 1D6C 91 SWAP2 1D6D 03 SUB 1D6E 90 SWAP1 1D6F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1D64 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a14c4b5 << 0xe4 // @1D6F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1D70: // Incoming jump from 0x1D57, if stack[-1] 1D70 5B JUMPDEST 1D71 60 PUSH1 0x00 1D73 61 PUSH2 0x1d7a 1D76 61 PUSH2 0x1eb5 1D79 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D71 stack[0] = 0x00 // @1D73 stack[1] = 0x1d7a // } // Block ends with unconditional jump to 0x1eb5 1D7A 5B JUMPDEST 1D7B 90 SWAP1 1D7C 50 POP 1D7D 80 DUP1 1D7E 51 MLOAD 1D7F 60 PUSH1 0x00 1D81 03 SUB 1D82 61 PUSH2 0x1d9a 1D85 57 *JUMPI 1D86 60 PUSH1 0x40 1D88 51 MLOAD 1D89 80 DUP1 1D8A 60 PUSH1 0x20 1D8C 01 ADD 1D8D 60 PUSH1 0x40 1D8F 52 MSTORE 1D90 80 DUP1 1D91 60 PUSH1 0x00 1D93 81 DUP2 1D94 52 MSTORE 1D95 50 POP 1D96 61 PUSH2 0x1726 1D99 56 *JUMP 1D9A 5B JUMPDEST 1D9B 80 DUP1 1D9C 61 PUSH2 0x1da4 1D9F 84 DUP5 1DA0 61 PUSH2 0x1ec4 1DA3 56 *JUMP 1DA4 5B JUMPDEST 1DA5 60 PUSH1 0x40 1DA7 51 MLOAD 1DA8 60 PUSH1 0x20 1DAA 01 ADD 1DAB 61 PUSH2 0x1db5 1DAE 92 SWAP3 1DAF 91 SWAP2 1DB0 90 SWAP1 1DB1 61 PUSH2 0x2540 1DB4 56 *JUMP 1DB5 5B JUMPDEST 1DB6 60 PUSH1 0x40 1DB8 51 MLOAD 1DB9 60 PUSH1 0x20 1DBB 81 DUP2 1DBC 83 DUP4 1DBD 03 SUB 1DBE 03 SUB 1DBF 81 DUP2 1DC0 52 MSTORE 1DC1 90 SWAP1 1DC2 60 PUSH1 0x40 1DC4 52 MSTORE 1DC5 93 SWAP4 1DC6 92 SWAP3 1DC7 50 POP 1DC8 50 POP 1DC9 50 POP 1DCA 56 *JUMP label_1DCB: // Incoming call from 0x1486, returns to 0x07B3 // Inputs[1] { @1DDF stack[-1] } 1DCB 5B JUMPDEST 1DCC 60 PUSH1 0x00 1DCE 63 PUSH4 0x01ffc9a7 1DD3 60 PUSH1 0xe0 1DD5 1B SHL 1DD6 60 PUSH1 0x01 1DD8 60 PUSH1 0x01 1DDA 60 PUSH1 0xe0 1DDC 1B SHL 1DDD 03 SUB 1DDE 19 NOT 1DDF 83 DUP4 1DE0 16 AND 1DE1 14 EQ 1DE2 80 DUP1 1DE3 61 PUSH2 0x1dfc 1DE6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DCC stack[0] = 0x00 // @1DE1 stack[1] = stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // } // Block ends with conditional jump to 0x1dfc, if stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 label_1DE7: // Incoming jump from 0x1DE6, if not stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // Inputs[1] { @1DF9 stack[-3] } 1DE7 50 POP 1DE8 63 PUSH4 0x80ac58cd 1DED 60 PUSH1 0xe0 1DEF 1B SHL 1DF0 60 PUSH1 0x01 1DF2 60 PUSH1 0x01 1DF4 60 PUSH1 0xe0 1DF6 1B SHL 1DF7 03 SUB 1DF8 19 NOT 1DF9 83 DUP4 1DFA 16 AND 1DFB 14 EQ 1DFC 5B JUMPDEST 1DFD 80 DUP1 1DFE 61 PUSH2 0x07b3 1E01 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1DFB stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 } // Block ends with conditional jump to 0x07b3, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 label_1E02: // Incoming jump from 0x1E01, if not stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Incoming jump from 0x1E01, if not stack[-1] // Inputs[2] // { // @1E0D stack[-3] // @1E17 stack[-4] // } 1E02 50 POP 1E03 50 POP 1E04 60 PUSH1 0x01 1E06 60 PUSH1 0x01 1E08 60 PUSH1 0xe0 1E0A 1B SHL 1E0B 03 SUB 1E0C 19 NOT 1E0D 16 AND 1E0E 63 PUSH4 0x5b5e139f 1E13 60 PUSH1 0xe0 1E15 1B SHL 1E16 14 EQ 1E17 90 SWAP1 1E18 56 *JUMP // Stack delta = -3 // Outputs[1] { @1E17 stack[-4] = 0x5b5e139f << 0xe0 == ~((0x01 << 0xe0) - 0x01) & stack[-3] } // Block ends with unconditional jump to stack[-4] label_1E19: // Incoming call from 0x1B63, returns to 0x1B64 // Inputs[1] { @1E1C storage[0x0b] } 1E19 5B JUMPDEST 1E1A 60 PUSH1 0x0b 1E1C 54 SLOAD 1E1D 60 PUSH1 0x01 1E1F 60 PUSH1 0xa0 1E21 1B SHL 1E22 90 SWAP1 1E23 04 DIV 1E24 60 PUSH1 0xff 1E26 16 AND 1E27 61 PUSH2 0x0ef4 1E2A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ef4, if 0xff & storage[0x0b] / (0x01 << 0xa0) label_1E2B: // Incoming jump from 0x1E2A, if not 0xff & storage[0x0b] / (0x01 << 0xa0) // Inputs[1] { @1E2D memory[0x40:0x60] } 1E2B 60 PUSH1 0x40 1E2D 51 MLOAD 1E2E 62 PUSH3 0x461bcd 1E32 60 PUSH1 0xe5 1E34 1B SHL 1E35 81 DUP2 1E36 52 MSTORE 1E37 60 PUSH1 0x20 1E39 60 PUSH1 0x04 1E3B 82 DUP3 1E3C 01 ADD 1E3D 52 MSTORE 1E3E 60 PUSH1 0x14 1E40 60 PUSH1 0x24 1E42 82 DUP3 1E43 01 ADD 1E44 52 MSTORE 1E45 73 PUSH20 0x14185d5cd8589b194e881b9bdd081c185d5cd959 1E5A 60 PUSH1 0x62 1E5C 1B SHL 1E5D 60 PUSH1 0x44 1E5F 82 DUP3 1E60 01 ADD 1E61 52 MSTORE 1E62 60 PUSH1 0x64 1E64 01 ADD 1E65 61 PUSH2 0x093b 1E68 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1E36 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1E3D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1E44 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @1E61 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14185d5cd8589b194e881b9bdd081c185d5cd959 << 0x62 // @1E64 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x093b label_1E69: // Incoming call from 0x1BBE, returns to 0x1BBF // Inputs[2] // { // @1E6C stack[-1] // @1E6F stack[-2] // } 1E69 5B JUMPDEST 1E6A 60 PUSH1 0x00 1E6C 81 DUP2 1E6D 81 DUP2 1E6E 5B JUMPDEST 1E6F 84 DUP5 1E70 81 DUP2 1E71 10 LT 1E72 15 ISZERO 1E73 61 PUSH2 0x1eac 1E76 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1E6A stack[0] = 0x00 // @1E6C stack[1] = stack[-1] // @1E6D stack[2] = 0x00 // } // Block ends with conditional jump to 0x1eac, if !(0x00 < stack[-2]) label_1E77: // Incoming jump from 0x1E76, if not !(stack[-1] < stack[-5]) // Incoming jump from 0x1E76, if not !(0x00 < stack[-2]) // Inputs[4] // { // @1E7A stack[-2] // @1E7B stack[-6] // @1E7C stack[-5] // @1E7D stack[-1] // } 1E77 61 PUSH2 0x1e98 1E7A 82 DUP3 1E7B 87 DUP8 1E7C 87 DUP8 1E7D 84 DUP5 1E7E 81 DUP2 1E7F 81 DUP2 1E80 10 LT 1E81 61 PUSH2 0x1e8c 1E84 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1E77 stack[0] = 0x1e98 // @1E7A stack[1] = stack[-2] // @1E7B stack[2] = stack[-6] // @1E7C stack[3] = stack[-5] // @1E7D stack[4] = stack[-1] // } // Block ends with conditional call to 0x1e8c, returns to 0x1E98, if stack[-1] < stack[-5] label_1E85: // Incoming jump from 0x1E84, if not stack[-1] < stack[-5] 1E85 61 PUSH2 0x1e8c 1E88 61 PUSH2 0x24fe 1E8B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E85 stack[0] = 0x1e8c } // Block ends with unconditional jump to 0x24fe label_1E8C: // Incoming call from 0x1E84, returns to 0x1E98, if stack[-1] < stack[-5] // Inputs[4] // { // @1E8D stack[-1] // @1E8D stack[-2] // @1E92 stack[-3] // @1E93 msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // } 1E8C 5B JUMPDEST 1E8D 90 SWAP1 1E8E 50 POP 1E8F 60 PUSH1 0x20 1E91 02 MUL 1E92 01 ADD 1E93 35 CALLDATALOAD 1E94 61 PUSH2 0x1f08 1E97 56 *JUMP // Stack delta = -2 // Outputs[1] { @1E93 stack[-3] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] } // Block ends with unconditional jump to 0x1f08 label_1E98: // Incoming return from call to 0x1E8C at 0x1E84 // Inputs[3] // { // @1E99 stack[-1] // @1E99 stack[-3] // @1E9B stack[-2] // } 1E98 5B JUMPDEST 1E99 91 SWAP2 1E9A 50 POP 1E9B 80 DUP1 1E9C 61 PUSH2 0x1ea4 1E9F 81 DUP2 1EA0 61 PUSH2 0x2514 1EA3 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1E99 stack[-3] = stack[-1] // @1E9B stack[-1] = stack[-2] // @1E9C stack[0] = 0x1ea4 // @1E9F stack[1] = stack[-2] // } // Block ends with call to 0x2514, returns to 0x1EA4 label_1EA4: // Incoming return from call to 0x2514 at 0x1EA3 // Inputs[2] // { // @1EA5 stack[-1] // @1EA5 stack[-3] // } 1EA4 5B JUMPDEST 1EA5 91 SWAP2 1EA6 50 POP 1EA7 50 POP 1EA8 61 PUSH2 0x1e6e 1EAB 56 *JUMP // Stack delta = -2 // Outputs[1] { @1EA5 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1e6e label_1EAC: // Incoming jump from 0x1E76, if !(stack[-1] < stack[-5]) // Incoming jump from 0x1E76, if !(0x00 < stack[-2]) // Inputs[3] // { // @1EAE stack[-7] // @1EAE stack[-2] // @1EAF stack[-6] // } 1EAC 5B JUMPDEST 1EAD 50 POP 1EAE 94 SWAP5 1EAF 93 SWAP4 1EB0 50 POP 1EB1 50 POP 1EB2 50 POP 1EB3 50 POP 1EB4 56 *JUMP // Stack delta = -6 // Outputs[1] { @1EAE stack[-7] = stack[-2] } // Block ends with unconditional jump to stack[-7] label_1EB5: // Incoming jump from 0x1D79 // Inputs[1] { @1EBB storage[0x0c] } 1EB5 5B JUMPDEST 1EB6 60 PUSH1 0x60 1EB8 60 PUSH1 0x0c 1EBA 80 DUP1 1EBB 54 SLOAD 1EBC 61 PUSH2 0x0817 1EBF 90 SWAP1 1EC0 61 PUSH2 0x236f 1EC3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1EB6 stack[0] = 0x60 // @1EB8 stack[1] = 0x0c // @1EBF stack[2] = 0x0817 // @1EBF stack[3] = storage[0x0c] // } // Block ends with call to 0x236f, returns to 0x0817 1EC4 5B JUMPDEST 1EC5 60 PUSH1 0x60 1EC7 60 PUSH1 0xa0 1EC9 60 PUSH1 0x40 1ECB 51 MLOAD 1ECC 01 ADD 1ECD 80 DUP1 1ECE 60 PUSH1 0x40 1ED0 52 MSTORE 1ED1 60 PUSH1 0x20 1ED3 81 DUP2 1ED4 03 SUB 1ED5 91 SWAP2 1ED6 50 POP 1ED7 50 POP 1ED8 60 PUSH1 0x00 1EDA 81 DUP2 1EDB 52 MSTORE 1EDC 80 DUP1 1EDD 82 DUP3 1EDE 5B JUMPDEST 1EDF 60 PUSH1 0x01 1EE1 83 DUP4 1EE2 03 SUB 1EE3 92 SWAP3 1EE4 50 POP 1EE5 60 PUSH1 0x0a 1EE7 81 DUP2 1EE8 06 MOD 1EE9 60 PUSH1 0x30 1EEB 01 ADD 1EEC 83 DUP4 1EED 53 MSTORE8 1EEE 60 PUSH1 0x0a 1EF0 90 SWAP1 1EF1 04 DIV 1EF2 80 DUP1 1EF3 61 PUSH2 0x1ede 1EF6 57 *JUMPI 1EF7 50 POP 1EF8 81 DUP2 1EF9 90 SWAP1 1EFA 03 SUB 1EFB 60 PUSH1 0x1f 1EFD 19 NOT 1EFE 90 SWAP1 1EFF 91 SWAP2 1F00 01 ADD 1F01 90 SWAP1 1F02 81 DUP2 1F03 52 MSTORE 1F04 91 SWAP2 1F05 90 SWAP1 1F06 50 POP 1F07 56 *JUMP label_1F08: // Incoming jump from 0x1E97 // Inputs[2] // { // @1F0B stack[-1] // @1F0C stack[-2] // } 1F08 5B JUMPDEST 1F09 60 PUSH1 0x00 1F0B 81 DUP2 1F0C 83 DUP4 1F0D 10 LT 1F0E 61 PUSH2 0x1f24 1F11 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F09 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f24, if stack[-2] < stack[-1] label_1F12: // Incoming jump from 0x1F11, if not stack[-2] < stack[-1] // Inputs[3] // { // @1F14 stack[-2] // @1F19 stack[-3] // @1F1F memory[0x00:0x40] // } 1F12 60 PUSH1 0x00 1F14 82 DUP3 1F15 81 DUP2 1F16 52 MSTORE 1F17 60 PUSH1 0x20 1F19 84 DUP5 1F1A 90 SWAP1 1F1B 52 MSTORE 1F1C 60 PUSH1 0x40 1F1E 90 SWAP1 1F1F 20 SHA3 1F20 61 PUSH2 0x1726 1F23 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1F16 memory[0x00:0x20] = stack[-2] // @1F1B memory[0x20:0x40] = stack[-3] // @1F1F stack[0] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to 0x1726 label_1F24: // Incoming jump from 0x1F11, if stack[-2] < stack[-1] // Inputs[4] // { // @1F28 stack[-3] // @1F2D stack[-2] // @1F31 memory[0x00:0x40] // @1F32 stack[-4] // } 1F24 5B JUMPDEST 1F25 50 POP 1F26 60 PUSH1 0x00 1F28 91 SWAP2 1F29 82 DUP3 1F2A 52 MSTORE 1F2B 60 PUSH1 0x20 1F2D 52 MSTORE 1F2E 60 PUSH1 0x40 1F30 90 SWAP1 1F31 20 SHA3 1F32 90 SWAP1 1F33 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1F2A memory[0x00:0x20] = stack[-3] // @1F2D memory[0x20:0x40] = stack[-2] // @1F32 stack[-4] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to stack[-4] label_1F34: // Incoming call from 0x1F66, returns to 0x1726 // Inputs[1] { @1F3E stack[-1] } 1F34 5B JUMPDEST 1F35 60 PUSH1 0x01 1F37 60 PUSH1 0x01 1F39 60 PUSH1 0xe0 1F3B 1B SHL 1F3C 03 SUB 1F3D 19 NOT 1F3E 81 DUP2 1F3F 16 AND 1F40 81 DUP2 1F41 14 EQ 1F42 61 PUSH2 0x0805 1F45 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0805, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1F46: // Incoming jump from 0x1F45, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1F49 memory[0x00:0x00] } 1F46 60 PUSH1 0x00 1F48 80 DUP1 1F49 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F49 revert(memory[0x00:0x00]); } // Block terminates label_1F4A: // Incoming call from 0x027B, returns to 0x027C // Inputs[2] // { // @1F4F stack[-1] // @1F50 stack[-2] // } 1F4A 5B JUMPDEST 1F4B 60 PUSH1 0x00 1F4D 60 PUSH1 0x20 1F4F 82 DUP3 1F50 84 DUP5 1F51 03 SUB 1F52 12 SLT 1F53 15 ISZERO 1F54 61 PUSH2 0x1f5c 1F57 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F4B stack[0] = 0x00 } // Block ends with conditional jump to 0x1f5c, if !(stack[-2] - stack[-1] i< 0x20) label_1F58: // Incoming jump from 0x1F57, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1F5B memory[0x00:0x00] } 1F58 60 PUSH1 0x00 1F5A 80 DUP1 1F5B FD *REVERT // Stack delta = +0 // Outputs[1] { @1F5B revert(memory[0x00:0x00]); } // Block terminates label_1F5C: // Incoming jump from 0x1F57, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1F5D stack[-2] // @1F5E msg.data[stack[-2]:stack[-2] + 0x20] // } 1F5C 5B JUMPDEST 1F5D 81 DUP2 1F5E 35 CALLDATALOAD 1F5F 61 PUSH2 0x1726 1F62 81 DUP2 1F63 61 PUSH2 0x1f34 1F66 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F5E stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1F5F stack[1] = 0x1726 // @1F62 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1f34, returns to 0x1726 label_1F67: // Incoming call from 0x2360, returns to 0x2361 // Incoming call from 0x236E, returns to 0x22C0 // Incoming call from 0x206F, returns to 0x2070 // Incoming call from 0x1F9D, returns to 0x1726 // Incoming call from 0x22B1, returns to 0x22B2 // Incoming call from 0x2061, returns to 0x2062 // Incoming call from 0x22F5, returns to 0x22F6 // Incoming call from 0x22E7, returns to 0x22E8 // Incoming call from 0x222D, returns to 0x222E // Incoming call from 0x2035, returns to 0x2036 // Inputs[2] // { // @1F68 stack[-1] // @1F69 msg.data[stack[-1]:stack[-1] + 0x20] // } 1F67 5B JUMPDEST 1F68 80 DUP1 1F69 35 CALLDATALOAD 1F6A 60 PUSH1 0x01 1F6C 60 PUSH1 0x01 1F6E 60 PUSH1 0xa0 1F70 1B SHL 1F71 03 SUB 1F72 81 DUP2 1F73 16 AND 1F74 81 DUP2 1F75 14 EQ 1F76 61 PUSH2 0x1f7e 1F79 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F69 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1f7e, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_1F7A: // Incoming jump from 0x1F79, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1F7D memory[0x00:0x00] } 1F7A 60 PUSH1 0x00 1F7C 80 DUP1 1F7D FD *REVERT // Stack delta = +0 // Outputs[1] { @1F7D revert(memory[0x00:0x00]); } // Block terminates label_1F7E: // Incoming jump from 0x208B, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Incoming jump from 0x1F79, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1F7F stack[-1] // @1F7F stack[-3] // @1F80 stack[-2] // } 1F7E 5B JUMPDEST 1F7F 91 SWAP2 1F80 90 SWAP1 1F81 50 POP 1F82 56 *JUMP // Stack delta = -2 // Outputs[1] { @1F7F stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1F83: // Incoming call from 0x05EC, returns to 0x05ED // Incoming call from 0x02B0, returns to 0x02B1 // Incoming call from 0x0779, returns to 0x077A // Inputs[2] // { // @1F88 stack[-1] // @1F89 stack[-2] // } 1F83 5B JUMPDEST 1F84 60 PUSH1 0x00 1F86 60 PUSH1 0x20 1F88 82 DUP3 1F89 84 DUP5 1F8A 03 SUB 1F8B 12 SLT 1F8C 15 ISZERO 1F8D 61 PUSH2 0x1f95 1F90 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F84 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f95, if !(stack[-2] - stack[-1] i< 0x20) label_1F91: // Incoming jump from 0x1F90, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1F94 memory[0x00:0x00] } 1F91 60 PUSH1 0x00 1F93 80 DUP1 1F94 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F94 revert(memory[0x00:0x00]); } // Block terminates label_1F95: // Incoming jump from 0x1F90, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1F99 stack[-2] } 1F95 5B JUMPDEST 1F96 61 PUSH2 0x1726 1F99 82 DUP3 1F9A 61 PUSH2 0x1f67 1F9D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F96 stack[0] = 0x1726 // @1F99 stack[1] = stack[-2] // } // Block ends with call to 0x1f67, returns to 0x1726 label_1F9E: // Incoming call from 0x1FD9, returns to 0x1FDA // Inputs[1] { @1FA2 stack[-3] } 1F9E 5B JUMPDEST 1F9F 60 PUSH1 0x00 1FA1 5B JUMPDEST 1FA2 83 DUP4 1FA3 81 DUP2 1FA4 10 LT 1FA5 15 ISZERO 1FA6 61 PUSH2 0x1fb9 1FA9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F9F stack[0] = 0x00 } // Block ends with conditional jump to 0x1fb9, if !(0x00 < stack[-3]) label_1FAA: // Incoming jump from 0x1FA9, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1FA9, if not !(0x00 < stack[-3]) // Inputs[4] // { // @1FAA stack[-2] // @1FAB stack[-1] // @1FAD memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1FAE stack[-3] // } 1FAA 81 DUP2 1FAB 81 DUP2 1FAC 01 ADD 1FAD 51 MLOAD 1FAE 83 DUP4 1FAF 82 DUP3 1FB0 01 ADD 1FB1 52 MSTORE 1FB2 60 PUSH1 0x20 1FB4 01 ADD 1FB5 61 PUSH2 0x1fa1 1FB8 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1FB1 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1FB4 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1fa1 label_1FB9: // Incoming jump from 0x1FA9, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1FA9, if !(0x00 < stack[-3]) // Inputs[3] // { // @1FBE stack[-4] // @1FBF stack[-3] // @1FC1 stack[-5] // } 1FB9 5B JUMPDEST 1FBA 50 POP 1FBB 50 POP 1FBC 60 PUSH1 0x00 1FBE 91 SWAP2 1FBF 01 ADD 1FC0 52 MSTORE 1FC1 56 *JUMP // Stack delta = -5 // Outputs[1] { @1FC0 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1FC2: // Incoming call from 0x2000, returns to 0x1726 // Inputs[3] // { // @1FC5 stack[-1] // @1FC6 memory[stack[-1]:stack[-1] + 0x20] // @1FC8 stack[-2] // } 1FC2 5B JUMPDEST 1FC3 60 PUSH1 0x00 1FC5 81 DUP2 1FC6 51 MLOAD 1FC7 80 DUP1 1FC8 84 DUP5 1FC9 52 MSTORE 1FCA 61 PUSH2 0x1fda 1FCD 81 DUP2 1FCE 60 PUSH1 0x20 1FD0 86 DUP7 1FD1 01 ADD 1FD2 60 PUSH1 0x20 1FD4 86 DUP7 1FD5 01 ADD 1FD6 61 PUSH2 0x1f9e 1FD9 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1FC3 stack[0] = 0x00 // @1FC6 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1FC9 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1FCA stack[2] = 0x1fda // @1FCD stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1FD1 stack[4] = stack[-2] + 0x20 // @1FD5 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x1f9e, returns to 0x1FDA label_1FDA: // Incoming return from call to 0x1F9E at 0x1FD9 // Inputs[4] // { // @1FDD stack[-1] // @1FE2 stack[-4] // @1FE3 stack[-2] // @1FE9 stack[-5] // } 1FDA 5B JUMPDEST 1FDB 60 PUSH1 0x1f 1FDD 01 ADD 1FDE 60 PUSH1 0x1f 1FE0 19 NOT 1FE1 16 AND 1FE2 92 SWAP3 1FE3 90 SWAP1 1FE4 92 SWAP3 1FE5 01 ADD 1FE6 60 PUSH1 0x20 1FE8 01 ADD 1FE9 92 SWAP3 1FEA 91 SWAP2 1FEB 50 POP 1FEC 50 POP 1FED 56 *JUMP // Stack delta = -4 // Outputs[1] { @1FE9 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1FEE: // Incoming jump from 0x02D9 // Inputs[2] // { // @1FF1 stack[-1] // @1FFC stack[-2] // } 1FEE 5B JUMPDEST 1FEF 60 PUSH1 0x20 1FF1 81 DUP2 1FF2 52 MSTORE 1FF3 60 PUSH1 0x00 1FF5 61 PUSH2 0x1726 1FF8 60 PUSH1 0x20 1FFA 83 DUP4 1FFB 01 ADD 1FFC 84 DUP5 1FFD 61 PUSH2 0x1fc2 2000 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1FF2 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1FF3 stack[0] = 0x00 // @1FF5 stack[1] = 0x1726 // @1FFB stack[2] = stack[-1] + 0x20 // @1FFC stack[3] = stack[-2] // } // Block ends with call to 0x1fc2, returns to 0x1726 label_2001: // Incoming call from 0x05AC, returns to 0x05AD // Incoming call from 0x05CC, returns to 0x05CD // Incoming call from 0x0621, returns to 0x0622 // Incoming call from 0x0460, returns to 0x0461 // Incoming call from 0x02F4, returns to 0x02F5 // Incoming call from 0x0739, returns to 0x073A // Incoming call from 0x050D, returns to 0x050E // Incoming call from 0x03F4, returns to 0x03F5 // Inputs[2] // { // @2006 stack[-1] // @2007 stack[-2] // } 2001 5B JUMPDEST 2002 60 PUSH1 0x00 2004 60 PUSH1 0x20 2006 82 DUP3 2007 84 DUP5 2008 03 SUB 2009 12 SLT 200A 15 ISZERO 200B 61 PUSH2 0x2013 200E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2002 stack[0] = 0x00 } // Block ends with conditional jump to 0x2013, if !(stack[-2] - stack[-1] i< 0x20) label_200F: // Incoming jump from 0x200E, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2012 memory[0x00:0x00] } 200F 60 PUSH1 0x00 2011 80 DUP1 2012 FD *REVERT // Stack delta = +0 // Outputs[1] { @2012 revert(memory[0x00:0x00]); } // Block terminates label_2013: // Incoming jump from 0x200E, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @2015 stack[-2] // @2015 msg.data[stack[-2]:stack[-2] + 0x20] // @2016 stack[-4] // @2017 stack[-3] // } 2013 5B JUMPDEST 2014 50 POP 2015 35 CALLDATALOAD 2016 91 SWAP2 2017 90 SWAP1 2018 50 POP 2019 56 *JUMP // Stack delta = -3 // Outputs[1] { @2016 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_201A: // Incoming call from 0x0375, returns to 0x0376 // Incoming call from 0x031F, returns to 0x0320 // Incoming call from 0x04BD, returns to 0x04BE // Inputs[2] // { // @2020 stack[-1] // @2021 stack[-2] // } 201A 5B JUMPDEST 201B 60 PUSH1 0x00 201D 80 DUP1 201E 60 PUSH1 0x40 2020 83 DUP4 2021 85 DUP6 2022 03 SUB 2023 12 SLT 2024 15 ISZERO 2025 61 PUSH2 0x202d 2028 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @201B stack[0] = 0x00 // @201D stack[1] = 0x00 // } // Block ends with conditional jump to 0x202d, if !(stack[-2] - stack[-1] i< 0x40) label_2029: // Incoming jump from 0x2028, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @202C memory[0x00:0x00] } 2029 60 PUSH1 0x00 202B 80 DUP1 202C FD *REVERT // Stack delta = +0 // Outputs[1] { @202C revert(memory[0x00:0x00]); } // Block terminates label_202D: // Incoming jump from 0x2028, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2031 stack[-3] } 202D 5B JUMPDEST 202E 61 PUSH2 0x2036 2031 83 DUP4 2032 61 PUSH2 0x1f67 2035 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @202E stack[0] = 0x2036 // @2031 stack[1] = stack[-3] // } // Block ends with call to 0x1f67, returns to 0x2036 label_2036: // Incoming return from call to 0x1F67 at 0x2035 // Inputs[5] // { // @2037 stack[-1] // @2037 stack[-6] // @203A stack[-4] // @203E msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @203F stack[-5] // } 2036 5B JUMPDEST 2037 94 SWAP5 2038 60 PUSH1 0x20 203A 93 SWAP4 203B 90 SWAP1 203C 93 SWAP4 203D 01 ADD 203E 35 CALLDATALOAD 203F 93 SWAP4 2040 50 POP 2041 50 POP 2042 50 POP 2043 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2037 stack[-6] = stack[-1] // @203F stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_2044: // Incoming call from 0x0355, returns to 0x0356 // Incoming call from 0x049D, returns to 0x049E // Inputs[2] // { // @204C stack[-1] // @204D stack[-2] // } 2044 5B JUMPDEST 2045 60 PUSH1 0x00 2047 80 DUP1 2048 60 PUSH1 0x00 204A 60 PUSH1 0x60 204C 84 DUP5 204D 86 DUP7 204E 03 SUB 204F 12 SLT 2050 15 ISZERO 2051 61 PUSH2 0x2059 2054 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2045 stack[0] = 0x00 // @2047 stack[1] = 0x00 // @2048 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2059, if !(stack[-2] - stack[-1] i< 0x60) label_2055: // Incoming jump from 0x2054, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2058 memory[0x00:0x00] } 2055 60 PUSH1 0x00 2057 80 DUP1 2058 FD *REVERT // Stack delta = +0 // Outputs[1] { @2058 revert(memory[0x00:0x00]); } // Block terminates label_2059: // Incoming jump from 0x2054, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @205D stack[-4] } 2059 5B JUMPDEST 205A 61 PUSH2 0x2062 205D 84 DUP5 205E 61 PUSH2 0x1f67 2061 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @205A stack[0] = 0x2062 // @205D stack[1] = stack[-4] // } // Block ends with call to 0x1f67, returns to 0x2062 label_2062: // Incoming return from call to 0x1F67 at 0x2061 // Inputs[3] // { // @2063 stack[-4] // @2063 stack[-1] // @206A stack[-5] // } 2062 5B JUMPDEST 2063 92 SWAP3 2064 50 POP 2065 61 PUSH2 0x2070 2068 60 PUSH1 0x20 206A 85 DUP6 206B 01 ADD 206C 61 PUSH2 0x1f67 206F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2063 stack[-4] = stack[-1] // @2065 stack[-1] = 0x2070 // @206B stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x1f67, returns to 0x2070 label_2070: // Incoming return from call to 0x1F67 at 0x206F // Inputs[8] // { // @2071 stack[-1] // @2071 stack[-3] // @2075 stack[-5] // @2077 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2078 stack[-2] // @207C stack[-6] // @207E stack[-7] // @207E stack[-4] // } 2070 5B JUMPDEST 2071 91 SWAP2 2072 50 POP 2073 60 PUSH1 0x40 2075 84 DUP5 2076 01 ADD 2077 35 CALLDATALOAD 2078 90 SWAP1 2079 50 POP 207A 92 SWAP3 207B 50 POP 207C 92 SWAP3 207D 50 POP 207E 92 SWAP3 207F 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @207A stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @207C stack[-6] = stack[-1] // @207E stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_2080: // Incoming call from 0x20AA, returns to 0x1726 // Incoming call from 0x22BF, returns to 0x22C0 // Inputs[2] // { // @2081 stack[-1] // @2082 msg.data[stack[-1]:stack[-1] + 0x20] // } 2080 5B JUMPDEST 2081 80 DUP1 2082 35 CALLDATALOAD 2083 80 DUP1 2084 15 ISZERO 2085 15 ISZERO 2086 81 DUP2 2087 14 EQ 2088 61 PUSH2 0x1f7e 208B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2082 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1f7e, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_208C: // Incoming jump from 0x208B, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @208F memory[0x00:0x00] } 208C 60 PUSH1 0x00 208E 80 DUP1 208F FD *REVERT // Stack delta = +0 // Outputs[1] { @208F revert(memory[0x00:0x00]); } // Block terminates label_2090: // Incoming call from 0x0395, returns to 0x0396 // Incoming call from 0x0719, returns to 0x071A // Inputs[2] // { // @2095 stack[-1] // @2096 stack[-2] // } 2090 5B JUMPDEST 2091 60 PUSH1 0x00 2093 60 PUSH1 0x20 2095 82 DUP3 2096 84 DUP5 2097 03 SUB 2098 12 SLT 2099 15 ISZERO 209A 61 PUSH2 0x20a2 209D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2091 stack[0] = 0x00 } // Block ends with conditional jump to 0x20a2, if !(stack[-2] - stack[-1] i< 0x20) label_209E: // Incoming jump from 0x209D, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @20A1 memory[0x00:0x00] } 209E 60 PUSH1 0x00 20A0 80 DUP1 20A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @20A1 revert(memory[0x00:0x00]); } // Block terminates label_20A2: // Incoming jump from 0x209D, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @20A6 stack[-2] } 20A2 5B JUMPDEST 20A3 61 PUSH2 0x1726 20A6 82 DUP3 20A7 61 PUSH2 0x2080 20AA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @20A3 stack[0] = 0x1726 // @20A6 stack[1] = stack[-2] // } // Block ends with call to 0x2080, returns to 0x1726 label_20AB: // Incoming call from 0x03B5, returns to 0x03B6 // Inputs[2] // { // @20B1 stack[-1] // @20B2 stack[-2] // } 20AB 5B JUMPDEST 20AC 60 PUSH1 0x00 20AE 80 DUP1 20AF 60 PUSH1 0x40 20B1 83 DUP4 20B2 85 DUP6 20B3 03 SUB 20B4 12 SLT 20B5 15 ISZERO 20B6 61 PUSH2 0x20be 20B9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20AC stack[0] = 0x00 // @20AE stack[1] = 0x00 // } // Block ends with conditional jump to 0x20be, if !(stack[-2] - stack[-1] i< 0x40) label_20BA: // Incoming jump from 0x20B9, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @20BD memory[0x00:0x00] } 20BA 60 PUSH1 0x00 20BC 80 DUP1 20BD FD *REVERT // Stack delta = +0 // Outputs[1] { @20BD revert(memory[0x00:0x00]); } // Block terminates label_20BE: // Incoming jump from 0x20B9, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[5] // { // @20C1 stack[-3] // @20C2 msg.data[stack[-3]:stack[-3] + 0x20] // @20C3 stack[-5] // @20C9 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @20CA stack[-4] // } 20BE 5B JUMPDEST 20BF 50 POP 20C0 50 POP 20C1 80 DUP1 20C2 35 CALLDATALOAD 20C3 92 SWAP3 20C4 60 PUSH1 0x20 20C6 90 SWAP1 20C7 91 SWAP2 20C8 01 ADD 20C9 35 CALLDATALOAD 20CA 91 SWAP2 20CB 50 POP 20CC 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @20C3 stack[-5] = msg.data[stack[-3]:stack[-3] + 0x20] // @20CA stack[-4] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with unconditional jump to stack[-5] label_20CD: // Incoming call from 0x042A, returns to 0x042B // Inputs[2] // { // @20D2 stack[-1] // @20D3 stack[-2] // } 20CD 5B JUMPDEST 20CE 60 PUSH1 0x00 20D0 60 PUSH1 0x20 20D2 82 DUP3 20D3 84 DUP5 20D4 03 SUB 20D5 12 SLT 20D6 15 ISZERO 20D7 61 PUSH2 0x20df 20DA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20CE stack[0] = 0x00 } // Block ends with conditional jump to 0x20df, if !(stack[-2] - stack[-1] i< 0x20) label_20DB: // Incoming jump from 0x20DA, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @20DE memory[0x00:0x00] } 20DB 60 PUSH1 0x00 20DD 80 DUP1 20DE FD *REVERT // Stack delta = +0 // Outputs[1] { @20DE revert(memory[0x00:0x00]); } // Block terminates label_20DF: // Incoming jump from 0x20DA, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @20E0 stack[-2] // @20E1 msg.data[stack[-2]:stack[-2] + 0x20] // } 20DF 5B JUMPDEST 20E0 81 DUP2 20E1 35 CALLDATALOAD 20E2 60 PUSH1 0x01 20E4 60 PUSH1 0x01 20E6 60 PUSH1 0x60 20E8 1B SHL 20E9 03 SUB 20EA 81 DUP2 20EB 16 AND 20EC 81 DUP2 20ED 14 EQ 20EE 61 PUSH2 0x1726 20F1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20E1 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1726, if msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0x60) - 0x01 label_20F2: // Incoming jump from 0x20F1, if not msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0x60) - 0x01 // Inputs[1] { @20F5 memory[0x00:0x00] } 20F2 60 PUSH1 0x00 20F4 80 DUP1 20F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @20F5 revert(memory[0x00:0x00]); } // Block terminates label_20F6: // Incoming jump from 0x2126 // Incoming jump from 0x214E // Incoming jump from 0x2457 // Inputs[1] { @210B memory[0x00:0x24] } 20F6 5B JUMPDEST 20F7 63 PUSH4 0x4e487b71 20FC 60 PUSH1 0xe0 20FE 1B SHL 20FF 60 PUSH1 0x00 2101 52 MSTORE 2102 60 PUSH1 0x41 2104 60 PUSH1 0x04 2106 52 MSTORE 2107 60 PUSH1 0x24 2109 60 PUSH1 0x00 210B FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2101 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2106 memory[0x04:0x24] = 0x41 // @210B revert(memory[0x00:0x24]); // } // Block terminates label_210C: // Incoming call from 0x2338, returns to 0x2339 // Incoming call from 0x21CA, returns to 0x1BC3 // Inputs[1] { @2119 stack[-2] } 210C 5B JUMPDEST 210D 60 PUSH1 0x00 210F 67 PUSH8 0xffffffffffffffff 2118 80 DUP1 2119 84 DUP5 211A 11 GT 211B 15 ISZERO 211C 61 PUSH2 0x2127 211F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @210D stack[0] = 0x00 // @210F stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x2127, if !(stack[-2] > 0xffffffffffffffff) label_2120: // Incoming jump from 0x211F, if not !(stack[-2] > 0xffffffffffffffff) 2120 61 PUSH2 0x2127 2123 61 PUSH2 0x20f6 2126 56 *JUMP // Stack delta = +1 // Outputs[1] { @2120 stack[0] = 0x2127 } // Block ends with unconditional jump to 0x20f6 label_2127: // Incoming jump from 0x211F, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @212A memory[0x40:0x60] // @212D stack[-4] // @213C stack[-1] // } 2127 5B JUMPDEST 2128 60 PUSH1 0x40 212A 51 MLOAD 212B 60 PUSH1 0x1f 212D 85 DUP6 212E 01 ADD 212F 60 PUSH1 0x1f 2131 19 NOT 2132 90 SWAP1 2133 81 DUP2 2134 16 AND 2135 60 PUSH1 0x3f 2137 01 ADD 2138 16 AND 2139 81 DUP2 213A 01 ADD 213B 90 SWAP1 213C 82 DUP3 213D 82 DUP3 213E 11 GT 213F 81 DUP2 2140 83 DUP4 2141 10 LT 2142 17 OR 2143 15 ISZERO 2144 61 PUSH2 0x214f 2147 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @213B stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @213B stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x214f, 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_2148: // Incoming jump from 0x2147, 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])) 2148 61 PUSH2 0x214f 214B 61 PUSH2 0x20f6 214E 56 *JUMP // Stack delta = +1 // Outputs[1] { @2148 stack[0] = 0x214f } // Block ends with unconditional jump to 0x20f6 label_214F: // Incoming jump from 0x2147, 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] // { // @2150 stack[-2] // @2154 stack[-1] // @2155 stack[-4] // @2157 stack[-6] // @215A stack[-7] // @215C stack[-5] // } 214F 5B JUMPDEST 2150 81 DUP2 2151 60 PUSH1 0x40 2153 52 MSTORE 2154 80 DUP1 2155 93 SWAP4 2156 50 POP 2157 85 DUP6 2158 81 DUP2 2159 52 MSTORE 215A 86 DUP7 215B 86 DUP7 215C 86 DUP7 215D 01 ADD 215E 11 GT 215F 15 ISZERO 2160 61 PUSH2 0x2168 2163 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2153 memory[0x40:0x60] = stack[-2] // @2155 stack[-4] = stack[-1] // @2159 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x2168, if !(stack[-5] + stack[-6] > stack[-7]) label_2164: // Incoming jump from 0x2163, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @2167 memory[0x00:0x00] } 2164 60 PUSH1 0x00 2166 80 DUP1 2167 FD *REVERT // Stack delta = +0 // Outputs[1] { @2167 revert(memory[0x00:0x00]); } // Block terminates label_2168: // Incoming jump from 0x2163, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @2169 stack[-6] // @216A stack[-5] // @216D stack[-1] // @216F msg.data[stack[-5]:stack[-5] + stack[-6]] // @217C stack[-8] // @217C stack[-4] // @217D stack[-7] // } 2168 5B JUMPDEST 2169 85 DUP6 216A 85 DUP6 216B 60 PUSH1 0x20 216D 83 DUP4 216E 01 ADD 216F 37 CALLDATACOPY 2170 60 PUSH1 0x00 2172 60 PUSH1 0x20 2174 87 DUP8 2175 83 DUP4 2176 01 ADD 2177 01 ADD 2178 52 MSTORE 2179 50 POP 217A 50 POP 217B 50 POP 217C 93 SWAP4 217D 92 SWAP3 217E 50 POP 217F 50 POP 2180 50 POP 2181 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @216F memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @2178 memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @217C stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_2182: // Incoming call from 0x052D, returns to 0x052E // Inputs[2] // { // @2187 stack[-1] // @2188 stack[-2] // } 2182 5B JUMPDEST 2183 60 PUSH1 0x00 2185 60 PUSH1 0x20 2187 82 DUP3 2188 84 DUP5 2189 03 SUB 218A 12 SLT 218B 15 ISZERO 218C 61 PUSH2 0x2194 218F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2183 stack[0] = 0x00 } // Block ends with conditional jump to 0x2194, if !(stack[-2] - stack[-1] i< 0x20) label_2190: // Incoming jump from 0x218F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2193 memory[0x00:0x00] } 2190 60 PUSH1 0x00 2192 80 DUP1 2193 FD *REVERT // Stack delta = +0 // Outputs[1] { @2193 revert(memory[0x00:0x00]); } // Block terminates label_2194: // Incoming jump from 0x218F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2195 stack[-2] // @2196 msg.data[stack[-2]:stack[-2] + 0x20] // } 2194 5B JUMPDEST 2195 81 DUP2 2196 35 CALLDATALOAD 2197 67 PUSH8 0xffffffffffffffff 21A0 81 DUP2 21A1 11 GT 21A2 15 ISZERO 21A3 61 PUSH2 0x21ab 21A6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2196 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x21ab, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_21A7: // Incoming jump from 0x21A6, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @21AA memory[0x00:0x00] } 21A7 60 PUSH1 0x00 21A9 80 DUP1 21AA FD *REVERT // Stack delta = +0 // Outputs[1] { @21AA revert(memory[0x00:0x00]); } // Block terminates label_21AB: // Incoming jump from 0x21A6, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @21AC stack[-3] // @21AD stack[-1] // @21B2 stack[-4] // } 21AB 5B JUMPDEST 21AC 82 DUP3 21AD 01 ADD 21AE 60 PUSH1 0x1f 21B0 81 DUP2 21B1 01 ADD 21B2 84 DUP5 21B3 13 SGT 21B4 61 PUSH2 0x21bc 21B7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @21AD stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x21bc, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_21B8: // Incoming jump from 0x21B7, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @21BB memory[0x00:0x00] } 21B8 60 PUSH1 0x00 21BA 80 DUP1 21BB FD *REVERT // Stack delta = +0 // Outputs[1] { @21BB revert(memory[0x00:0x00]); } // Block terminates label_21BC: // Incoming jump from 0x21B7, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @21C0 stack[-4] // @21C1 stack[-1] // @21C2 msg.data[stack[-1]:stack[-1] + 0x20] // } 21BC 5B JUMPDEST 21BD 61 PUSH2 0x1bc3 21C0 84 DUP5 21C1 82 DUP3 21C2 35 CALLDATALOAD 21C3 60 PUSH1 0x20 21C5 84 DUP5 21C6 01 ADD 21C7 61 PUSH2 0x210c 21CA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @21BD stack[0] = 0x1bc3 // @21C0 stack[1] = stack[-4] // @21C2 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @21C6 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x210c, returns to 0x1BC3 label_21CB: // Incoming call from 0x2255, returns to 0x2256 // Inputs[2] // { // @21CF stack[-2] // @21D2 stack[-1] // } 21CB 5B JUMPDEST 21CC 60 PUSH1 0x00 21CE 80 DUP1 21CF 83 DUP4 21D0 60 PUSH1 0x1f 21D2 84 DUP5 21D3 01 ADD 21D4 12 SLT 21D5 61 PUSH2 0x21dd 21D8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21CC stack[0] = 0x00 // @21CE stack[1] = 0x00 // } // Block ends with conditional jump to 0x21dd, if stack[-1] + 0x1f i< stack[-2] label_21D9: // Incoming jump from 0x21D8, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @21DC memory[0x00:0x00] } 21D9 60 PUSH1 0x00 21DB 80 DUP1 21DC FD *REVERT // Stack delta = +0 // Outputs[1] { @21DC revert(memory[0x00:0x00]); } // Block terminates label_21DD: // Incoming jump from 0x21D8, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @21DF stack[-3] // @21E0 msg.data[stack[-3]:stack[-3] + 0x20] // } 21DD 5B JUMPDEST 21DE 50 POP 21DF 81 DUP2 21E0 35 CALLDATALOAD 21E1 67 PUSH8 0xffffffffffffffff 21EA 81 DUP2 21EB 11 GT 21EC 15 ISZERO 21ED 61 PUSH2 0x21f5 21F0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @21E0 stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x21f5, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_21F1: // Incoming jump from 0x21F0, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @21F4 memory[0x00:0x00] } 21F1 60 PUSH1 0x00 21F3 80 DUP1 21F4 FD *REVERT // Stack delta = +0 // Outputs[1] { @21F4 revert(memory[0x00:0x00]); } // Block terminates label_21F5: // Incoming jump from 0x21F0, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @21F8 stack[-3] // @21FA stack[-2] // @21FC stack[-4] // @21FF stack[-1] // } 21F5 5B JUMPDEST 21F6 60 PUSH1 0x20 21F8 83 DUP4 21F9 01 ADD 21FA 91 SWAP2 21FB 50 POP 21FC 83 DUP4 21FD 60 PUSH1 0x20 21FF 82 DUP3 2200 60 PUSH1 0x05 2202 1B SHL 2203 85 DUP6 2204 01 ADD 2205 01 ADD 2206 11 GT 2207 15 ISZERO 2208 61 PUSH2 0x0cb8 220B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @21FA stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x0cb8, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) label_220C: // Incoming jump from 0x220B, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Inputs[1] { @220F memory[0x00:0x00] } 220C 60 PUSH1 0x00 220E 80 DUP1 220F FD *REVERT // Stack delta = +0 // Outputs[1] { @220F revert(memory[0x00:0x00]); } // Block terminates label_2210: // Incoming call from 0x054D, returns to 0x054E // Inputs[2] // { // @2218 stack[-1] // @2219 stack[-2] // } 2210 5B JUMPDEST 2211 60 PUSH1 0x00 2213 80 DUP1 2214 60 PUSH1 0x00 2216 60 PUSH1 0x40 2218 84 DUP5 2219 86 DUP7 221A 03 SUB 221B 12 SLT 221C 15 ISZERO 221D 61 PUSH2 0x2225 2220 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2211 stack[0] = 0x00 // @2213 stack[1] = 0x00 // @2214 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2225, if !(stack[-2] - stack[-1] i< 0x40) label_2221: // Incoming jump from 0x2220, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2224 memory[0x00:0x00] } 2221 60 PUSH1 0x00 2223 80 DUP1 2224 FD *REVERT // Stack delta = +0 // Outputs[1] { @2224 revert(memory[0x00:0x00]); } // Block terminates label_2225: // Incoming jump from 0x2220, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2229 stack[-4] } 2225 5B JUMPDEST 2226 61 PUSH2 0x222e 2229 84 DUP5 222A 61 PUSH2 0x1f67 222D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2226 stack[0] = 0x222e // @2229 stack[1] = stack[-4] // } // Block ends with call to 0x1f67, returns to 0x222E label_222E: // Incoming return from call to 0x1F67 at 0x222D // Inputs[4] // { // @222F stack[-4] // @222F stack[-1] // @2233 stack[-5] // @2235 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 222E 5B JUMPDEST 222F 92 SWAP3 2230 50 POP 2231 60 PUSH1 0x20 2233 84 DUP5 2234 01 ADD 2235 35 CALLDATALOAD 2236 67 PUSH8 0xffffffffffffffff 223F 81 DUP2 2240 11 GT 2241 15 ISZERO 2242 61 PUSH2 0x224a 2245 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @222F stack[-4] = stack[-1] // @2235 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x224a, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) label_2246: // Incoming jump from 0x2245, if not !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2249 memory[0x00:0x00] } 2246 60 PUSH1 0x00 2248 80 DUP1 2249 FD *REVERT // Stack delta = +0 // Outputs[1] { @2249 revert(memory[0x00:0x00]); } // Block terminates label_224A: // Incoming jump from 0x2245, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Incoming jump from 0x2291, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @224E stack[-6] // @224F stack[-1] // @2250 stack[-5] // } 224A 5B JUMPDEST 224B 61 PUSH2 0x2256 224E 86 DUP7 224F 82 DUP3 2250 87 DUP8 2251 01 ADD 2252 61 PUSH2 0x21cb 2255 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @224B stack[0] = 0x2256 // @224E stack[1] = stack[-6] // @2251 stack[2] = stack[-5] + stack[-1] // } // Block ends with call to 0x21cb, returns to 0x2256 label_2256: // Incoming return from call to 0x21CB at 0x2255 // Inputs[6] // { // @2257 stack[-6] // @2257 stack[-1] // @2258 stack[-9] // @2259 stack[-2] // @225A stack[-8] // @225D stack[-7] // } 2256 5B JUMPDEST 2257 94 SWAP5 2258 97 SWAP8 2259 90 SWAP1 225A 96 SWAP7 225B 50 POP 225C 93 SWAP4 225D 94 SWAP5 225E 50 POP 225F 50 POP 2260 50 POP 2261 50 POP 2262 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @2258 stack[-9] = stack[-6] // @225A stack[-8] = stack[-2] // @225D stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-9] label_2263: // Incoming call from 0x056D, returns to 0x056E // Inputs[2] // { // @226B stack[-1] // @226C stack[-2] // } 2263 5B JUMPDEST 2264 60 PUSH1 0x00 2266 80 DUP1 2267 60 PUSH1 0x00 2269 60 PUSH1 0x40 226B 84 DUP5 226C 86 DUP7 226D 03 SUB 226E 12 SLT 226F 15 ISZERO 2270 61 PUSH2 0x2278 2273 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2264 stack[0] = 0x00 // @2266 stack[1] = 0x00 // @2267 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2278, if !(stack[-2] - stack[-1] i< 0x40) label_2274: // Incoming jump from 0x2273, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2277 memory[0x00:0x00] } 2274 60 PUSH1 0x00 2276 80 DUP1 2277 FD *REVERT // Stack delta = +0 // Outputs[1] { @2277 revert(memory[0x00:0x00]); } // Block terminates label_2278: // Incoming jump from 0x2273, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @2279 stack[-4] // @227A msg.data[stack[-4]:stack[-4] + 0x20] // @227B stack[-3] // @2281 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 2278 5B JUMPDEST 2279 83 DUP4 227A 35 CALLDATALOAD 227B 92 SWAP3 227C 50 POP 227D 60 PUSH1 0x20 227F 84 DUP5 2280 01 ADD 2281 35 CALLDATALOAD 2282 67 PUSH8 0xffffffffffffffff 228B 81 DUP2 228C 11 GT 228D 15 ISZERO 228E 61 PUSH2 0x224a 2291 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @227B stack[-3] = msg.data[stack[-4]:stack[-4] + 0x20] // @2281 stack[0] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x224a, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) label_2292: // Incoming jump from 0x2291, if not !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2295 memory[0x00:0x00] } 2292 60 PUSH1 0x00 2294 80 DUP1 2295 FD *REVERT // Stack delta = +0 // Outputs[1] { @2295 revert(memory[0x00:0x00]); } // Block terminates label_2296: // Incoming call from 0x0689, returns to 0x068A // Inputs[2] // { // @229C stack[-1] // @229D stack[-2] // } 2296 5B JUMPDEST 2297 60 PUSH1 0x00 2299 80 DUP1 229A 60 PUSH1 0x40 229C 83 DUP4 229D 85 DUP6 229E 03 SUB 229F 12 SLT 22A0 15 ISZERO 22A1 61 PUSH2 0x22a9 22A4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2297 stack[0] = 0x00 // @2299 stack[1] = 0x00 // } // Block ends with conditional jump to 0x22a9, if !(stack[-2] - stack[-1] i< 0x40) label_22A5: // Incoming jump from 0x22A4, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @22A8 memory[0x00:0x00] } 22A5 60 PUSH1 0x00 22A7 80 DUP1 22A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @22A8 revert(memory[0x00:0x00]); } // Block terminates label_22A9: // Incoming jump from 0x22A4, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @22AD stack[-3] } 22A9 5B JUMPDEST 22AA 61 PUSH2 0x22b2 22AD 83 DUP4 22AE 61 PUSH2 0x1f67 22B1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @22AA stack[0] = 0x22b2 // @22AD stack[1] = stack[-3] // } // Block ends with call to 0x1f67, returns to 0x22B2 label_22B2: // Incoming return from call to 0x1F67 at 0x22B1 // Inputs[3] // { // @22B3 stack[-3] // @22B3 stack[-1] // @22BA stack[-4] // } 22B2 5B JUMPDEST 22B3 91 SWAP2 22B4 50 POP 22B5 61 PUSH2 0x22c0 22B8 60 PUSH1 0x20 22BA 84 DUP5 22BB 01 ADD 22BC 61 PUSH2 0x2080 22BF 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @22B3 stack[-3] = stack[-1] // @22B5 stack[-1] = 0x22c0 // @22BB stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x2080, returns to 0x22C0 label_22C0: // Incoming return from call to 0x1F67 at 0x236E // Incoming return from call to 0x2080 at 0x22BF // Inputs[6] // { // @22C1 stack[-1] // @22C1 stack[-2] // @22C3 stack[-5] // @22C5 stack[-3] // @22C5 stack[-6] // @22C6 stack[-4] // } 22C0 5B JUMPDEST 22C1 90 SWAP1 22C2 50 POP 22C3 92 SWAP3 22C4 50 POP 22C5 92 SWAP3 22C6 90 SWAP1 22C7 50 POP 22C8 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @22C3 stack[-5] = stack[-1] // @22C5 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_22C9: // Incoming call from 0x06C1, returns to 0x06C2 // Inputs[2] // { // @22D2 stack[-1] // @22D3 stack[-2] // } 22C9 5B JUMPDEST 22CA 60 PUSH1 0x00 22CC 80 DUP1 22CD 60 PUSH1 0x00 22CF 80 DUP1 22D0 60 PUSH1 0x80 22D2 85 DUP6 22D3 87 DUP8 22D4 03 SUB 22D5 12 SLT 22D6 15 ISZERO 22D7 61 PUSH2 0x22df 22DA 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @22CA stack[0] = 0x00 // @22CC stack[1] = 0x00 // @22CD stack[2] = 0x00 // @22CF stack[3] = 0x00 // } // Block ends with conditional jump to 0x22df, if !(stack[-2] - stack[-1] i< 0x80) label_22DB: // Incoming jump from 0x22DA, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @22DE memory[0x00:0x00] } 22DB 60 PUSH1 0x00 22DD 80 DUP1 22DE FD *REVERT // Stack delta = +0 // Outputs[1] { @22DE revert(memory[0x00:0x00]); } // Block terminates label_22DF: // Incoming jump from 0x22DA, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @22E3 stack[-5] } 22DF 5B JUMPDEST 22E0 61 PUSH2 0x22e8 22E3 85 DUP6 22E4 61 PUSH2 0x1f67 22E7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @22E0 stack[0] = 0x22e8 // @22E3 stack[1] = stack[-5] // } // Block ends with call to 0x1f67, returns to 0x22E8 label_22E8: // Incoming return from call to 0x1F67 at 0x22E7 // Inputs[3] // { // @22E9 stack[-5] // @22E9 stack[-1] // @22F0 stack[-6] // } 22E8 5B JUMPDEST 22E9 93 SWAP4 22EA 50 POP 22EB 61 PUSH2 0x22f6 22EE 60 PUSH1 0x20 22F0 86 DUP7 22F1 01 ADD 22F2 61 PUSH2 0x1f67 22F5 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @22E9 stack[-5] = stack[-1] // @22EB stack[-1] = 0x22f6 // @22F1 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x1f67, returns to 0x22F6 label_22F6: // Incoming return from call to 0x1F67 at 0x22F5 // Inputs[6] // { // @22F7 stack[-4] // @22F7 stack[-1] // @22FB stack[-6] // @22FD msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @22FE stack[-3] // @2304 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 22F6 5B JUMPDEST 22F7 92 SWAP3 22F8 50 POP 22F9 60 PUSH1 0x40 22FB 85 DUP6 22FC 01 ADD 22FD 35 CALLDATALOAD 22FE 91 SWAP2 22FF 50 POP 2300 60 PUSH1 0x60 2302 85 DUP6 2303 01 ADD 2304 35 CALLDATALOAD 2305 67 PUSH8 0xffffffffffffffff 230E 81 DUP2 230F 11 GT 2310 15 ISZERO 2311 61 PUSH2 0x2319 2314 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @22F7 stack[-4] = stack[-1] // @22FE stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2304 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x2319, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_2315: // Incoming jump from 0x2314, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2318 memory[0x00:0x00] } 2315 60 PUSH1 0x00 2317 80 DUP1 2318 FD *REVERT // Stack delta = +0 // Outputs[1] { @2318 revert(memory[0x00:0x00]); } // Block terminates label_2319: // Incoming jump from 0x2314, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @231A stack[-6] // @231B stack[-1] // @2320 stack[-7] // } 2319 5B JUMPDEST 231A 85 DUP6 231B 01 ADD 231C 60 PUSH1 0x1f 231E 81 DUP2 231F 01 ADD 2320 87 DUP8 2321 13 SGT 2322 61 PUSH2 0x232a 2325 57 *JUMPI // Stack delta = +0 // Outputs[1] { @231B stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x232a, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_2326: // Incoming jump from 0x2325, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @2329 memory[0x00:0x00] } 2326 60 PUSH1 0x00 2328 80 DUP1 2329 FD *REVERT // Stack delta = +0 // Outputs[1] { @2329 revert(memory[0x00:0x00]); } // Block terminates label_232A: // Incoming jump from 0x2325, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @232E stack[-7] // @232F stack[-1] // @2330 msg.data[stack[-1]:stack[-1] + 0x20] // } 232A 5B JUMPDEST 232B 61 PUSH2 0x2339 232E 87 DUP8 232F 82 DUP3 2330 35 CALLDATALOAD 2331 60 PUSH1 0x20 2333 84 DUP5 2334 01 ADD 2335 61 PUSH2 0x210c 2338 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @232B stack[0] = 0x2339 // @232E stack[1] = stack[-7] // @2330 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2334 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x210c, returns to 0x2339 label_2339: // Incoming return from call to 0x210C at 0x2338 // Inputs[8] // { // @233A stack[-3] // @233A stack[-1] // @233D stack[-6] // @233E stack[-9] // @233F stack[-5] // @2340 stack[-8] // @2342 stack[-7] // @2342 stack[-4] // } 2339 5B JUMPDEST 233A 91 SWAP2 233B 50 POP 233C 50 POP 233D 92 SWAP3 233E 95 SWAP6 233F 91 SWAP2 2340 94 SWAP5 2341 50 POP 2342 92 SWAP3 2343 50 POP 2344 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @233D stack[-6] = stack[-1] // @233E stack[-9] = stack[-6] // @2340 stack[-8] = stack[-5] // @2342 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_2345: // Incoming call from 0x0759, returns to 0x075A // Inputs[2] // { // @234B stack[-1] // @234C stack[-2] // } 2345 5B JUMPDEST 2346 60 PUSH1 0x00 2348 80 DUP1 2349 60 PUSH1 0x40 234B 83 DUP4 234C 85 DUP6 234D 03 SUB 234E 12 SLT 234F 15 ISZERO 2350 61 PUSH2 0x2358 2353 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2346 stack[0] = 0x00 // @2348 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2358, if !(stack[-2] - stack[-1] i< 0x40) label_2354: // Incoming jump from 0x2353, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2357 memory[0x00:0x00] } 2354 60 PUSH1 0x00 2356 80 DUP1 2357 FD *REVERT // Stack delta = +0 // Outputs[1] { @2357 revert(memory[0x00:0x00]); } // Block terminates label_2358: // Incoming jump from 0x2353, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @235C stack[-3] } 2358 5B JUMPDEST 2359 61 PUSH2 0x2361 235C 83 DUP4 235D 61 PUSH2 0x1f67 2360 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2359 stack[0] = 0x2361 // @235C stack[1] = stack[-3] // } // Block ends with call to 0x1f67, returns to 0x2361 label_2361: // Incoming return from call to 0x1F67 at 0x2360 // Inputs[3] // { // @2362 stack[-1] // @2362 stack[-3] // @2369 stack[-4] // } 2361 5B JUMPDEST 2362 91 SWAP2 2363 50 POP 2364 61 PUSH2 0x22c0 2367 60 PUSH1 0x20 2369 84 DUP5 236A 01 ADD 236B 61 PUSH2 0x1f67 236E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2362 stack[-3] = stack[-1] // @2364 stack[-1] = 0x22c0 // @236A stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1f67, returns to 0x22C0 label_236F: // Incoming call from 0x0816, returns to 0x0817 // Incoming call from 0x2465, returns to 0x2466 // Incoming call from 0x0842, returns to 0x0843 // Incoming call from 0x1EC3, returns to 0x0817 // Incoming call from 0x12A2, returns to 0x0817 // Inputs[1] { @2372 stack[-1] } 236F 5B JUMPDEST 2370 60 PUSH1 0x01 2372 81 DUP2 2373 81 DUP2 2374 1C SHR 2375 90 SWAP1 2376 82 DUP3 2377 16 AND 2378 80 DUP1 2379 61 PUSH2 0x2383 237C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2375 stack[0] = stack[-1] >> 0x01 // @2377 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2383, if stack[-1] & 0x01 label_237D: // Incoming jump from 0x237C, if not stack[-1] & 0x01 // Inputs[2] // { // @237F stack[-2] // @2388 stack[-1] // } 237D 60 PUSH1 0x7f 237F 82 DUP3 2380 16 AND 2381 91 SWAP2 2382 50 POP 2383 5B JUMPDEST 2384 60 PUSH1 0x20 2386 82 DUP3 2387 10 LT 2388 81 DUP2 2389 03 SUB 238A 61 PUSH2 0x23a3 238D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2381 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x23a3, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_238E: // Incoming jump from 0x238D, if not stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x238D, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[1] { @23A2 memory[0x00:0x24] } 238E 63 PUSH4 0x4e487b71 2393 60 PUSH1 0xe0 2395 1B SHL 2396 60 PUSH1 0x00 2398 52 MSTORE 2399 60 PUSH1 0x22 239B 60 PUSH1 0x04 239D 52 MSTORE 239E 60 PUSH1 0x24 23A0 60 PUSH1 0x00 23A2 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2398 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @239D memory[0x04:0x24] = 0x22 // @23A2 revert(memory[0x00:0x24]); // } // Block terminates label_23A3: // Incoming jump from 0x238D, if stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x238D, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[3] // { // @23A5 stack[-4] // @23A5 stack[-2] // @23A6 stack[-3] // } 23A3 5B JUMPDEST 23A4 50 POP 23A5 91 SWAP2 23A6 90 SWAP1 23A7 50 POP 23A8 56 *JUMP // Stack delta = -3 // Outputs[1] { @23A5 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_23A9: // Incoming jump from 0x2525 // Incoming jump from 0x23D5 // Incoming jump from 0x253F // Inputs[1] { @23BE memory[0x00:0x24] } 23A9 5B JUMPDEST 23AA 63 PUSH4 0x4e487b71 23AF 60 PUSH1 0xe0 23B1 1B SHL 23B2 60 PUSH1 0x00 23B4 52 MSTORE 23B5 60 PUSH1 0x11 23B7 60 PUSH1 0x04 23B9 52 MSTORE 23BA 60 PUSH1 0x24 23BC 60 PUSH1 0x00 23BE FD *REVERT // Stack delta = +0 // Outputs[3] // { // @23B4 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @23B9 memory[0x04:0x24] = 0x11 // @23BE revert(memory[0x00:0x24]); // } // Block terminates label_23BF: // Incoming call from 0x0CA4, returns to 0x0CA5 // Incoming call from 0x0CA4, returns to 0x0CA5 // Inputs[2] // { // @23C0 stack[-1] // @23C1 stack[-2] // } 23BF 5B JUMPDEST 23C0 80 DUP1 23C1 82 DUP3 23C2 02 MUL 23C3 81 DUP2 23C4 15 ISZERO 23C5 82 DUP3 23C6 82 DUP3 23C7 04 DIV 23C8 84 DUP5 23C9 14 EQ 23CA 17 OR 23CB 61 PUSH2 0x07b3 23CE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @23C2 stack[0] = stack[-2] * stack[-1] } // Block ends with conditional jump to 0x07b3, if (stack[-2] == (stack[-2] * stack[-1]) / stack[-1]) | !stack[-1] label_23CF: // Incoming jump from 0x23CE, if not (stack[-2] == (stack[-2] * stack[-1]) / stack[-1]) | !stack[-1] 23CF 61 PUSH2 0x07b3 23D2 61 PUSH2 0x23a9 23D5 56 *JUMP // Stack delta = +1 // Outputs[1] { @23CF stack[0] = 0x07b3 } // Block ends with unconditional jump to 0x23a9 label_23D6: // Incoming call from 0x0CAE, returns to 0x0CAF // Inputs[1] { @23D9 stack[-2] } 23D6 5B JUMPDEST 23D7 60 PUSH1 0x00 23D9 82 DUP3 23DA 61 PUSH2 0x23f3 23DD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @23D7 stack[0] = 0x00 } // Block ends with conditional jump to 0x23f3, if stack[-2] label_23DE: // Incoming jump from 0x23DD, if not stack[-2] // Inputs[1] { @23F2 memory[0x00:0x24] } 23DE 63 PUSH4 0x4e487b71 23E3 60 PUSH1 0xe0 23E5 1B SHL 23E6 60 PUSH1 0x00 23E8 52 MSTORE 23E9 60 PUSH1 0x12 23EB 60 PUSH1 0x04 23ED 52 MSTORE 23EE 60 PUSH1 0x24 23F0 60 PUSH1 0x00 23F2 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @23E8 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @23ED memory[0x04:0x24] = 0x12 // @23F2 revert(memory[0x00:0x24]); // } // Block terminates label_23F3: // Incoming jump from 0x23DD, if stack[-2] // Inputs[3] // { // @23F5 stack[-3] // @23F5 stack[-2] // @23F6 stack[-4] // } 23F3 5B JUMPDEST 23F4 50 POP 23F5 04 DIV 23F6 90 SWAP1 23F7 56 *JUMP // Stack delta = -3 // Outputs[1] { @23F6 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_23F8: // Incoming jump from 0x246B // Inputs[1] { @23FB stack[-2] } 23F8 5B JUMPDEST 23F9 60 PUSH1 0x1f 23FB 82 DUP3 23FC 11 GT 23FD 15 ISZERO 23FE 61 PUSH2 0x0bf1 2401 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bf1, if !(stack[-2] > 0x1f) label_2402: // Incoming jump from 0x2401, if not !(stack[-2] > 0x1f) // Inputs[3] // { // @2404 stack[-1] // @240A memory[0x00:0x20] // @240D stack[-3] // } 2402 60 PUSH1 0x00 2404 81 DUP2 2405 81 DUP2 2406 52 MSTORE 2407 60 PUSH1 0x20 2409 81 DUP2 240A 20 SHA3 240B 60 PUSH1 0x1f 240D 85 DUP6 240E 01 ADD 240F 60 PUSH1 0x05 2411 1C SHR 2412 81 DUP2 2413 01 ADD 2414 60 PUSH1 0x20 2416 86 DUP7 2417 10 LT 2418 15 ISZERO 2419 61 PUSH2 0x241f 241C 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @2402 stack[0] = 0x00 // @2406 memory[0x00:0x20] = stack[-1] // @240A stack[1] = keccak256(memory[0x00:0x20]) // @2413 stack[2] = keccak256(memory[0x00:0x20]) + (stack[-3] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x241f, if !(stack[-3] < 0x20) label_241D: // Incoming jump from 0x241C, if not !(stack[-3] < 0x20) // Inputs[2] // { // @241E stack[-2] // @2422 stack[-5] // } 241D 50 POP 241E 80 DUP1 241F 5B JUMPDEST 2420 60 PUSH1 0x1f 2422 85 DUP6 2423 01 ADD 2424 60 PUSH1 0x05 2426 1C SHR 2427 82 DUP3 2428 01 ADD 2429 91 SWAP2 242A 50 POP 242B 5B JUMPDEST 242C 81 DUP2 242D 81 DUP2 242E 10 LT 242F 15 ISZERO 2430 61 PUSH2 0x0afc 2433 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @241E stack[-1] = stack[-2] // @2429 stack[-2] = stack[-2] + (stack[-5] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x0afc, if !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) label_2434: // Incoming jump from 0x2433, if not !(stack[-1] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x2433, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x2433, if not !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Inputs[2] // { // @2434 stack[-3] // @2435 stack[-1] // } 2434 82 DUP3 2435 81 DUP2 2436 55 SSTORE 2437 60 PUSH1 0x01 2439 01 ADD 243A 61 PUSH2 0x242b 243D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2436 storage[stack[-1]] = stack[-3] // @2439 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x242b label_243E: // Incoming call from 0x0F53, returns to 0x094E // Inputs[2] // { // @243F stack[-2] // @2440 memory[stack[-2]:stack[-2] + 0x20] // } 243E 5B JUMPDEST 243F 81 DUP2 2440 51 MLOAD 2441 67 PUSH8 0xffffffffffffffff 244A 81 DUP2 244B 11 GT 244C 15 ISZERO 244D 61 PUSH2 0x2458 2450 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2440 stack[0] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2458, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_2451: // Incoming jump from 0x2450, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) 2451 61 PUSH2 0x2458 2454 61 PUSH2 0x20f6 2457 56 *JUMP // Stack delta = +1 // Outputs[1] { @2451 stack[0] = 0x2458 } // Block ends with unconditional jump to 0x20f6 label_2458: // Incoming jump from 0x2450, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @245C stack[-1] // @2460 stack[-2] // @2461 storage[stack[-2]] // } 2458 5B JUMPDEST 2459 61 PUSH2 0x246c 245C 81 DUP2 245D 61 PUSH2 0x2466 2460 84 DUP5 2461 54 SLOAD 2462 61 PUSH2 0x236f 2465 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2459 stack[0] = 0x246c // @245C stack[1] = stack[-1] // @245D stack[2] = 0x2466 // @2461 stack[3] = storage[stack[-2]] // } // Block ends with call to 0x236f, returns to 0x2466 label_2466: // Incoming return from call to 0x236F at 0x2465 // Inputs[1] { @2467 stack[-5] } 2466 5B JUMPDEST 2467 84 DUP5 2468 61 PUSH2 0x23f8 246B 56 *JUMP // Stack delta = +1 // Outputs[1] { @2467 stack[0] = stack[-5] } // Block ends with unconditional jump to 0x23f8 label_246C: // Incoming return from call to 0x2466 at 0x2465 // Inputs[1] { @2472 stack[-1] } 246C 5B JUMPDEST 246D 60 PUSH1 0x20 246F 80 DUP1 2470 60 PUSH1 0x1f 2472 83 DUP4 2473 11 GT 2474 60 PUSH1 0x01 2476 81 DUP2 2477 14 EQ 2478 61 PUSH2 0x24a1 247B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @246D stack[0] = 0x20 // @246F stack[1] = 0x20 // @2473 stack[2] = stack[-1] > 0x1f // } // Block ends with conditional jump to 0x24a1, if (stack[-1] > 0x1f) == 0x01 label_247C: // Incoming jump from 0x247B, if not (stack[-1] > 0x1f) == 0x01 // Inputs[1] { @247E stack[-4] } 247C 60 PUSH1 0x00 247E 84 DUP5 247F 15 ISZERO 2480 61 PUSH2 0x2489 2483 57 *JUMPI // Stack delta = +1 // Outputs[1] { @247C stack[0] = 0x00 } // Block ends with conditional jump to 0x2489, if !stack[-4] label_2484: // Incoming jump from 0x2483, if not !stack[-4] // Inputs[5] // { // @2485 stack[-7] // @2486 stack[-4] // @2488 memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20] // @248F stack[-5] // @249B stack[-6] // } 2484 50 POP 2485 85 DUP6 2486 83 DUP4 2487 01 ADD 2488 51 MLOAD 2489 5B JUMPDEST 248A 60 PUSH1 0x00 248C 19 NOT 248D 60 PUSH1 0x03 248F 86 DUP7 2490 90 SWAP1 2491 1B SHL 2492 1C SHR 2493 19 NOT 2494 16 AND 2495 60 PUSH1 0x01 2497 85 DUP6 2498 90 SWAP1 2499 1B SHL 249A 17 OR 249B 85 DUP6 249C 55 SSTORE 249D 61 PUSH2 0x0afc 24A0 56 *JUMP // Stack delta = -1 // Outputs[1] { @249C storage[stack[-6]] = (stack[-5] << 0x01) | (~(~0x00 >> (stack[-5] << 0x03)) & memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20]) } // Block ends with unconditional jump to 0x0afc label_24A1: // Incoming jump from 0x247B, if (stack[-1] > 0x1f) == 0x01 // Inputs[3] // { // @24A4 stack[-5] // @24AA memory[0x00:0x20] // @24AE stack[-4] // } 24A1 5B JUMPDEST 24A2 60 PUSH1 0x00 24A4 85 DUP6 24A5 81 DUP2 24A6 52 MSTORE 24A7 60 PUSH1 0x20 24A9 81 DUP2 24AA 20 SHA3 24AB 60 PUSH1 0x1f 24AD 19 NOT 24AE 86 DUP7 24AF 16 AND 24B0 91 SWAP2 24B1 5B JUMPDEST 24B2 82 DUP3 24B3 81 DUP2 24B4 10 LT 24B5 15 ISZERO 24B6 61 PUSH2 0x24d0 24B9 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @24A6 memory[0x00:0x20] = stack[-5] // @24AA stack[1] = keccak256(memory[0x00:0x20]) // @24B0 stack[0] = stack[-4] & ~0x1f // @24B0 stack[2] = 0x00 // } // Block ends with conditional jump to 0x24d0, if !(0x00 < stack[-4] & ~0x1f) label_24BA: // Incoming jump from 0x24B9, if not !(0x00 < stack[-4] & ~0x1f) // Incoming jump from 0x24B9, if not !(stack[-1] < stack[-3]) // Inputs[6] // { // @24BA stack[-9] // @24BB stack[-6] // @24BD memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @24BE stack[-2] // @24C0 stack[-1] // @24C1 stack[-5] // } 24BA 88 DUP9 24BB 86 DUP7 24BC 01 ADD 24BD 51 MLOAD 24BE 82 DUP3 24BF 55 SSTORE 24C0 94 SWAP5 24C1 84 DUP5 24C2 01 ADD 24C3 94 SWAP5 24C4 60 PUSH1 0x01 24C6 90 SWAP1 24C7 91 SWAP2 24C8 01 ADD 24C9 90 SWAP1 24CA 84 DUP5 24CB 01 ADD 24CC 61 PUSH2 0x24b1 24CF 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @24BF storage[stack[-2]] = memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @24C3 stack[-6] = stack[-5] + stack[-6] // @24C9 stack[-2] = stack[-2] + 0x01 // @24CB stack[-1] = stack[-5] + stack[-1] // } // Block ends with unconditional jump to 0x24b1 label_24D0: // Incoming jump from 0x24B9, if !(0x00 < stack[-4] & ~0x1f) // Incoming jump from 0x24B9, if !(stack[-1] < stack[-3]) // Inputs[2] // { // @24D2 stack[-7] // @24D3 stack[-3] // } 24D0 5B JUMPDEST 24D1 50 POP 24D2 85 DUP6 24D3 82 DUP3 24D4 10 LT 24D5 15 ISZERO 24D6 61 PUSH2 0x24ee 24D9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x24ee, if !(stack[-3] < stack[-7]) label_24DA: // Incoming jump from 0x24D9, if not !(stack[-3] < stack[-7]) // Inputs[7] // { // @24DA stack[-8] // @24DB stack[-5] // @24DD memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @24E3 stack[-6] // @24EC stack[-1] // @24FA stack[-7] // @24FD stack[-9] // } 24DA 87 DUP8 24DB 85 DUP6 24DC 01 ADD 24DD 51 MLOAD 24DE 60 PUSH1 0x00 24E0 19 NOT 24E1 60 PUSH1 0x03 24E3 88 DUP9 24E4 90 SWAP1 24E5 1B SHL 24E6 60 PUSH1 0xf8 24E8 16 AND 24E9 1C SHR 24EA 19 NOT 24EB 16 AND 24EC 81 DUP2 24ED 55 SSTORE 24EE 5B JUMPDEST 24EF 50 POP 24F0 50 POP 24F1 50 POP 24F2 50 POP 24F3 50 POP 24F4 60 PUSH1 0x01 24F6 90 SWAP1 24F7 81 DUP2 24F8 1B SHL 24F9 01 ADD 24FA 90 SWAP1 24FB 55 SSTORE 24FC 50 POP 24FD 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @24ED storage[stack[-1]] = ~(~0x00 >> (0xf8 & (stack[-6] << 0x03))) & memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @24FB storage[stack[-7]] = (stack[-6] << 0x01) + 0x01 // } // Block ends with unconditional jump to stack[-9] label_24FE: // Incoming jump from 0x1E8B // Incoming jump from 0x0F7D // Inputs[1] { @2513 memory[0x00:0x24] } 24FE 5B JUMPDEST 24FF 63 PUSH4 0x4e487b71 2504 60 PUSH1 0xe0 2506 1B SHL 2507 60 PUSH1 0x00 2509 52 MSTORE 250A 60 PUSH1 0x32 250C 60 PUSH1 0x04 250E 52 MSTORE 250F 60 PUSH1 0x24 2511 60 PUSH1 0x00 2513 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2509 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @250E memory[0x04:0x24] = 0x32 // @2513 revert(memory[0x00:0x24]); // } // Block terminates label_2514: // Incoming call from 0x1EA3, returns to 0x1EA4 // Incoming call from 0x0FC1, returns to 0x0FC2 // Inputs[1] { @2519 stack[-1] } 2514 5B JUMPDEST 2515 60 PUSH1 0x00 2517 60 PUSH1 0x01 2519 82 DUP3 251A 01 ADD 251B 61 PUSH2 0x2526 251E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2515 stack[0] = 0x00 } // Block ends with conditional jump to 0x2526, if stack[-1] + 0x01 label_251F: // Incoming jump from 0x251E, if not stack[-1] + 0x01 251F 61 PUSH2 0x2526 2522 61 PUSH2 0x23a9 2525 56 *JUMP // Stack delta = +1 // Outputs[1] { @251F stack[0] = 0x2526 } // Block ends with unconditional jump to 0x23a9 label_2526: // Incoming jump from 0x251E, if stack[-1] + 0x01 // Inputs[2] // { // @252A stack[-2] // @252B stack[-3] // } 2526 5B JUMPDEST 2527 50 POP 2528 60 PUSH1 0x01 252A 01 ADD 252B 90 SWAP1 252C 56 *JUMP // Stack delta = -2 // Outputs[1] { @252B stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_252D: // Incoming call from 0x18AC, returns to 0x18AD // Inputs[2] // { // @252E stack[-1] // @252F stack[-2] // } 252D 5B JUMPDEST 252E 80 DUP1 252F 82 DUP3 2530 01 ADD 2531 80 DUP1 2532 82 DUP3 2533 11 GT 2534 15 ISZERO 2535 61 PUSH2 0x07b3 2538 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2530 stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x07b3, if !(stack[-1] > stack[-2] + stack[-1]) label_2539: // Incoming jump from 0x2538, if not !(stack[-1] > stack[-2] + stack[-1]) 2539 61 PUSH2 0x07b3 253C 61 PUSH2 0x23a9 253F 56 *JUMP // Stack delta = +1 // Outputs[1] { @2539 stack[0] = 0x07b3 } // Block ends with unconditional jump to 0x23a9 2540 5B JUMPDEST 2541 60 PUSH1 0x00 2543 83 DUP4 2544 51 MLOAD 2545 61 PUSH2 0x2552 2548 81 DUP2 2549 84 DUP5 254A 60 PUSH1 0x20 254C 88 DUP9 254D 01 ADD 254E 61 PUSH2 0x1f9e 2551 56 *JUMP 2552 5B JUMPDEST 2553 83 DUP4 2554 51 MLOAD 2555 90 SWAP1 2556 83 DUP4 2557 01 ADD 2558 90 SWAP1 2559 61 PUSH2 0x2566 255C 81 DUP2 255D 83 DUP4 255E 60 PUSH1 0x20 2560 88 DUP9 2561 01 ADD 2562 61 PUSH2 0x1f9e 2565 56 *JUMP 2566 5B JUMPDEST 2567 01 ADD 2568 94 SWAP5 2569 93 SWAP4 256A 50 POP 256B 50 POP 256C 50 POP 256D 50 POP 256E 56 *JUMP 256F 5B JUMPDEST 2570 60 PUSH1 0x01 2572 60 PUSH1 0x01 2574 60 PUSH1 0xa0 2576 1B SHL 2577 03 SUB 2578 85 DUP6 2579 81 DUP2 257A 16 AND 257B 82 DUP3 257C 52 MSTORE 257D 84 DUP5 257E 16 AND 257F 60 PUSH1 0x20 2581 82 DUP3 2582 01 ADD 2583 52 MSTORE 2584 60 PUSH1 0x40 2586 81 DUP2 2587 01 ADD 2588 83 DUP4 2589 90 SWAP1 258A 52 MSTORE 258B 60 PUSH1 0x80 258D 60 PUSH1 0x60 258F 82 DUP3 2590 01 ADD 2591 81 DUP2 2592 90 SWAP1 2593 52 MSTORE 2594 60 PUSH1 0x00 2596 90 SWAP1 2597 61 PUSH2 0x25a2 259A 90 SWAP1 259B 83 DUP4 259C 01 ADD 259D 84 DUP5 259E 61 PUSH2 0x1fc2 25A1 56 *JUMP 25A2 5B JUMPDEST 25A3 96 SWAP7 25A4 95 SWAP6 25A5 50 POP 25A6 50 POP 25A7 50 POP 25A8 50 POP 25A9 50 POP 25AA 50 POP 25AB 56 *JUMP 25AC 5B JUMPDEST 25AD 60 PUSH1 0x00 25AF 60 PUSH1 0x20 25B1 82 DUP3 25B2 84 DUP5 25B3 03 SUB 25B4 12 SLT 25B5 15 ISZERO 25B6 61 PUSH2 0x25be 25B9 57 *JUMPI 25BA 60 PUSH1 0x00 25BC 80 DUP1 25BD FD *REVERT 25BE 5B JUMPDEST 25BF 81 DUP2 25C0 51 MLOAD 25C1 61 PUSH2 0x1726 25C4 81 DUP2 25C5 61 PUSH2 0x1f34 25C8 56 *JUMP 25C9 FE *ASSERT 25CA A2 LOG2 25CB 64 PUSH5 0x6970667358 25D1 22 22 25D2 12 SLT 25D3 20 SHA3 25D4 BB BB 25D5 12 SLT 25D6 2F 2F 25D7 CA CA 25D8 00 *STOP 25D9 91 SWAP2 25DA C4 C4 25DB 78 PUSH25 0xf2154c91243ad6a8af54a011db1a97b20fe0d541ff5ee59064 25F5 73 PUSH20 0x6f6c63430008110033