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 0x02c8 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x02c8, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x6352211e 0019 11 GT 001A 61 PUSH2 0x0175 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0175, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xa22cb465 0024 11 GT 0025 61 PUSH2 0x00dc 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00dc, if 0xa22cb465 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xa22cb465 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xd547741f 002F 11 GT 0030 61 PUSH2 0x0095 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0095, if 0xd547741f > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xd547741f > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xe985e9c5 003A 11 GT 003B 61 PUSH2 0x006f 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xe985e9c5 > stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xe985e9c5 > stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe985e9c5 0045 14 EQ 0046 61 PUSH2 0x0902 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0902, if 0xe985e9c5 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xf2fde38b 0050 14 EQ 0051 61 PUSH2 0x0922 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0922, if 0xf2fde38b == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xfb796e6c 005B 14 EQ 005C 61 PUSH2 0x0942 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0942, if 0xfb796e6c == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xfb796e6c == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xff768212 0066 14 EQ 0067 61 PUSH2 0x095c 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x095c, if 0xff768212 == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xff768212 == stack[-1] // Inputs[1] { @006E memory[0x00:0x00] } 006B 60 PUSH1 0x00 006D 80 DUP1 006E FD *REVERT // Stack delta = +0 // Outputs[1] { @006E revert(memory[0x00:0x00]); } // Block terminates label_006F: // Incoming jump from 0x003E, if 0xe985e9c5 > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0xd547741f 0076 14 EQ 0077 61 PUSH2 0x088e 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x088e, if 0xd547741f == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xd547741f == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xdbe4613d 0081 14 EQ 0082 61 PUSH2 0x08ae 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08ae, if 0xdbe4613d == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xdbe4613d == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xe58306f9 008C 14 EQ 008D 61 PUSH2 0x08e2 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08e2, if 0xe58306f9 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xe58306f9 == stack[-1] // Inputs[1] { @0094 memory[0x00:0x00] } 0091 60 PUSH1 0x00 0093 80 DUP1 0094 FD *REVERT // Stack delta = +0 // Outputs[1] { @0094 revert(memory[0x00:0x00]); } // Block terminates label_0095: // Incoming jump from 0x0033, if 0xd547741f > stack[-1] // Inputs[1] { @0096 stack[-1] } 0095 5B JUMPDEST 0096 80 DUP1 0097 63 PUSH4 0xa22cb465 009C 14 EQ 009D 61 PUSH2 0x07db 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07db, if 0xa22cb465 == stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0xb7c0b8e8 00A7 14 EQ 00A8 61 PUSH2 0x07fb 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07fb, if 0xb7c0b8e8 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0xb7c0b8e8 == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0xb88d4fde 00B2 14 EQ 00B3 61 PUSH2 0x081b 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x081b, if 0xb88d4fde == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0xb88d4fde == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0xbabcc539 00BD 14 EQ 00BE 61 PUSH2 0x082e 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x082e, if 0xbabcc539 == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0xbabcc539 == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0xbc98a00f 00C8 14 EQ 00C9 61 PUSH2 0x084e 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x084e, if 0xbc98a00f == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0xbc98a00f == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0xc87b56dd 00D3 14 EQ 00D4 61 PUSH2 0x086e 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x086e, if 0xc87b56dd == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0xc87b56dd == stack[-1] // Inputs[1] { @00DB memory[0x00:0x00] } 00D8 60 PUSH1 0x00 00DA 80 DUP1 00DB FD *REVERT // Stack delta = +0 // Outputs[1] { @00DB revert(memory[0x00:0x00]); } // Block terminates label_00DC: // Incoming jump from 0x0028, if 0xa22cb465 > stack[-1] // Inputs[1] { @00DD stack[-1] } 00DC 5B JUMPDEST 00DD 80 DUP1 00DE 63 PUSH4 0x86e454eb 00E3 11 GT 00E4 61 PUSH2 0x012e 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x012e, if 0x86e454eb > stack[-1] label_00E8: // Incoming jump from 0x00E7, if not 0x86e454eb > stack[-1] // Inputs[1] { @00E8 stack[-1] } 00E8 80 DUP1 00E9 63 PUSH4 0x86e454eb 00EE 14 EQ 00EF 61 PUSH2 0x0733 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0733, if 0x86e454eb == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x86e454eb == stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F3 80 DUP1 00F4 63 PUSH4 0x8da5cb5b 00F9 14 EQ 00FA 61 PUSH2 0x0753 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0753, if 0x8da5cb5b == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0x91d14854 0104 14 EQ 0105 61 PUSH2 0x0771 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0771, if 0x91d14854 == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x91d14854 == stack[-1] // Inputs[1] { @0109 stack[-1] } 0109 80 DUP1 010A 63 PUSH4 0x95d89b41 010F 14 EQ 0110 61 PUSH2 0x0791 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0791, if 0x95d89b41 == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0114 stack[-1] } 0114 80 DUP1 0115 63 PUSH4 0x9c09628d 011A 14 EQ 011B 61 PUSH2 0x07a6 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07a6, if 0x9c09628d == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x9c09628d == stack[-1] // Inputs[1] { @011F stack[-1] } 011F 80 DUP1 0120 63 PUSH4 0xa217fddf 0125 14 EQ 0126 61 PUSH2 0x07c6 0129 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07c6, if 0xa217fddf == stack[-1] label_012A: // Incoming jump from 0x0129, if not 0xa217fddf == stack[-1] // Inputs[1] { @012D memory[0x00:0x00] } 012A 60 PUSH1 0x00 012C 80 DUP1 012D FD *REVERT // Stack delta = +0 // Outputs[1] { @012D revert(memory[0x00:0x00]); } // Block terminates label_012E: // Incoming jump from 0x00E7, if 0x86e454eb > stack[-1] // Inputs[1] { @012F stack[-1] } 012E 5B JUMPDEST 012F 80 DUP1 0130 63 PUSH4 0x6352211e 0135 14 EQ 0136 61 PUSH2 0x0676 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0676, if 0x6352211e == stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x6352211e == stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x669ee234 0140 14 EQ 0141 61 PUSH2 0x0696 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0696, if 0x669ee234 == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x669ee234 == stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x6d42ac7f 014B 14 EQ 014C 61 PUSH2 0x06b6 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06b6, if 0x6d42ac7f == stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x6d42ac7f == stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x70a08231 0156 14 EQ 0157 61 PUSH2 0x06de 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06de, if 0x70a08231 == stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x70a08231 == stack[-1] // Inputs[1] { @015B stack[-1] } 015B 80 DUP1 015C 63 PUSH4 0x715018a6 0161 14 EQ 0162 61 PUSH2 0x06fe 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06fe, if 0x715018a6 == stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x715018a6 == stack[-1] // Inputs[1] { @0166 stack[-1] } 0166 80 DUP1 0167 63 PUSH4 0x72b44d71 016C 14 EQ 016D 61 PUSH2 0x0713 0170 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0713, if 0x72b44d71 == stack[-1] label_0171: // Incoming jump from 0x0170, if not 0x72b44d71 == stack[-1] // Inputs[1] { @0174 memory[0x00:0x00] } 0171 60 PUSH1 0x00 0173 80 DUP1 0174 FD *REVERT // Stack delta = +0 // Outputs[1] { @0174 revert(memory[0x00:0x00]); } // Block terminates label_0175: // Incoming jump from 0x001D, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0176 stack[-1] } 0175 5B JUMPDEST 0176 80 DUP1 0177 63 PUSH4 0x23b872dd 017C 11 GT 017D 61 PUSH2 0x0234 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0234, if 0x23b872dd > stack[-1] label_0181: // Incoming jump from 0x0180, if not 0x23b872dd > stack[-1] // Inputs[1] { @0181 stack[-1] } 0181 80 DUP1 0182 63 PUSH4 0x32cb6b0c 0187 11 GT 0188 61 PUSH2 0x01ed 018B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ed, if 0x32cb6b0c > stack[-1] label_018C: // Incoming jump from 0x018B, if not 0x32cb6b0c > stack[-1] // Inputs[1] { @018C stack[-1] } 018C 80 DUP1 018D 63 PUSH4 0x42842e0e 0192 11 GT 0193 61 PUSH2 0x01c7 0196 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c7, if 0x42842e0e > stack[-1] label_0197: // Incoming jump from 0x0196, if not 0x42842e0e > stack[-1] // Inputs[1] { @0197 stack[-1] } 0197 80 DUP1 0198 63 PUSH4 0x42842e0e 019D 14 EQ 019E 61 PUSH2 0x05ef 01A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05ef, if 0x42842e0e == stack[-1] label_01A2: // Incoming jump from 0x01A1, if not 0x42842e0e == stack[-1] // Inputs[1] { @01A2 stack[-1] } 01A2 80 DUP1 01A3 63 PUSH4 0x4f3db346 01A8 14 EQ 01A9 61 PUSH2 0x0602 01AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0602, if 0x4f3db346 == stack[-1] label_01AD: // Incoming jump from 0x01AC, if not 0x4f3db346 == stack[-1] // Inputs[1] { @01AD stack[-1] } 01AD 80 DUP1 01AE 63 PUSH4 0x53ebf6bd 01B3 14 EQ 01B4 61 PUSH2 0x0636 01B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0636, if 0x53ebf6bd == stack[-1] label_01B8: // Incoming jump from 0x01B7, if not 0x53ebf6bd == stack[-1] // Inputs[1] { @01B8 stack[-1] } 01B8 80 DUP1 01B9 63 PUSH4 0x6137a96f 01BE 14 EQ 01BF 61 PUSH2 0x0656 01C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0656, if 0x6137a96f == stack[-1] label_01C3: // Incoming jump from 0x01C2, if not 0x6137a96f == stack[-1] // Inputs[1] { @01C6 memory[0x00:0x00] } 01C3 60 PUSH1 0x00 01C5 80 DUP1 01C6 FD *REVERT // Stack delta = +0 // Outputs[1] { @01C6 revert(memory[0x00:0x00]); } // Block terminates label_01C7: // Incoming jump from 0x0196, if 0x42842e0e > stack[-1] // Inputs[1] { @01C8 stack[-1] } 01C7 5B JUMPDEST 01C8 80 DUP1 01C9 63 PUSH4 0x32cb6b0c 01CE 14 EQ 01CF 61 PUSH2 0x057c 01D2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x057c, if 0x32cb6b0c == stack[-1] label_01D3: // Incoming jump from 0x01D2, if not 0x32cb6b0c == stack[-1] // Inputs[1] { @01D3 stack[-1] } 01D3 80 DUP1 01D4 63 PUSH4 0x36568abe 01D9 14 EQ 01DA 61 PUSH2 0x0592 01DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0592, if 0x36568abe == stack[-1] label_01DE: // Incoming jump from 0x01DD, if not 0x36568abe == stack[-1] // Inputs[1] { @01DE stack[-1] } 01DE 80 DUP1 01DF 63 PUSH4 0x396e8f53 01E4 14 EQ 01E5 61 PUSH2 0x05b2 01E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b2, if 0x396e8f53 == stack[-1] label_01E9: // Incoming jump from 0x01E8, if not 0x396e8f53 == stack[-1] // Inputs[1] { @01EC memory[0x00:0x00] } 01E9 60 PUSH1 0x00 01EB 80 DUP1 01EC FD *REVERT // Stack delta = +0 // Outputs[1] { @01EC revert(memory[0x00:0x00]); } // Block terminates label_01ED: // Incoming jump from 0x018B, if 0x32cb6b0c > stack[-1] // Inputs[1] { @01EE stack[-1] } 01ED 5B JUMPDEST 01EE 80 DUP1 01EF 63 PUSH4 0x23b872dd 01F4 14 EQ 01F5 61 PUSH2 0x0495 01F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0495, if 0x23b872dd == stack[-1] label_01F9: // Incoming jump from 0x01F8, if not 0x23b872dd == stack[-1] // Inputs[1] { @01F9 stack[-1] } 01F9 80 DUP1 01FA 63 PUSH4 0x248a9ca3 01FF 14 EQ 0200 61 PUSH2 0x04a8 0203 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a8, if 0x248a9ca3 == stack[-1] label_0204: // Incoming jump from 0x0203, if not 0x248a9ca3 == stack[-1] // Inputs[1] { @0204 stack[-1] } 0204 80 DUP1 0205 63 PUSH4 0x2a55205a 020A 14 EQ 020B 61 PUSH2 0x04d8 020E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d8, if 0x2a55205a == stack[-1] label_020F: // Incoming jump from 0x020E, if not 0x2a55205a == stack[-1] // Inputs[1] { @020F stack[-1] } 020F 80 DUP1 0210 63 PUSH4 0x2f2ff15d 0215 14 EQ 0216 61 PUSH2 0x0517 0219 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0517, if 0x2f2ff15d == stack[-1] label_021A: // Incoming jump from 0x0219, if not 0x2f2ff15d == stack[-1] // Inputs[1] { @021A stack[-1] } 021A 80 DUP1 021B 63 PUSH4 0x303e74df 0220 14 EQ 0221 61 PUSH2 0x0537 0224 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0537, if 0x303e74df == stack[-1] label_0225: // Incoming jump from 0x0224, if not 0x303e74df == stack[-1] // Inputs[1] { @0225 stack[-1] } 0225 80 DUP1 0226 63 PUSH4 0x324cb3cb 022B 14 EQ 022C 61 PUSH2 0x055d 022F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x055d, if 0x324cb3cb == stack[-1] label_0230: // Incoming jump from 0x022F, if not 0x324cb3cb == stack[-1] // Inputs[1] { @0233 memory[0x00:0x00] } 0230 60 PUSH1 0x00 0232 80 DUP1 0233 FD *REVERT // Stack delta = +0 // Outputs[1] { @0233 revert(memory[0x00:0x00]); } // Block terminates label_0234: // Incoming jump from 0x0180, if 0x23b872dd > stack[-1] // Inputs[1] { @0235 stack[-1] } 0234 5B JUMPDEST 0235 80 DUP1 0236 63 PUSH4 0x06fdde03 023B 11 GT 023C 61 PUSH2 0x0286 023F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0286, if 0x06fdde03 > stack[-1] label_0240: // Incoming jump from 0x023F, if not 0x06fdde03 > stack[-1] // Inputs[1] { @0240 stack[-1] } 0240 80 DUP1 0241 63 PUSH4 0x06fdde03 0246 14 EQ 0247 61 PUSH2 0x03aa 024A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03aa, if 0x06fdde03 == stack[-1] label_024B: // Incoming jump from 0x024A, if not 0x06fdde03 == stack[-1] // Inputs[1] { @024B stack[-1] } 024B 80 DUP1 024C 63 PUSH4 0x081812fc 0251 14 EQ 0252 61 PUSH2 0x03cc 0255 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03cc, if 0x081812fc == stack[-1] label_0256: // Incoming jump from 0x0255, if not 0x081812fc == stack[-1] // Inputs[1] { @0256 stack[-1] } 0256 80 DUP1 0257 63 PUSH4 0x095ea7b3 025C 14 EQ 025D 61 PUSH2 0x0404 0260 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0404, if 0x095ea7b3 == stack[-1] label_0261: // Incoming jump from 0x0260, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0261 stack[-1] } 0261 80 DUP1 0262 63 PUSH4 0x09849233 0267 14 EQ 0268 61 PUSH2 0x0417 026B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0417, if 0x09849233 == stack[-1] label_026C: // Incoming jump from 0x026B, if not 0x09849233 == stack[-1] // Inputs[1] { @026C stack[-1] } 026C 80 DUP1 026D 63 PUSH4 0x0f4345e2 0272 14 EQ 0273 61 PUSH2 0x044e 0276 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x044e, if 0x0f4345e2 == stack[-1] label_0277: // Incoming jump from 0x0276, if not 0x0f4345e2 == stack[-1] // Inputs[1] { @0277 stack[-1] } 0277 80 DUP1 0278 63 PUSH4 0x18160ddd 027D 14 EQ 027E 61 PUSH2 0x046e 0281 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x046e, if 0x18160ddd == stack[-1] label_0282: // Incoming jump from 0x0281, if not 0x18160ddd == stack[-1] // Inputs[1] { @0285 memory[0x00:0x00] } 0282 60 PUSH1 0x00 0284 80 DUP1 0285 FD *REVERT // Stack delta = +0 // Outputs[1] { @0285 revert(memory[0x00:0x00]); } // Block terminates label_0286: // Incoming jump from 0x023F, if 0x06fdde03 > stack[-1] // Inputs[1] { @0287 stack[-1] } 0286 5B JUMPDEST 0287 80 DUP1 0288 62 PUSH3 0x3f332f 028C 14 EQ 028D 61 PUSH2 0x02cd 0290 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02cd, if 0x3f332f == stack[-1] label_0291: // Incoming jump from 0x0290, if not 0x3f332f == stack[-1] // Inputs[1] { @0291 stack[-1] } 0291 80 DUP1 0292 63 PUSH4 0x018d9b50 0297 14 EQ 0298 61 PUSH2 0x02f8 029B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f8, if 0x018d9b50 == stack[-1] label_029C: // Incoming jump from 0x029B, if not 0x018d9b50 == stack[-1] // Inputs[1] { @029C stack[-1] } 029C 80 DUP1 029D 63 PUSH4 0x01b9a397 02A2 14 EQ 02A3 61 PUSH2 0x0328 02A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0328, if 0x01b9a397 == stack[-1] label_02A7: // Incoming jump from 0x02A6, if not 0x01b9a397 == stack[-1] // Inputs[1] { @02A7 stack[-1] } 02A7 80 DUP1 02A8 63 PUSH4 0x01ffc9a7 02AD 14 EQ 02AE 61 PUSH2 0x034a 02B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x034a, if 0x01ffc9a7 == stack[-1] label_02B2: // Incoming jump from 0x02B1, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @02B2 stack[-1] } 02B2 80 DUP1 02B3 63 PUSH4 0x025e332e 02B8 14 EQ 02B9 61 PUSH2 0x036a 02BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036a, if 0x025e332e == stack[-1] label_02BD: // Incoming jump from 0x02BC, if not 0x025e332e == stack[-1] // Inputs[1] { @02BD stack[-1] } 02BD 80 DUP1 02BE 63 PUSH4 0x04634d8d 02C3 14 EQ 02C4 61 PUSH2 0x038a 02C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x038a, if 0x04634d8d == stack[-1] label_02C8: // Incoming jump from 0x02C7, if not 0x04634d8d == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @02CC memory[0x00:0x00] } 02C8 5B JUMPDEST 02C9 60 PUSH1 0x00 02CB 80 DUP1 02CC FD *REVERT // Stack delta = +0 // Outputs[1] { @02CC revert(memory[0x00:0x00]); } // Block terminates label_02CD: // Incoming jump from 0x0290, if 0x3f332f == stack[-1] // Inputs[1] { @02CE msg.value } 02CD 5B JUMPDEST 02CE 34 CALLVALUE 02CF 80 DUP1 02D0 15 ISZERO 02D1 61 PUSH2 0x02d9 02D4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02CE stack[0] = msg.value } // Block ends with conditional jump to 0x02d9, if !msg.value label_02D5: // Incoming jump from 0x02D4, if not !msg.value // Inputs[1] { @02D8 memory[0x00:0x00] } 02D5 60 PUSH1 0x00 02D7 80 DUP1 02D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D8 revert(memory[0x00:0x00]); } // Block terminates label_02D9: // Incoming jump from 0x02D4, if !msg.value 02D9 5B JUMPDEST 02DA 50 POP 02DB 61 PUSH2 0x02e2 02DE 61 PUSH2 0x097c 02E1 56 *JUMP // Stack delta = +0 // Outputs[1] { @02DB stack[-1] = 0x02e2 } // Block ends with call to 0x097c, returns to 0x02E2 label_02E2: // Incoming return from call to 0x097C at 0x02E1 // Inputs[2] // { // @02E5 memory[0x40:0x60] // @02E9 stack[-1] // } 02E2 5B JUMPDEST 02E3 60 PUSH1 0x40 02E5 51 MLOAD 02E6 61 PUSH2 0x02ef 02E9 91 SWAP2 02EA 90 SWAP1 02EB 61 PUSH2 0x23cc 02EE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02E9 stack[-1] = 0x02ef // @02EA stack[1] = memory[0x40:0x60] // @02EA stack[0] = stack[-1] // } // Block ends with call to 0x23cc, returns to 0x02EF label_02EF: // Incoming return from call to 0x23CC at 0x02EE // Incoming jump from 0x0494 // Incoming jump from 0x0327 // Incoming jump from 0x0403 // Incoming return from call to 0x2513 at 0x03CB // Incoming jump from 0x0494 // Incoming jump from 0x0516 // Inputs[3] // { // @02F2 memory[0x40:0x60] // @02F4 stack[-1] // @02F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 02EF 5B JUMPDEST 02F0 60 PUSH1 0x40 02F2 51 MLOAD 02F3 80 DUP1 02F4 91 SWAP2 02F5 03 SUB 02F6 90 SWAP1 02F7 F3 *RETURN // Stack delta = -1 // Outputs[1] { @02F7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02F8: // Incoming jump from 0x029B, if 0x018d9b50 == stack[-1] // Inputs[1] { @02F9 msg.value } 02F8 5B JUMPDEST 02F9 34 CALLVALUE 02FA 80 DUP1 02FB 15 ISZERO 02FC 61 PUSH2 0x0304 02FF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F9 stack[0] = msg.value } // Block ends with conditional jump to 0x0304, if !msg.value label_0300: // Incoming jump from 0x02FF, if not !msg.value // Inputs[1] { @0303 memory[0x00:0x00] } 0300 60 PUSH1 0x00 0302 80 DUP1 0303 FD *REVERT // Stack delta = +0 // Outputs[1] { @0303 revert(memory[0x00:0x00]); } // Block terminates label_0304: // Incoming jump from 0x02FF, if !msg.value // Inputs[1] { @030C msg.data.length } 0304 5B JUMPDEST 0305 50 POP 0306 61 PUSH2 0x0318 0309 61 PUSH2 0x0313 030C 36 CALLDATASIZE 030D 60 PUSH1 0x04 030F 61 PUSH2 0x242e 0312 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0306 stack[-1] = 0x0318 // @0309 stack[0] = 0x0313 // @030C stack[1] = msg.data.length // @030D stack[2] = 0x04 // } // Block ends with call to 0x242e, returns to 0x0313 label_0313: // Incoming return from call to 0x242E at 0x0312 0313 5B JUMPDEST 0314 61 PUSH2 0x099a 0317 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x099a label_0318: // Incoming return from call to 0x0365 at 0x0364 // Incoming return from call to 0x0313 at 0x0312 // Incoming return from call to 0x0849 at 0x0848 // Incoming return from call to 0x0849 at 0x0848 // Incoming jump from 0x044D // Incoming return from call to 0x078C at 0x078B // Incoming jump from 0x057B // Incoming jump from 0x095B // Inputs[2] // { // @031B memory[0x40:0x60] // @031C stack[-1] // } 0318 5B JUMPDEST 0319 60 PUSH1 0x40 031B 51 MLOAD 031C 90 SWAP1 031D 15 ISZERO 031E 15 ISZERO 031F 81 DUP2 0320 52 MSTORE 0321 60 PUSH1 0x20 0323 01 ADD 0324 61 PUSH2 0x02ef 0327 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0320 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0323 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02ef label_0328: // Incoming jump from 0x02A6, if 0x01b9a397 == stack[-1] // Inputs[1] { @0329 msg.value } 0328 5B JUMPDEST 0329 34 CALLVALUE 032A 80 DUP1 032B 15 ISZERO 032C 61 PUSH2 0x0334 032F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0329 stack[0] = msg.value } // Block ends with conditional jump to 0x0334, if !msg.value label_0330: // Incoming jump from 0x032F, if not !msg.value // Inputs[1] { @0333 memory[0x00:0x00] } 0330 60 PUSH1 0x00 0332 80 DUP1 0333 FD *REVERT // Stack delta = +0 // Outputs[1] { @0333 revert(memory[0x00:0x00]); } // Block terminates label_0334: // Incoming jump from 0x032F, if !msg.value // Inputs[1] { @033C msg.data.length } 0334 5B JUMPDEST 0335 50 POP 0336 61 PUSH2 0x0348 0339 61 PUSH2 0x0343 033C 36 CALLDATASIZE 033D 60 PUSH1 0x04 033F 61 PUSH2 0x242e 0342 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0336 stack[-1] = 0x0348 // @0339 stack[0] = 0x0343 // @033C stack[1] = msg.data.length // @033D stack[2] = 0x04 // } // Block ends with call to 0x242e, returns to 0x0343 label_0343: // Incoming return from call to 0x242E at 0x0342 0343 5B JUMPDEST 0344 61 PUSH2 0x09ba 0347 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09ba label_0348: // Incoming return from call to 0x0816 at 0x0815 // Incoming return from call to 0x06B1 at 0x06B0 // Incoming return from call to 0x03A5 at 0x03A4 // Incoming return from call to 0x0343 at 0x0342 // Incoming return from call to 0x07C1 at 0x07C0 // Incoming return from call to 0x0671 at 0x0670 // Incoming return from call to 0x0412 at 0x0411 // Incoming return from call to 0x0385 at 0x0384 // Incoming return from call to 0x05AD at 0x05AC // Incoming return from call to 0x0651 at 0x0650 0348 5B JUMPDEST 0349 00 *STOP // Stack delta = +0 // Outputs[1] { @0349 stop(); } // Block terminates label_034A: // Incoming jump from 0x02B1, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @034B msg.value } 034A 5B JUMPDEST 034B 34 CALLVALUE 034C 80 DUP1 034D 15 ISZERO 034E 61 PUSH2 0x0356 0351 57 *JUMPI // Stack delta = +1 // Outputs[1] { @034B stack[0] = msg.value } // Block ends with conditional jump to 0x0356, if !msg.value label_0352: // Incoming jump from 0x0351, if not !msg.value // Inputs[1] { @0355 memory[0x00:0x00] } 0352 60 PUSH1 0x00 0354 80 DUP1 0355 FD *REVERT // Stack delta = +0 // Outputs[1] { @0355 revert(memory[0x00:0x00]); } // Block terminates label_0356: // Incoming jump from 0x0351, if !msg.value // Inputs[1] { @035E msg.data.length } 0356 5B JUMPDEST 0357 50 POP 0358 61 PUSH2 0x0318 035B 61 PUSH2 0x0365 035E 36 CALLDATASIZE 035F 60 PUSH1 0x04 0361 61 PUSH2 0x2461 0364 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0358 stack[-1] = 0x0318 // @035B stack[0] = 0x0365 // @035E stack[1] = msg.data.length // @035F stack[2] = 0x04 // } // Block ends with call to 0x2461, returns to 0x0365 label_0365: // Incoming return from call to 0x2461 at 0x0364 0365 5B JUMPDEST 0366 61 PUSH2 0x0a0c 0369 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a0c label_036A: // Incoming jump from 0x02BC, if 0x025e332e == stack[-1] // Inputs[1] { @036B msg.value } 036A 5B JUMPDEST 036B 34 CALLVALUE 036C 80 DUP1 036D 15 ISZERO 036E 61 PUSH2 0x0376 0371 57 *JUMPI // Stack delta = +1 // Outputs[1] { @036B stack[0] = msg.value } // Block ends with conditional jump to 0x0376, if !msg.value label_0372: // Incoming jump from 0x0371, if not !msg.value // Inputs[1] { @0375 memory[0x00:0x00] } 0372 60 PUSH1 0x00 0374 80 DUP1 0375 FD *REVERT // Stack delta = +0 // Outputs[1] { @0375 revert(memory[0x00:0x00]); } // Block terminates label_0376: // Incoming jump from 0x0371, if !msg.value // Inputs[1] { @037E msg.data.length } 0376 5B JUMPDEST 0377 50 POP 0378 61 PUSH2 0x0348 037B 61 PUSH2 0x0385 037E 36 CALLDATASIZE 037F 60 PUSH1 0x04 0381 61 PUSH2 0x242e 0384 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0378 stack[-1] = 0x0348 // @037B stack[0] = 0x0385 // @037E stack[1] = msg.data.length // @037F stack[2] = 0x04 // } // Block ends with call to 0x242e, returns to 0x0385 label_0385: // Incoming return from call to 0x242E at 0x0384 0385 5B JUMPDEST 0386 61 PUSH2 0x0a6b 0389 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a6b label_038A: // Incoming jump from 0x02C7, if 0x04634d8d == stack[-1] // Inputs[1] { @038B msg.value } 038A 5B JUMPDEST 038B 34 CALLVALUE 038C 80 DUP1 038D 15 ISZERO 038E 61 PUSH2 0x0396 0391 57 *JUMPI // Stack delta = +1 // Outputs[1] { @038B stack[0] = msg.value } // Block ends with conditional jump to 0x0396, if !msg.value label_0392: // Incoming jump from 0x0391, if not !msg.value // Inputs[1] { @0395 memory[0x00:0x00] } 0392 60 PUSH1 0x00 0394 80 DUP1 0395 FD *REVERT // Stack delta = +0 // Outputs[1] { @0395 revert(memory[0x00:0x00]); } // Block terminates label_0396: // Incoming jump from 0x0391, if !msg.value // Inputs[1] { @039E msg.data.length } 0396 5B JUMPDEST 0397 50 POP 0398 61 PUSH2 0x0348 039B 61 PUSH2 0x03a5 039E 36 CALLDATASIZE 039F 60 PUSH1 0x04 03A1 61 PUSH2 0x247e 03A4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0398 stack[-1] = 0x0348 // @039B stack[0] = 0x03a5 // @039E stack[1] = msg.data.length // @039F stack[2] = 0x04 // } // Block ends with call to 0x247e, returns to 0x03A5 label_03A5: // Incoming return from call to 0x247E at 0x03A4 03A5 5B JUMPDEST 03A6 61 PUSH2 0x0ad3 03A9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ad3 label_03AA: // Incoming jump from 0x024A, if 0x06fdde03 == stack[-1] // Inputs[1] { @03AB msg.value } 03AA 5B JUMPDEST 03AB 34 CALLVALUE 03AC 80 DUP1 03AD 15 ISZERO 03AE 61 PUSH2 0x03b6 03B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03AB stack[0] = msg.value } // Block ends with conditional jump to 0x03b6, if !msg.value label_03B2: // Incoming jump from 0x03B1, if not !msg.value // Inputs[1] { @03B5 memory[0x00:0x00] } 03B2 60 PUSH1 0x00 03B4 80 DUP1 03B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @03B5 revert(memory[0x00:0x00]); } // Block terminates label_03B6: // Incoming jump from 0x03B1, if !msg.value 03B6 5B JUMPDEST 03B7 50 POP 03B8 61 PUSH2 0x03bf 03BB 61 PUSH2 0x0b09 03BE 56 *JUMP // Stack delta = +0 // Outputs[1] { @03B8 stack[-1] = 0x03bf } // Block ends with call to 0x0b09, returns to 0x03BF label_03BF: // Incoming return from call to 0x0B09 at 0x03BE // Incoming return from call to 0x1007 at 0x07A5 // Inputs[2] // { // @03C2 memory[0x40:0x60] // @03C6 stack[-1] // } 03BF 5B JUMPDEST 03C0 60 PUSH1 0x40 03C2 51 MLOAD 03C3 61 PUSH2 0x02ef 03C6 91 SWAP2 03C7 90 SWAP1 03C8 61 PUSH2 0x2513 03CB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @03C6 stack[-1] = 0x02ef // @03C7 stack[1] = memory[0x40:0x60] // @03C7 stack[0] = stack[-1] // } // Block ends with call to 0x2513, returns to 0x02EF label_03CC: // Incoming jump from 0x0255, if 0x081812fc == stack[-1] // Inputs[1] { @03CD msg.value } 03CC 5B JUMPDEST 03CD 34 CALLVALUE 03CE 80 DUP1 03CF 15 ISZERO 03D0 61 PUSH2 0x03d8 03D3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03CD stack[0] = msg.value } // Block ends with conditional jump to 0x03d8, if !msg.value label_03D4: // Incoming jump from 0x03D3, if not !msg.value // Inputs[1] { @03D7 memory[0x00:0x00] } 03D4 60 PUSH1 0x00 03D6 80 DUP1 03D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D7 revert(memory[0x00:0x00]); } // Block terminates label_03D8: // Incoming jump from 0x03D3, if !msg.value // Inputs[1] { @03E0 msg.data.length } 03D8 5B JUMPDEST 03D9 50 POP 03DA 61 PUSH2 0x03ec 03DD 61 PUSH2 0x03e7 03E0 36 CALLDATASIZE 03E1 60 PUSH1 0x04 03E3 61 PUSH2 0x2526 03E6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03DA stack[-1] = 0x03ec // @03DD stack[0] = 0x03e7 // @03E0 stack[1] = msg.data.length // @03E1 stack[2] = 0x04 // } // Block ends with call to 0x2526, returns to 0x03E7 label_03E7: // Incoming return from call to 0x2526 at 0x03E6 03E7 5B JUMPDEST 03E8 61 PUSH2 0x0b9b 03EB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b9b label_03EC: // Incoming jump from 0x06DD // Incoming jump from 0x055C // Incoming jump from 0x05EE // Incoming return from call to 0x03E7 at 0x03E6 // Incoming return from call to 0x03E7 at 0x03E6 // Incoming return from call to 0x0691 at 0x0690 // Incoming jump from 0x0770 // Inputs[2] // { // @03EF memory[0x40:0x60] // @03F9 stack[-1] // } 03EC 5B JUMPDEST 03ED 60 PUSH1 0x40 03EF 51 MLOAD 03F0 60 PUSH1 0x01 03F2 60 PUSH1 0x01 03F4 60 PUSH1 0xa0 03F6 1B SHL 03F7 03 SUB 03F8 90 SWAP1 03F9 91 SWAP2 03FA 16 AND 03FB 81 DUP2 03FC 52 MSTORE 03FD 60 PUSH1 0x20 03FF 01 ADD 0400 61 PUSH2 0x02ef 0403 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03FC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @03FF stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02ef label_0404: // Incoming jump from 0x0260, if 0x095ea7b3 == stack[-1] // Inputs[1] { @040B msg.data.length } 0404 5B JUMPDEST 0405 61 PUSH2 0x0348 0408 61 PUSH2 0x0412 040B 36 CALLDATASIZE 040C 60 PUSH1 0x04 040E 61 PUSH2 0x253f 0411 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0405 stack[0] = 0x0348 // @0408 stack[1] = 0x0412 // @040B stack[2] = msg.data.length // @040C stack[3] = 0x04 // } // Block ends with call to 0x253f, returns to 0x0412 label_0412: // Incoming return from call to 0x253F at 0x0411 0412 5B JUMPDEST 0413 61 PUSH2 0x0bbf 0416 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bbf label_0417: // Incoming jump from 0x026B, if 0x09849233 == stack[-1] // Inputs[1] { @0418 msg.value } 0417 5B JUMPDEST 0418 34 CALLVALUE 0419 80 DUP1 041A 15 ISZERO 041B 61 PUSH2 0x0423 041E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0418 stack[0] = msg.value } // Block ends with conditional jump to 0x0423, if !msg.value label_041F: // Incoming jump from 0x041E, if not !msg.value // Inputs[1] { @0422 memory[0x00:0x00] } 041F 60 PUSH1 0x00 0421 80 DUP1 0422 FD *REVERT // Stack delta = +0 // Outputs[1] { @0422 revert(memory[0x00:0x00]); } // Block terminates label_0423: // Incoming jump from 0x041E, if !msg.value // Inputs[1] { @0446 storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a620] } 0423 5B JUMPDEST 0424 50 POP 0425 7F PUSH32 0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a620 0446 54 SLOAD 0447 60 PUSH1 0xff 0449 16 AND 044A 61 PUSH2 0x0318 044D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0449 stack[-1] = 0xff & storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a620] } // Block ends with unconditional jump to 0x0318 label_044E: // Incoming jump from 0x0276, if 0x0f4345e2 == stack[-1] // Inputs[1] { @044F msg.value } 044E 5B JUMPDEST 044F 34 CALLVALUE 0450 80 DUP1 0451 15 ISZERO 0452 61 PUSH2 0x045a 0455 57 *JUMPI // Stack delta = +1 // Outputs[1] { @044F stack[0] = msg.value } // Block ends with conditional jump to 0x045a, if !msg.value label_0456: // Incoming jump from 0x0455, if not !msg.value // Inputs[1] { @0459 memory[0x00:0x00] } 0456 60 PUSH1 0x00 0458 80 DUP1 0459 FD *REVERT // Stack delta = +0 // Outputs[1] { @0459 revert(memory[0x00:0x00]); } // Block terminates label_045A: // Incoming jump from 0x0455, if !msg.value // Inputs[1] { @0462 msg.data.length } 045A 5B JUMPDEST 045B 50 POP 045C 61 PUSH2 0x0348 045F 61 PUSH2 0x0469 0462 36 CALLDATASIZE 0463 60 PUSH1 0x04 0465 61 PUSH2 0x2526 0468 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @045C stack[-1] = 0x0348 // @045F stack[0] = 0x0469 // @0462 stack[1] = msg.data.length // @0463 stack[2] = 0x04 // } // Block ends with call to 0x2526, returns to 0x0469 label_0469: // Incoming return from call to 0x2526 at 0x0468 0469 5B JUMPDEST 046A 61 PUSH2 0x0c3e 046D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c3e label_046E: // Incoming jump from 0x0281, if 0x18160ddd == stack[-1] // Inputs[1] { @046F msg.value } 046E 5B JUMPDEST 046F 34 CALLVALUE 0470 80 DUP1 0471 15 ISZERO 0472 61 PUSH2 0x047a 0475 57 *JUMPI // Stack delta = +1 // Outputs[1] { @046F stack[0] = msg.value } // Block ends with conditional jump to 0x047a, if !msg.value label_0476: // Incoming jump from 0x0475, if not !msg.value // Inputs[1] { @0479 memory[0x00:0x00] } 0476 60 PUSH1 0x00 0478 80 DUP1 0479 FD *REVERT // Stack delta = +0 // Outputs[1] { @0479 revert(memory[0x00:0x00]); } // Block terminates label_047A: // Incoming jump from 0x0475, if !msg.value // Inputs[3] // { // @047E storage[0x01] // @0481 storage[0x00] // @048A memory[0x40:0x60] // } 047A 5B JUMPDEST 047B 50 POP 047C 60 PUSH1 0x01 047E 54 SLOAD 047F 60 PUSH1 0x00 0481 54 SLOAD 0482 03 SUB 0483 60 PUSH1 0x00 0485 19 NOT 0486 01 ADD 0487 5B JUMPDEST 0488 60 PUSH1 0x40 048A 51 MLOAD 048B 90 SWAP1 048C 81 DUP2 048D 52 MSTORE 048E 60 PUSH1 0x20 0490 01 ADD 0491 61 PUSH2 0x02ef 0494 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @048D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0x00 + (storage[0x00] - storage[0x01]) // @0490 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02ef label_0495: // Incoming jump from 0x01F8, if 0x23b872dd == stack[-1] // Inputs[1] { @049C msg.data.length } 0495 5B JUMPDEST 0496 61 PUSH2 0x0348 0499 61 PUSH2 0x04a3 049C 36 CALLDATASIZE 049D 60 PUSH1 0x04 049F 61 PUSH2 0x256b 04A2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0496 stack[0] = 0x0348 // @0499 stack[1] = 0x04a3 // @049C stack[2] = msg.data.length // @049D stack[3] = 0x04 // } // Block ends with call to 0x256b, returns to 0x04A3 label_04A3: // Incoming return from call to 0x256B at 0x04A2 04A3 5B JUMPDEST 04A4 61 PUSH2 0x0c6f 04A7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c6f label_04A8: // Incoming jump from 0x0203, if 0x248a9ca3 == stack[-1] // Inputs[1] { @04A9 msg.value } 04A8 5B JUMPDEST 04A9 34 CALLVALUE 04AA 80 DUP1 04AB 15 ISZERO 04AC 61 PUSH2 0x04b4 04AF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04A9 stack[0] = msg.value } // Block ends with conditional jump to 0x04b4, if !msg.value label_04B0: // Incoming jump from 0x04AF, if not !msg.value // Inputs[1] { @04B3 memory[0x00:0x00] } 04B0 60 PUSH1 0x00 04B2 80 DUP1 04B3 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B3 revert(memory[0x00:0x00]); } // Block terminates label_04B4: // Incoming jump from 0x04AF, if !msg.value // Inputs[1] { @04BC msg.data.length } 04B4 5B JUMPDEST 04B5 50 POP 04B6 61 PUSH2 0x0487 04B9 61 PUSH2 0x04c3 04BC 36 CALLDATASIZE 04BD 60 PUSH1 0x04 04BF 61 PUSH2 0x2526 04C2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04B6 stack[-1] = 0x0487 // @04B9 stack[0] = 0x04c3 // @04BC stack[1] = msg.data.length // @04BD stack[2] = 0x04 // } // Block ends with call to 0x2526, returns to 0x04C3 label_04C3: // Incoming return from call to 0x2526 at 0x04C2 // Inputs[4] // { // @04C6 stack[-1] // @04D1 memory[0x00:0x40] // @04D5 storage[0x01 + keccak256(memory[0x00:0x40])] // @04D6 stack[-2] // } 04C3 5B JUMPDEST 04C4 60 PUSH1 0x00 04C6 90 SWAP1 04C7 81 DUP2 04C8 52 MSTORE 04C9 60 PUSH1 0x09 04CB 60 PUSH1 0x20 04CD 52 MSTORE 04CE 60 PUSH1 0x40 04D0 90 SWAP1 04D1 20 SHA3 04D2 60 PUSH1 0x01 04D4 01 ADD 04D5 54 SLOAD 04D6 90 SWAP1 04D7 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @04C8 memory[0x00:0x20] = stack[-1] // @04CD memory[0x20:0x40] = 0x09 // @04D6 stack[-2] = storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_04D8: // Incoming jump from 0x020E, if 0x2a55205a == stack[-1] // Inputs[1] { @04D9 msg.value } 04D8 5B JUMPDEST 04D9 34 CALLVALUE 04DA 80 DUP1 04DB 15 ISZERO 04DC 61 PUSH2 0x04e4 04DF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D9 stack[0] = msg.value } // Block ends with conditional jump to 0x04e4, if !msg.value label_04E0: // Incoming jump from 0x04DF, if not !msg.value // Inputs[1] { @04E3 memory[0x00:0x00] } 04E0 60 PUSH1 0x00 04E2 80 DUP1 04E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @04E3 revert(memory[0x00:0x00]); } // Block terminates label_04E4: // Incoming jump from 0x04DF, if !msg.value // Inputs[1] { @04EC msg.data.length } 04E4 5B JUMPDEST 04E5 50 POP 04E6 61 PUSH2 0x04f8 04E9 61 PUSH2 0x04f3 04EC 36 CALLDATASIZE 04ED 60 PUSH1 0x04 04EF 61 PUSH2 0x25ac 04F2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04E6 stack[-1] = 0x04f8 // @04E9 stack[0] = 0x04f3 // @04EC stack[1] = msg.data.length // @04ED stack[2] = 0x04 // } // Block ends with call to 0x25ac, returns to 0x04F3 label_04F3: // Incoming return from call to 0x25AC at 0x04F2 04F3 5B JUMPDEST 04F4 61 PUSH2 0x0ce9 04F7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ce9 label_04F8: // Incoming return from call to 0x04F3 at 0x04F2 // Inputs[3] // { // @04FC memory[0x40:0x60] // @0506 stack[-2] // @050E stack[-1] // } 04F8 5B JUMPDEST 04F9 60 PUSH1 0x40 04FB 80 DUP1 04FC 51 MLOAD 04FD 60 PUSH1 0x01 04FF 60 PUSH1 0x01 0501 60 PUSH1 0xa0 0503 1B SHL 0504 03 SUB 0505 90 SWAP1 0506 93 SWAP4 0507 16 AND 0508 83 DUP4 0509 52 MSTORE 050A 60 PUSH1 0x20 050C 83 DUP4 050D 01 ADD 050E 91 SWAP2 050F 90 SWAP1 0510 91 SWAP2 0511 52 MSTORE 0512 01 ADD 0513 61 PUSH2 0x02ef 0516 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0509 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0511 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @0512 stack[-2] = 0x40 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02ef label_0517: // Incoming jump from 0x0219, if 0x2f2ff15d == stack[-1] // Inputs[1] { @0518 msg.value } 0517 5B JUMPDEST 0518 34 CALLVALUE 0519 80 DUP1 051A 15 ISZERO 051B 61 PUSH2 0x0523 051E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0518 stack[0] = msg.value } // Block ends with conditional jump to 0x0523, if !msg.value label_051F: // Incoming jump from 0x051E, if not !msg.value // Inputs[1] { @0522 memory[0x00:0x00] } 051F 60 PUSH1 0x00 0521 80 DUP1 0522 FD *REVERT // Stack delta = +0 // Outputs[1] { @0522 revert(memory[0x00:0x00]); } // Block terminates label_0523: // Incoming jump from 0x051E, if !msg.value // Inputs[1] { @052B msg.data.length } 0523 5B JUMPDEST 0524 50 POP 0525 61 PUSH2 0x0348 0528 61 PUSH2 0x0532 052B 36 CALLDATASIZE 052C 60 PUSH1 0x04 052E 61 PUSH2 0x25ce 0531 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0525 stack[-1] = 0x0348 // @0528 stack[0] = 0x0532 // @052B stack[1] = msg.data.length // @052C stack[2] = 0x04 // } // Block ends with call to 0x25ce, returns to 0x0532 label_0532: // Incoming return from call to 0x25CE at 0x0531 0532 5B JUMPDEST 0533 61 PUSH2 0x0d46 0536 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d46 label_0537: // Incoming jump from 0x0224, if 0x303e74df == stack[-1] // Inputs[1] { @0538 msg.value } 0537 5B JUMPDEST 0538 34 CALLVALUE 0539 80 DUP1 053A 15 ISZERO 053B 61 PUSH2 0x0543 053E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0538 stack[0] = msg.value } // Block ends with conditional jump to 0x0543, if !msg.value label_053F: // Incoming jump from 0x053E, if not !msg.value // Inputs[1] { @0542 memory[0x00:0x00] } 053F 60 PUSH1 0x00 0541 80 DUP1 0542 FD *REVERT // Stack delta = +0 // Outputs[1] { @0542 revert(memory[0x00:0x00]); } // Block terminates label_0543: // Incoming jump from 0x053E, if !msg.value // Inputs[1] { @0547 storage[0x0b] } 0543 5B JUMPDEST 0544 50 POP 0545 60 PUSH1 0x0b 0547 54 SLOAD 0548 61 PUSH2 0x03ec 054B 90 SWAP1 054C 62 PUSH3 0x010000 0550 90 SWAP1 0551 04 DIV 0552 60 PUSH1 0x01 0554 60 PUSH1 0x01 0556 60 PUSH1 0xa0 0558 1B SHL 0559 03 SUB 055A 16 AND 055B 81 DUP2 055C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @054B stack[-1] = 0x03ec // @055A stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0b] / 0x010000 // } // Block ends with unconditional jump to 0x03ec label_055D: // Incoming jump from 0x022F, if 0x324cb3cb == stack[-1] // Inputs[1] { @055E msg.value } 055D 5B JUMPDEST 055E 34 CALLVALUE 055F 80 DUP1 0560 15 ISZERO 0561 61 PUSH2 0x0569 0564 57 *JUMPI // Stack delta = +1 // Outputs[1] { @055E stack[0] = msg.value } // Block ends with conditional jump to 0x0569, if !msg.value label_0565: // Incoming jump from 0x0564, if not !msg.value // Inputs[1] { @0568 memory[0x00:0x00] } 0565 60 PUSH1 0x00 0567 80 DUP1 0568 FD *REVERT // Stack delta = +0 // Outputs[1] { @0568 revert(memory[0x00:0x00]); } // Block terminates label_0569: // Incoming jump from 0x0564, if !msg.value // Inputs[1] { @056D storage[0x0b] } 0569 5B JUMPDEST 056A 50 POP 056B 60 PUSH1 0x0b 056D 54 SLOAD 056E 61 PUSH2 0x0318 0571 90 SWAP1 0572 61 PUSH2 0x0100 0575 90 SWAP1 0576 04 DIV 0577 60 PUSH1 0xff 0579 16 AND 057A 81 DUP2 057B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0571 stack[-1] = 0x0318 // @0579 stack[0] = 0xff & storage[0x0b] / 0x0100 // } // Block ends with unconditional jump to 0x0318 label_057C: // Incoming jump from 0x01D2, if 0x32cb6b0c == stack[-1] // Inputs[1] { @057D msg.value } 057C 5B JUMPDEST 057D 34 CALLVALUE 057E 80 DUP1 057F 15 ISZERO 0580 61 PUSH2 0x0588 0583 57 *JUMPI // Stack delta = +1 // Outputs[1] { @057D stack[0] = msg.value } // Block ends with conditional jump to 0x0588, if !msg.value label_0584: // Incoming jump from 0x0583, if not !msg.value // Inputs[1] { @0587 memory[0x00:0x00] } 0584 60 PUSH1 0x00 0586 80 DUP1 0587 FD *REVERT // Stack delta = +0 // Outputs[1] { @0587 revert(memory[0x00:0x00]); } // Block terminates label_0588: // Incoming jump from 0x0583, if !msg.value 0588 5B JUMPDEST 0589 50 POP 058A 61 PUSH2 0x0487 058D 61 PUSH2 0x0bb8 0590 81 DUP2 0591 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @058A stack[-1] = 0x0487 // @058D stack[0] = 0x0bb8 // } // Block ends with unconditional jump to 0x0487 label_0592: // Incoming jump from 0x01DD, if 0x36568abe == 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 0x0348 05A3 61 PUSH2 0x05ad 05A6 36 CALLDATASIZE 05A7 60 PUSH1 0x04 05A9 61 PUSH2 0x25ce 05AC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05A0 stack[-1] = 0x0348 // @05A3 stack[0] = 0x05ad // @05A6 stack[1] = msg.data.length // @05A7 stack[2] = 0x04 // } // Block ends with call to 0x25ce, returns to 0x05AD label_05AD: // Incoming return from call to 0x25CE at 0x05AC 05AD 5B JUMPDEST 05AE 61 PUSH2 0x0d70 05B1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d70 label_05B2: // Incoming jump from 0x01E8, if 0x396e8f53 == 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] { @05E1 storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a61d] } 05BE 5B JUMPDEST 05BF 50 POP 05C0 7F PUSH32 0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a61d 05E1 54 SLOAD 05E2 60 PUSH1 0x01 05E4 60 PUSH1 0x01 05E6 60 PUSH1 0xa0 05E8 1B SHL 05E9 03 SUB 05EA 16 AND 05EB 61 PUSH2 0x03ec 05EE 56 *JUMP // Stack delta = +0 // Outputs[1] { @05EA stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a61d] } // Block ends with unconditional jump to 0x03ec label_05EF: // Incoming jump from 0x01A1, if 0x42842e0e == stack[-1] // Inputs[1] { @05F6 msg.data.length } 05EF 5B JUMPDEST 05F0 61 PUSH2 0x0348 05F3 61 PUSH2 0x05fd 05F6 36 CALLDATASIZE 05F7 60 PUSH1 0x04 05F9 61 PUSH2 0x256b 05FC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05F0 stack[0] = 0x0348 // @05F3 stack[1] = 0x05fd // @05F6 stack[2] = msg.data.length // @05F7 stack[3] = 0x04 // } // Block ends with call to 0x256b, returns to 0x05FD label_05FD: // Incoming return from call to 0x256B at 0x05FC 05FD 5B JUMPDEST 05FE 61 PUSH2 0x0def 0601 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0def label_0602: // Incoming jump from 0x01AC, if 0x4f3db346 == stack[-1] // Inputs[1] { @0603 msg.value } 0602 5B JUMPDEST 0603 34 CALLVALUE 0604 80 DUP1 0605 15 ISZERO 0606 61 PUSH2 0x060e 0609 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0603 stack[0] = msg.value } // Block ends with conditional jump to 0x060e, if !msg.value label_060A: // Incoming jump from 0x0609, if not !msg.value // Inputs[1] { @060D memory[0x00:0x00] } 060A 60 PUSH1 0x00 060C 80 DUP1 060D FD *REVERT // Stack delta = +0 // Outputs[1] { @060D revert(memory[0x00:0x00]); } // Block terminates label_060E: // Incoming jump from 0x0609, if !msg.value // Inputs[1] { @0631 storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a621] } 060E 5B JUMPDEST 060F 50 POP 0610 7F PUSH32 0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a621 0631 54 SLOAD 0632 61 PUSH2 0x0487 0635 56 *JUMP // Stack delta = +0 // Outputs[1] { @0631 stack[-1] = storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a621] } // Block ends with unconditional jump to 0x0487 label_0636: // Incoming jump from 0x01B7, if 0x53ebf6bd == stack[-1] // Inputs[1] { @0637 msg.value } 0636 5B JUMPDEST 0637 34 CALLVALUE 0638 80 DUP1 0639 15 ISZERO 063A 61 PUSH2 0x0642 063D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0637 stack[0] = msg.value } // Block ends with conditional jump to 0x0642, if !msg.value label_063E: // Incoming jump from 0x063D, if not !msg.value // Inputs[1] { @0641 memory[0x00:0x00] } 063E 60 PUSH1 0x00 0640 80 DUP1 0641 FD *REVERT // Stack delta = +0 // Outputs[1] { @0641 revert(memory[0x00:0x00]); } // Block terminates label_0642: // Incoming jump from 0x063D, if !msg.value // Inputs[1] { @064A msg.data.length } 0642 5B JUMPDEST 0643 50 POP 0644 61 PUSH2 0x0348 0647 61 PUSH2 0x0651 064A 36 CALLDATASIZE 064B 60 PUSH1 0x04 064D 61 PUSH2 0x2601 0650 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0644 stack[-1] = 0x0348 // @0647 stack[0] = 0x0651 // @064A stack[1] = msg.data.length // @064B stack[2] = 0x04 // } // Block ends with call to 0x2601, returns to 0x0651 label_0651: // Incoming return from call to 0x2601 at 0x0650 0651 5B JUMPDEST 0652 61 PUSH2 0x0e0a 0655 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e0a label_0656: // Incoming jump from 0x01C2, if 0x6137a96f == stack[-1] // Inputs[1] { @0657 msg.value } 0656 5B JUMPDEST 0657 34 CALLVALUE 0658 80 DUP1 0659 15 ISZERO 065A 61 PUSH2 0x0662 065D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0657 stack[0] = msg.value } // Block ends with conditional jump to 0x0662, if !msg.value label_065E: // Incoming jump from 0x065D, if not !msg.value // Inputs[1] { @0661 memory[0x00:0x00] } 065E 60 PUSH1 0x00 0660 80 DUP1 0661 FD *REVERT // Stack delta = +0 // Outputs[1] { @0661 revert(memory[0x00:0x00]); } // Block terminates label_0662: // Incoming jump from 0x065D, if !msg.value // Inputs[1] { @066A msg.data.length } 0662 5B JUMPDEST 0663 50 POP 0664 61 PUSH2 0x0348 0667 61 PUSH2 0x0671 066A 36 CALLDATASIZE 066B 60 PUSH1 0x04 066D 61 PUSH2 0x25ac 0670 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0664 stack[-1] = 0x0348 // @0667 stack[0] = 0x0671 // @066A stack[1] = msg.data.length // @066B stack[2] = 0x04 // } // Block ends with call to 0x25ac, returns to 0x0671 label_0671: // Incoming return from call to 0x25AC at 0x0670 0671 5B JUMPDEST 0672 61 PUSH2 0x0e4c 0675 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e4c label_0676: // Incoming jump from 0x0139, if 0x6352211e == stack[-1] // Inputs[1] { @0677 msg.value } 0676 5B JUMPDEST 0677 34 CALLVALUE 0678 80 DUP1 0679 15 ISZERO 067A 61 PUSH2 0x0682 067D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0677 stack[0] = msg.value } // Block ends with conditional jump to 0x0682, if !msg.value label_067E: // Incoming jump from 0x067D, if not !msg.value // Inputs[1] { @0681 memory[0x00:0x00] } 067E 60 PUSH1 0x00 0680 80 DUP1 0681 FD *REVERT // Stack delta = +0 // Outputs[1] { @0681 revert(memory[0x00:0x00]); } // Block terminates label_0682: // Incoming jump from 0x067D, if !msg.value // Inputs[1] { @068A msg.data.length } 0682 5B JUMPDEST 0683 50 POP 0684 61 PUSH2 0x03ec 0687 61 PUSH2 0x0691 068A 36 CALLDATASIZE 068B 60 PUSH1 0x04 068D 61 PUSH2 0x2526 0690 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0684 stack[-1] = 0x03ec // @0687 stack[0] = 0x0691 // @068A stack[1] = msg.data.length // @068B stack[2] = 0x04 // } // Block ends with call to 0x2526, returns to 0x0691 label_0691: // Incoming return from call to 0x2526 at 0x0690 0691 5B JUMPDEST 0692 61 PUSH2 0x0eb1 0695 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0eb1 label_0696: // Incoming jump from 0x0144, if 0x669ee234 == stack[-1] // Inputs[1] { @0697 msg.value } 0696 5B JUMPDEST 0697 34 CALLVALUE 0698 80 DUP1 0699 15 ISZERO 069A 61 PUSH2 0x06a2 069D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0697 stack[0] = msg.value } // Block ends with conditional jump to 0x06a2, if !msg.value label_069E: // Incoming jump from 0x069D, if not !msg.value // Inputs[1] { @06A1 memory[0x00:0x00] } 069E 60 PUSH1 0x00 06A0 80 DUP1 06A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @06A1 revert(memory[0x00:0x00]); } // Block terminates label_06A2: // Incoming jump from 0x069D, if !msg.value // Inputs[1] { @06AA msg.data.length } 06A2 5B JUMPDEST 06A3 50 POP 06A4 61 PUSH2 0x0348 06A7 61 PUSH2 0x06b1 06AA 36 CALLDATASIZE 06AB 60 PUSH1 0x04 06AD 61 PUSH2 0x2601 06B0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06A4 stack[-1] = 0x0348 // @06A7 stack[0] = 0x06b1 // @06AA stack[1] = msg.data.length // @06AB stack[2] = 0x04 // } // Block ends with call to 0x2601, returns to 0x06B1 label_06B1: // Incoming return from call to 0x2601 at 0x06B0 06B1 5B JUMPDEST 06B2 61 PUSH2 0x0ebc 06B5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ebc label_06B6: // Incoming jump from 0x014F, if 0x6d42ac7f == stack[-1] // Inputs[1] { @06B7 msg.value } 06B6 5B JUMPDEST 06B7 34 CALLVALUE 06B8 80 DUP1 06B9 15 ISZERO 06BA 61 PUSH2 0x06c2 06BD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06B7 stack[0] = msg.value } // Block ends with conditional jump to 0x06c2, if !msg.value label_06BE: // Incoming jump from 0x06BD, if not !msg.value // Inputs[1] { @06C1 memory[0x00:0x00] } 06BE 60 PUSH1 0x00 06C0 80 DUP1 06C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @06C1 revert(memory[0x00:0x00]); } // Block terminates label_06C2: // Incoming jump from 0x06BD, if !msg.value 06C2 5B JUMPDEST 06C3 50 POP 06C4 61 PUSH2 0x03ec 06C7 73 PUSH20 0xd3441bf5870ef9c2cec0212532a5b4edd5ed9b74 06DC 81 DUP2 06DD 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @06C4 stack[-1] = 0x03ec // @06C7 stack[0] = 0xd3441bf5870ef9c2cec0212532a5b4edd5ed9b74 // } // Block ends with unconditional jump to 0x03ec label_06DE: // Incoming jump from 0x015A, if 0x70a08231 == stack[-1] // Inputs[1] { @06DF msg.value } 06DE 5B JUMPDEST 06DF 34 CALLVALUE 06E0 80 DUP1 06E1 15 ISZERO 06E2 61 PUSH2 0x06ea 06E5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06DF stack[0] = msg.value } // Block ends with conditional jump to 0x06ea, if !msg.value label_06E6: // Incoming jump from 0x06E5, if not !msg.value // Inputs[1] { @06E9 memory[0x00:0x00] } 06E6 60 PUSH1 0x00 06E8 80 DUP1 06E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @06E9 revert(memory[0x00:0x00]); } // Block terminates label_06EA: // Incoming jump from 0x06E5, if !msg.value // Inputs[1] { @06F2 msg.data.length } 06EA 5B JUMPDEST 06EB 50 POP 06EC 61 PUSH2 0x0487 06EF 61 PUSH2 0x06f9 06F2 36 CALLDATASIZE 06F3 60 PUSH1 0x04 06F5 61 PUSH2 0x242e 06F8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06EC stack[-1] = 0x0487 // @06EF stack[0] = 0x06f9 // @06F2 stack[1] = msg.data.length // @06F3 stack[2] = 0x04 // } // Block ends with call to 0x242e, returns to 0x06F9 label_06F9: // Incoming return from call to 0x242E at 0x06F8 06F9 5B JUMPDEST 06FA 61 PUSH2 0x0f14 06FD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f14 label_06FE: // Incoming jump from 0x0165, if 0x715018a6 == stack[-1] // Inputs[1] { @06FF msg.value } 06FE 5B JUMPDEST 06FF 34 CALLVALUE 0700 80 DUP1 0701 15 ISZERO 0702 61 PUSH2 0x070a 0705 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06FF stack[0] = msg.value } // Block ends with conditional jump to 0x070a, if !msg.value label_0706: // Incoming jump from 0x0705, if not !msg.value // Inputs[1] { @0709 memory[0x00:0x00] } 0706 60 PUSH1 0x00 0708 80 DUP1 0709 FD *REVERT // Stack delta = +0 // Outputs[1] { @0709 revert(memory[0x00:0x00]); } // Block terminates label_070A: // Incoming jump from 0x0705, if !msg.value 070A 5B JUMPDEST 070B 50 POP 070C 61 PUSH2 0x0348 070F 61 PUSH2 0x0f63 0712 56 *JUMP // Stack delta = +0 // Outputs[1] { @070C stack[-1] = 0x0348 } // Block ends with unconditional jump to 0x0f63 label_0713: // Incoming jump from 0x0170, if 0x72b44d71 == stack[-1] // Inputs[1] { @0714 msg.value } 0713 5B JUMPDEST 0714 34 CALLVALUE 0715 80 DUP1 0716 15 ISZERO 0717 61 PUSH2 0x071f 071A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0714 stack[0] = msg.value } // Block ends with conditional jump to 0x071f, if !msg.value label_071B: // Incoming jump from 0x071A, if not !msg.value // Inputs[1] { @071E memory[0x00:0x00] } 071B 60 PUSH1 0x00 071D 80 DUP1 071E FD *REVERT // Stack delta = +0 // Outputs[1] { @071E revert(memory[0x00:0x00]); } // Block terminates label_071F: // Incoming jump from 0x071A, if !msg.value // Inputs[1] { @0727 msg.data.length } 071F 5B JUMPDEST 0720 50 POP 0721 61 PUSH2 0x0348 0724 61 PUSH2 0x072e 0727 36 CALLDATASIZE 0728 60 PUSH1 0x04 072A 61 PUSH2 0x242e 072D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0721 stack[-1] = 0x0348 // @0724 stack[0] = 0x072e // @0727 stack[1] = msg.data.length // @0728 stack[2] = 0x04 // } // Block ends with call to 0x242e, returns to 0x072E label_072E: // Incoming return from call to 0x242E at 0x072D 072E 5B JUMPDEST 072F 61 PUSH2 0x0f77 0732 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f77 label_0733: // Incoming jump from 0x00F2, if 0x86e454eb == stack[-1] // Inputs[1] { @0734 msg.value } 0733 5B JUMPDEST 0734 34 CALLVALUE 0735 80 DUP1 0736 15 ISZERO 0737 61 PUSH2 0x073f 073A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0734 stack[0] = msg.value } // Block ends with conditional jump to 0x073f, if !msg.value label_073B: // Incoming jump from 0x073A, if not !msg.value // Inputs[1] { @073E memory[0x00:0x00] } 073B 60 PUSH1 0x00 073D 80 DUP1 073E FD *REVERT // Stack delta = +0 // Outputs[1] { @073E revert(memory[0x00:0x00]); } // Block terminates label_073F: // Incoming jump from 0x073A, if !msg.value // Inputs[1] { @0747 msg.data.length } 073F 5B JUMPDEST 0740 50 POP 0741 61 PUSH2 0x0348 0744 61 PUSH2 0x074e 0747 36 CALLDATASIZE 0748 60 PUSH1 0x04 074A 61 PUSH2 0x253f 074D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0741 stack[-1] = 0x0348 // @0744 stack[0] = 0x074e // @0747 stack[1] = msg.data.length // @0748 stack[2] = 0x04 // } // Block ends with call to 0x253f, returns to 0x074E label_074E: // Incoming return from call to 0x253F at 0x074D 074E 5B JUMPDEST 074F 61 PUSH2 0x0fa8 0752 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fa8 label_0753: // Incoming jump from 0x00FD, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0754 msg.value } 0753 5B JUMPDEST 0754 34 CALLVALUE 0755 80 DUP1 0756 15 ISZERO 0757 61 PUSH2 0x075f 075A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0754 stack[0] = msg.value } // Block ends with conditional jump to 0x075f, if !msg.value label_075B: // Incoming jump from 0x075A, if not !msg.value // Inputs[1] { @075E memory[0x00:0x00] } 075B 60 PUSH1 0x00 075D 80 DUP1 075E FD *REVERT // Stack delta = +0 // Outputs[1] { @075E revert(memory[0x00:0x00]); } // Block terminates label_075F: // Incoming jump from 0x075A, if !msg.value // Inputs[1] { @0763 storage[0x08] } 075F 5B JUMPDEST 0760 50 POP 0761 60 PUSH1 0x08 0763 54 SLOAD 0764 60 PUSH1 0x01 0766 60 PUSH1 0x01 0768 60 PUSH1 0xa0 076A 1B SHL 076B 03 SUB 076C 16 AND 076D 61 PUSH2 0x03ec 0770 56 *JUMP // Stack delta = +0 // Outputs[1] { @076C stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x08] } // Block ends with unconditional jump to 0x03ec label_0771: // Incoming jump from 0x0108, if 0x91d14854 == stack[-1] // Inputs[1] { @0772 msg.value } 0771 5B JUMPDEST 0772 34 CALLVALUE 0773 80 DUP1 0774 15 ISZERO 0775 61 PUSH2 0x077d 0778 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0772 stack[0] = msg.value } // Block ends with conditional jump to 0x077d, if !msg.value label_0779: // Incoming jump from 0x0778, if not !msg.value // Inputs[1] { @077C memory[0x00:0x00] } 0779 60 PUSH1 0x00 077B 80 DUP1 077C FD *REVERT // Stack delta = +0 // Outputs[1] { @077C revert(memory[0x00:0x00]); } // Block terminates label_077D: // Incoming jump from 0x0778, if !msg.value // Inputs[1] { @0785 msg.data.length } 077D 5B JUMPDEST 077E 50 POP 077F 61 PUSH2 0x0318 0782 61 PUSH2 0x078c 0785 36 CALLDATASIZE 0786 60 PUSH1 0x04 0788 61 PUSH2 0x25ce 078B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @077F stack[-1] = 0x0318 // @0782 stack[0] = 0x078c // @0785 stack[1] = msg.data.length // @0786 stack[2] = 0x04 // } // Block ends with call to 0x25ce, returns to 0x078C label_078C: // Incoming return from call to 0x25CE at 0x078B 078C 5B JUMPDEST 078D 61 PUSH2 0x0fdc 0790 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fdc label_0791: // Incoming jump from 0x0113, if 0x95d89b41 == stack[-1] // Inputs[1] { @0792 msg.value } 0791 5B JUMPDEST 0792 34 CALLVALUE 0793 80 DUP1 0794 15 ISZERO 0795 61 PUSH2 0x079d 0798 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0792 stack[0] = msg.value } // Block ends with conditional jump to 0x079d, if !msg.value label_0799: // Incoming jump from 0x0798, if not !msg.value // Inputs[1] { @079C memory[0x00:0x00] } 0799 60 PUSH1 0x00 079B 80 DUP1 079C FD *REVERT // Stack delta = +0 // Outputs[1] { @079C revert(memory[0x00:0x00]); } // Block terminates label_079D: // Incoming jump from 0x0798, if !msg.value 079D 5B JUMPDEST 079E 50 POP 079F 61 PUSH2 0x03bf 07A2 61 PUSH2 0x1007 07A5 56 *JUMP // Stack delta = +0 // Outputs[1] { @079F stack[-1] = 0x03bf } // Block ends with call to 0x1007, returns to 0x03BF label_07A6: // Incoming jump from 0x011E, if 0x9c09628d == stack[-1] // Inputs[1] { @07A7 msg.value } 07A6 5B JUMPDEST 07A7 34 CALLVALUE 07A8 80 DUP1 07A9 15 ISZERO 07AA 61 PUSH2 0x07b2 07AD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07A7 stack[0] = msg.value } // Block ends with conditional jump to 0x07b2, if !msg.value label_07AE: // Incoming jump from 0x07AD, if not !msg.value // Inputs[1] { @07B1 memory[0x00:0x00] } 07AE 60 PUSH1 0x00 07B0 80 DUP1 07B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @07B1 revert(memory[0x00:0x00]); } // Block terminates label_07B2: // Incoming jump from 0x07AD, if !msg.value // Inputs[1] { @07BA msg.data.length } 07B2 5B JUMPDEST 07B3 50 POP 07B4 61 PUSH2 0x0348 07B7 61 PUSH2 0x07c1 07BA 36 CALLDATASIZE 07BB 60 PUSH1 0x04 07BD 61 PUSH2 0x2526 07C0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @07B4 stack[-1] = 0x0348 // @07B7 stack[0] = 0x07c1 // @07BA stack[1] = msg.data.length // @07BB stack[2] = 0x04 // } // Block ends with call to 0x2526, returns to 0x07C1 label_07C1: // Incoming return from call to 0x2526 at 0x07C0 07C1 5B JUMPDEST 07C2 61 PUSH2 0x1016 07C5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1016 label_07C6: // Incoming jump from 0x0129, if 0xa217fddf == stack[-1] // Inputs[1] { @07C7 msg.value } 07C6 5B JUMPDEST 07C7 34 CALLVALUE 07C8 80 DUP1 07C9 15 ISZERO 07CA 61 PUSH2 0x07d2 07CD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07C7 stack[0] = msg.value } // Block ends with conditional jump to 0x07d2, if !msg.value label_07CE: // Incoming jump from 0x07CD, if not !msg.value // Inputs[1] { @07D1 memory[0x00:0x00] } 07CE 60 PUSH1 0x00 07D0 80 DUP1 07D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @07D1 revert(memory[0x00:0x00]); } // Block terminates label_07D2: // Incoming jump from 0x07CD, if !msg.value 07D2 5B JUMPDEST 07D3 50 POP 07D4 61 PUSH2 0x0487 07D7 60 PUSH1 0x00 07D9 81 DUP2 07DA 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @07D4 stack[-1] = 0x0487 // @07D7 stack[0] = 0x00 // } // Block ends with unconditional jump to 0x0487 label_07DB: // Incoming jump from 0x00A0, if 0xa22cb465 == stack[-1] // Inputs[1] { @07DC msg.value } 07DB 5B JUMPDEST 07DC 34 CALLVALUE 07DD 80 DUP1 07DE 15 ISZERO 07DF 61 PUSH2 0x07e7 07E2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07DC stack[0] = msg.value } // Block ends with conditional jump to 0x07e7, if !msg.value label_07E3: // Incoming jump from 0x07E2, if not !msg.value // Inputs[1] { @07E6 memory[0x00:0x00] } 07E3 60 PUSH1 0x00 07E5 80 DUP1 07E6 FD *REVERT // Stack delta = +0 // Outputs[1] { @07E6 revert(memory[0x00:0x00]); } // Block terminates label_07E7: // Incoming jump from 0x07E2, if !msg.value // Inputs[1] { @07EF msg.data.length } 07E7 5B JUMPDEST 07E8 50 POP 07E9 61 PUSH2 0x0348 07EC 61 PUSH2 0x07f6 07EF 36 CALLDATASIZE 07F0 60 PUSH1 0x04 07F2 61 PUSH2 0x261e 07F5 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @07E9 stack[-1] = 0x0348 // @07EC stack[0] = 0x07f6 // @07EF stack[1] = msg.data.length // @07F0 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x261e 07F6 5B JUMPDEST 07F7 61 PUSH2 0x1074 07FA 56 *JUMP label_07FB: // Incoming jump from 0x00AB, if 0xb7c0b8e8 == stack[-1] // Inputs[1] { @07FC msg.value } 07FB 5B JUMPDEST 07FC 34 CALLVALUE 07FD 80 DUP1 07FE 15 ISZERO 07FF 61 PUSH2 0x0807 0802 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07FC stack[0] = msg.value } // Block ends with conditional jump to 0x0807, if !msg.value label_0803: // Incoming jump from 0x0802, if not !msg.value // Inputs[1] { @0806 memory[0x00:0x00] } 0803 60 PUSH1 0x00 0805 80 DUP1 0806 FD *REVERT // Stack delta = +0 // Outputs[1] { @0806 revert(memory[0x00:0x00]); } // Block terminates label_0807: // Incoming jump from 0x0802, if !msg.value // Inputs[1] { @080F msg.data.length } 0807 5B JUMPDEST 0808 50 POP 0809 61 PUSH2 0x0348 080C 61 PUSH2 0x0816 080F 36 CALLDATASIZE 0810 60 PUSH1 0x04 0812 61 PUSH2 0x2601 0815 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0809 stack[-1] = 0x0348 // @080C stack[0] = 0x0816 // @080F stack[1] = msg.data.length // @0810 stack[2] = 0x04 // } // Block ends with call to 0x2601, returns to 0x0816 label_0816: // Incoming return from call to 0x2601 at 0x0815 0816 5B JUMPDEST 0817 61 PUSH2 0x10f6 081A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10f6 label_081B: // Incoming jump from 0x00B6, if 0xb88d4fde == stack[-1] // Inputs[1] { @0822 msg.data.length } 081B 5B JUMPDEST 081C 61 PUSH2 0x0348 081F 61 PUSH2 0x0829 0822 36 CALLDATASIZE 0823 60 PUSH1 0x04 0825 61 PUSH2 0x26bb 0828 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @081C stack[0] = 0x0348 // @081F stack[1] = 0x0829 // @0822 stack[2] = msg.data.length // @0823 stack[3] = 0x04 // } // Block ends with call to 0x26bb, returns to 0x0829 label_0829: // Incoming return from call to 0x26BB at 0x0828 0829 5B JUMPDEST 082A 61 PUSH2 0x1131 082D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1131 label_082E: // Incoming jump from 0x00C1, if 0xbabcc539 == stack[-1] // Inputs[1] { @082F msg.value } 082E 5B JUMPDEST 082F 34 CALLVALUE 0830 80 DUP1 0831 15 ISZERO 0832 61 PUSH2 0x083a 0835 57 *JUMPI // Stack delta = +1 // Outputs[1] { @082F stack[0] = msg.value } // Block ends with conditional jump to 0x083a, if !msg.value label_0836: // Incoming jump from 0x0835, if not !msg.value // Inputs[1] { @0839 memory[0x00:0x00] } 0836 60 PUSH1 0x00 0838 80 DUP1 0839 FD *REVERT // Stack delta = +0 // Outputs[1] { @0839 revert(memory[0x00:0x00]); } // Block terminates label_083A: // Incoming jump from 0x0835, if !msg.value // Inputs[1] { @0842 msg.data.length } 083A 5B JUMPDEST 083B 50 POP 083C 61 PUSH2 0x0318 083F 61 PUSH2 0x0849 0842 36 CALLDATASIZE 0843 60 PUSH1 0x04 0845 61 PUSH2 0x242e 0848 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @083C stack[-1] = 0x0318 // @083F stack[0] = 0x0849 // @0842 stack[1] = msg.data.length // @0843 stack[2] = 0x04 // } // Block ends with call to 0x242e, returns to 0x0849 label_0849: // Incoming return from call to 0x242E at 0x0848 0849 5B JUMPDEST 084A 61 PUSH2 0x1175 084D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1175 label_084E: // Incoming jump from 0x00CC, if 0xbc98a00f == stack[-1] // Inputs[1] { @084F msg.value } 084E 5B JUMPDEST 084F 34 CALLVALUE 0850 80 DUP1 0851 15 ISZERO 0852 61 PUSH2 0x085a 0855 57 *JUMPI // Stack delta = +1 // Outputs[1] { @084F stack[0] = msg.value } // Block ends with conditional jump to 0x085a, if !msg.value label_0856: // Incoming jump from 0x0855, if not !msg.value // Inputs[1] { @0859 memory[0x00:0x00] } 0856 60 PUSH1 0x00 0858 80 DUP1 0859 FD *REVERT // Stack delta = +0 // Outputs[1] { @0859 revert(memory[0x00:0x00]); } // Block terminates label_085A: // Incoming jump from 0x0855, if !msg.value // Inputs[1] { @0862 msg.data.length } 085A 5B JUMPDEST 085B 50 POP 085C 61 PUSH2 0x0348 085F 61 PUSH2 0x0869 0862 36 CALLDATASIZE 0863 60 PUSH1 0x04 0865 61 PUSH2 0x253f 0868 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @085C stack[-1] = 0x0348 // @085F stack[0] = 0x0869 // @0862 stack[1] = msg.data.length // @0863 stack[2] = 0x04 // } // Block ends with call to 0x253f, returns to 0x0869 label_0869: // Incoming return from call to 0x253F at 0x0868 0869 5B JUMPDEST 086A 61 PUSH2 0x126e 086D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x126e label_086E: // Incoming jump from 0x00D7, if 0xc87b56dd == stack[-1] // Inputs[1] { @086F msg.value } 086E 5B JUMPDEST 086F 34 CALLVALUE 0870 80 DUP1 0871 15 ISZERO 0872 61 PUSH2 0x087a 0875 57 *JUMPI // Stack delta = +1 // Outputs[1] { @086F stack[0] = msg.value } // Block ends with conditional jump to 0x087a, if !msg.value label_0876: // Incoming jump from 0x0875, if not !msg.value // Inputs[1] { @0879 memory[0x00:0x00] } 0876 60 PUSH1 0x00 0878 80 DUP1 0879 FD *REVERT // Stack delta = +0 // Outputs[1] { @0879 revert(memory[0x00:0x00]); } // Block terminates label_087A: // Incoming jump from 0x0875, if !msg.value // Inputs[1] { @0882 msg.data.length } 087A 5B JUMPDEST 087B 50 POP 087C 61 PUSH2 0x03bf 087F 61 PUSH2 0x0889 0882 36 CALLDATASIZE 0883 60 PUSH1 0x04 0885 61 PUSH2 0x2526 0888 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @087C stack[-1] = 0x03bf // @087F stack[0] = 0x0889 // @0882 stack[1] = msg.data.length // @0883 stack[2] = 0x04 // } // Block ends with call to 0x2526, returns to 0x0889 label_0889: // Incoming return from call to 0x2526 at 0x0888 0889 5B JUMPDEST 088A 61 PUSH2 0x12a2 088D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x12a2 label_088E: // Incoming jump from 0x007A, if 0xd547741f == stack[-1] // Inputs[1] { @088F msg.value } 088E 5B JUMPDEST 088F 34 CALLVALUE 0890 80 DUP1 0891 15 ISZERO 0892 61 PUSH2 0x089a 0895 57 *JUMPI // Stack delta = +1 // Outputs[1] { @088F stack[0] = msg.value } // Block ends with conditional jump to 0x089a, if !msg.value label_0896: // Incoming jump from 0x0895, if not !msg.value // Inputs[1] { @0899 memory[0x00:0x00] } 0896 60 PUSH1 0x00 0898 80 DUP1 0899 FD *REVERT // Stack delta = +0 // Outputs[1] { @0899 revert(memory[0x00:0x00]); } // Block terminates label_089A: // Incoming jump from 0x0895, if !msg.value // Inputs[1] { @08A2 msg.data.length } 089A 5B JUMPDEST 089B 50 POP 089C 61 PUSH2 0x0348 089F 61 PUSH2 0x08a9 08A2 36 CALLDATASIZE 08A3 60 PUSH1 0x04 08A5 61 PUSH2 0x25ce 08A8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @089C stack[-1] = 0x0348 // @089F stack[0] = 0x08a9 // @08A2 stack[1] = msg.data.length // @08A3 stack[2] = 0x04 // } // Block ends with call to 0x25ce, returns to 0x08A9 label_08A9: // Incoming return from call to 0x25CE at 0x08A8 08A9 5B JUMPDEST 08AA 61 PUSH2 0x1324 08AD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1324 label_08AE: // Incoming jump from 0x0085, if 0xdbe4613d == stack[-1] // Inputs[1] { @08AF msg.value } 08AE 5B JUMPDEST 08AF 34 CALLVALUE 08B0 80 DUP1 08B1 15 ISZERO 08B2 61 PUSH2 0x08ba 08B5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08AF stack[0] = msg.value } // Block ends with conditional jump to 0x08ba, if !msg.value label_08B6: // Incoming jump from 0x08B5, if not !msg.value // Inputs[1] { @08B9 memory[0x00:0x00] } 08B6 60 PUSH1 0x00 08B8 80 DUP1 08B9 FD *REVERT // Stack delta = +0 // Outputs[1] { @08B9 revert(memory[0x00:0x00]); } // Block terminates label_08BA: // Incoming jump from 0x08B5, if !msg.value 08BA 5B JUMPDEST 08BB 50 POP 08BC 61 PUSH2 0x0487 08BF 7F PUSH32 0x43f25613eb2f15fb17222a5d424ca2655743e71265d98e4b93c05e5fb589ecde 08E0 81 DUP2 08E1 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @08BC stack[-1] = 0x0487 // @08BF stack[0] = 0x43f25613eb2f15fb17222a5d424ca2655743e71265d98e4b93c05e5fb589ecde // } // Block ends with unconditional jump to 0x0487 label_08E2: // Incoming jump from 0x0090, if 0xe58306f9 == stack[-1] // Inputs[1] { @08E3 msg.value } 08E2 5B JUMPDEST 08E3 34 CALLVALUE 08E4 80 DUP1 08E5 15 ISZERO 08E6 61 PUSH2 0x08ee 08E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08E3 stack[0] = msg.value } // Block ends with conditional jump to 0x08ee, if !msg.value label_08EA: // Incoming jump from 0x08E9, if not !msg.value // Inputs[1] { @08ED memory[0x00:0x00] } 08EA 60 PUSH1 0x00 08EC 80 DUP1 08ED FD *REVERT // Stack delta = +0 // Outputs[1] { @08ED revert(memory[0x00:0x00]); } // Block terminates label_08EE: // Incoming jump from 0x08E9, if !msg.value // Inputs[1] { @08F6 msg.data.length } 08EE 5B JUMPDEST 08EF 50 POP 08F0 61 PUSH2 0x0348 08F3 61 PUSH2 0x08fd 08F6 36 CALLDATASIZE 08F7 60 PUSH1 0x04 08F9 61 PUSH2 0x253f 08FC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @08F0 stack[-1] = 0x0348 // @08F3 stack[0] = 0x08fd // @08F6 stack[1] = msg.data.length // @08F7 stack[2] = 0x04 // } // Block ends with call to 0x253f, returns to 0x08FD label_08FD: // Incoming return from call to 0x253F at 0x08FC 08FD 5B JUMPDEST 08FE 61 PUSH2 0x1349 0901 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1349 label_0902: // Incoming jump from 0x0049, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0903 msg.value } 0902 5B JUMPDEST 0903 34 CALLVALUE 0904 80 DUP1 0905 15 ISZERO 0906 61 PUSH2 0x090e 0909 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0903 stack[0] = msg.value } // Block ends with conditional jump to 0x090e, if !msg.value label_090A: // Incoming jump from 0x0909, if not !msg.value // Inputs[1] { @090D memory[0x00:0x00] } 090A 60 PUSH1 0x00 090C 80 DUP1 090D FD *REVERT // Stack delta = +0 // Outputs[1] { @090D revert(memory[0x00:0x00]); } // Block terminates label_090E: // Incoming jump from 0x0909, if !msg.value // Inputs[1] { @0916 msg.data.length } 090E 5B JUMPDEST 090F 50 POP 0910 61 PUSH2 0x0318 0913 61 PUSH2 0x091d 0916 36 CALLDATASIZE 0917 60 PUSH1 0x04 0919 61 PUSH2 0x276a 091C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0910 stack[-1] = 0x0318 // @0913 stack[0] = 0x091d // @0916 stack[1] = msg.data.length // @0917 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x276a 091D 5B JUMPDEST 091E 61 PUSH2 0x137b 0921 56 *JUMP label_0922: // Incoming jump from 0x0054, if 0xf2fde38b == stack[-1] // Inputs[1] { @0923 msg.value } 0922 5B JUMPDEST 0923 34 CALLVALUE 0924 80 DUP1 0925 15 ISZERO 0926 61 PUSH2 0x092e 0929 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0923 stack[0] = msg.value } // Block ends with conditional jump to 0x092e, if !msg.value label_092A: // Incoming jump from 0x0929, if not !msg.value // Inputs[1] { @092D memory[0x00:0x00] } 092A 60 PUSH1 0x00 092C 80 DUP1 092D FD *REVERT // Stack delta = +0 // Outputs[1] { @092D revert(memory[0x00:0x00]); } // Block terminates label_092E: // Incoming jump from 0x0929, if !msg.value // Inputs[1] { @0936 msg.data.length } 092E 5B JUMPDEST 092F 50 POP 0930 61 PUSH2 0x0348 0933 61 PUSH2 0x093d 0936 36 CALLDATASIZE 0937 60 PUSH1 0x04 0939 61 PUSH2 0x242e 093C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0930 stack[-1] = 0x0348 // @0933 stack[0] = 0x093d // @0936 stack[1] = msg.data.length // @0937 stack[2] = 0x04 // } // Block ends with call to 0x242e, returns to 0x093D label_093D: // Incoming return from call to 0x242E at 0x093C 093D 5B JUMPDEST 093E 61 PUSH2 0x13c7 0941 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x13c7 label_0942: // Incoming jump from 0x005F, if 0xfb796e6c == stack[-1] // Inputs[1] { @0943 msg.value } 0942 5B JUMPDEST 0943 34 CALLVALUE 0944 80 DUP1 0945 15 ISZERO 0946 61 PUSH2 0x094e 0949 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0943 stack[0] = msg.value } // Block ends with conditional jump to 0x094e, if !msg.value label_094A: // Incoming jump from 0x0949, if not !msg.value // Inputs[1] { @094D memory[0x00:0x00] } 094A 60 PUSH1 0x00 094C 80 DUP1 094D FD *REVERT // Stack delta = +0 // Outputs[1] { @094D revert(memory[0x00:0x00]); } // Block terminates label_094E: // Incoming jump from 0x0949, if !msg.value // Inputs[1] { @0952 storage[0x0b] } 094E 5B JUMPDEST 094F 50 POP 0950 60 PUSH1 0x0b 0952 54 SLOAD 0953 61 PUSH2 0x0318 0956 90 SWAP1 0957 60 PUSH1 0xff 0959 16 AND 095A 81 DUP2 095B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0956 stack[-1] = 0x0318 // @0959 stack[0] = 0xff & storage[0x0b] // } // Block ends with unconditional jump to 0x0318 label_095C: // Incoming jump from 0x006A, if 0xff768212 == stack[-1] // Inputs[1] { @095D msg.value } 095C 5B JUMPDEST 095D 34 CALLVALUE 095E 80 DUP1 095F 15 ISZERO 0960 61 PUSH2 0x0968 0963 57 *JUMPI // Stack delta = +1 // Outputs[1] { @095D stack[0] = msg.value } // Block ends with conditional jump to 0x0968, if !msg.value label_0964: // Incoming jump from 0x0963, if not !msg.value // Inputs[1] { @0967 memory[0x00:0x00] } 0964 60 PUSH1 0x00 0966 80 DUP1 0967 FD *REVERT // Stack delta = +0 // Outputs[1] { @0967 revert(memory[0x00:0x00]); } // Block terminates label_0968: // Incoming jump from 0x0963, if !msg.value // Inputs[1] { @0970 msg.data.length } 0968 5B JUMPDEST 0969 50 POP 096A 61 PUSH2 0x0348 096D 61 PUSH2 0x0977 0970 36 CALLDATASIZE 0971 60 PUSH1 0x04 0973 61 PUSH2 0x242e 0976 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @096A stack[-1] = 0x0348 // @096D stack[0] = 0x0977 // @0970 stack[1] = msg.data.length // @0971 stack[2] = 0x04 // } // Block ends with call to 0x242e, returns to 0x0977 label_0977: // Incoming return from call to 0x242E at 0x0976 0977 5B JUMPDEST 0978 61 PUSH2 0x143d 097B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x143d label_097C: // Incoming call from 0x02E1, returns to 0x02E2 // Inputs[2] // { // @0985 memory[0x00:0x20] // @098E memory[0x00:0x20] // } 097C 5B JUMPDEST 097D 60 PUSH1 0x60 097F 61 PUSH2 0x0995 0982 60 PUSH1 0x00 0984 80 DUP1 0985 51 MLOAD 0986 60 PUSH1 0x20 0988 61 PUSH2 0x29ee 098B 83 DUP4 098C 39 CODECOPY 098D 81 DUP2 098E 51 MLOAD 098F 91 SWAP2 0990 52 MSTORE 0991 61 PUSH2 0x146e 0994 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @097D stack[0] = 0x60 // @097F stack[1] = 0x0995 // @098C memory[0x00:0x20] = code[0x29ee:0x2a0e] // @098F stack[2] = memory[0x00:0x20] // @0990 memory[0x00:0x20] = memory[0x00:0x20] // } // Block ends with call to 0x146e, returns to 0x0995 label_0995: // Incoming return from call to 0x146E at 0x0994 // Inputs[3] // { // @0996 stack[-2] // @0996 stack[-1] // @0998 stack[-3] // } 0995 5B JUMPDEST 0996 90 SWAP1 0997 50 POP 0998 90 SWAP1 0999 56 *JUMP // Stack delta = -2 // Outputs[1] { @0998 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_099A: // Incoming jump from 0x0317 // Incoming call from 0x11B1, returns to 0x11B2 // Inputs[3] // { // @09A3 memory[0x00:0x20] // @09AC memory[0x00:0x20] // @09AF stack[-1] // } 099A 5B JUMPDEST 099B 60 PUSH1 0x00 099D 61 PUSH2 0x09b4 09A0 60 PUSH1 0x00 09A2 80 DUP1 09A3 51 MLOAD 09A4 60 PUSH1 0x20 09A6 61 PUSH2 0x29ee 09A9 83 DUP4 09AA 39 CODECOPY 09AB 81 DUP2 09AC 51 MLOAD 09AD 91 SWAP2 09AE 52 MSTORE 09AF 83 DUP4 09B0 61 PUSH2 0x147b 09B3 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @099B stack[0] = 0x00 // @099D stack[1] = 0x09b4 // @09AA memory[0x00:0x20] = code[0x29ee:0x2a0e] // @09AD stack[2] = memory[0x00:0x20] // @09AE memory[0x00:0x20] = memory[0x00:0x20] // @09AF stack[3] = stack[-1] // } // Block ends with call to 0x147b, returns to 0x09B4 label_09B4: // Incoming jump from 0x14B8, if 0x7965db0b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x23C3 // Incoming jump from 0x27F7, if (stack[-2] == (stack[-2] * stack[-1]) / stack[-1]) | !stack[-1] // Incoming return from call to 0x2821 at 0x126D // Incoming return from call to 0x20FD at 0x20FC // Incoming jump from 0x1508, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Incoming return from call to 0x149D at 0x1544 // Incoming jump from 0x1DF5, if !(stack[-3] < storage[0x00]) // Incoming jump from 0x0A61, if 0x24832483 << 0xe1 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x153B, if 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x29CF, if !(stack[-1] - stack[-2] > stack[-1]) // Incoming jump from 0x0A61, if stack[-1] // Incoming return from call to 0x147B at 0x09B3 // Incoming jump from 0x237C // Incoming return from call to 0x1520 at 0x0A6A // Incoming jump from 0x14D1 // Incoming return from call to 0x283E at 0x1323 // Incoming jump from 0x11B7, if stack[-1] // Incoming return from call to 0x1A8D at 0x0EBB // Incoming return from call to 0x1642 at 0x0BBE // Incoming jump from 0x23CB // Incoming jump from 0x1DF5, if !stack[-1] // Incoming jump from 0x291A, if !(stack[-1] > stack[-2] + stack[-1]) // Incoming jump from 0x2372 // Incoming jump from 0x1395 // Incoming jump from 0x1508, if stack[-1] // Inputs[3] // { // @09B5 stack[-1] // @09B5 stack[-4] // @09B6 stack[-3] // } 09B4 5B JUMPDEST 09B5 92 SWAP3 09B6 91 SWAP2 09B7 50 POP 09B8 50 POP 09B9 56 *JUMP // Stack delta = -3 // Outputs[1] { @09B5 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_09BA: // Incoming jump from 0x0347 // Inputs[1] { @09C0 msg.sender } 09BA 5B JUMPDEST 09BB 61 PUSH2 0x09c5 09BE 60 PUSH1 0x00 09C0 33 CALLER 09C1 61 PUSH2 0x0fdc 09C4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09BB stack[0] = 0x09c5 // @09BE stack[1] = 0x00 // @09C0 stack[2] = msg.sender // } // Block ends with call to 0x0fdc, returns to 0x09C5 label_09C5: // Incoming return from call to 0x0FDC at 0x09C4 // Inputs[1] { @09C9 stack[-1] } 09C5 5B JUMPDEST 09C6 61 PUSH2 0x09e2 09C9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x09e2, if stack[-1] label_09CA: // Incoming jump from 0x09C9, if not stack[-1] // Inputs[3] // { // @09CC memory[0x40:0x60] // @09DC memory[0x40:0x60] // @09E1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 09CA 60 PUSH1 0x40 09CC 51 MLOAD 09CD 63 PUSH4 0x5ee82311 09D2 60 PUSH1 0xe0 09D4 1B SHL 09D5 81 DUP2 09D6 52 MSTORE 09D7 60 PUSH1 0x04 09D9 01 ADD 09DA 60 PUSH1 0x40 09DC 51 MLOAD 09DD 80 DUP1 09DE 91 SWAP2 09DF 03 SUB 09E0 90 SWAP1 09E1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @09D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5ee82311 << 0xe0 // @09E1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_09E2: // Incoming jump from 0x09C9, if stack[-1] // Inputs[3] // { // @09E6 storage[0x0b] // @09F0 stack[-1] // @0A0B stack[-2] // } 09E2 5B JUMPDEST 09E3 60 PUSH1 0x0b 09E5 80 DUP1 09E6 54 SLOAD 09E7 60 PUSH1 0x01 09E9 60 PUSH1 0x01 09EB 60 PUSH1 0xa0 09ED 1B SHL 09EE 03 SUB 09EF 90 SWAP1 09F0 92 SWAP3 09F1 16 AND 09F2 62 PUSH3 0x010000 09F6 02 MUL 09F7 62 PUSH3 0x010000 09FB 60 PUSH1 0x01 09FD 60 PUSH1 0xb0 09FF 1B SHL 0A00 03 SUB 0A01 19 NOT 0A02 90 SWAP1 0A03 92 SWAP3 0A04 16 AND 0A05 91 SWAP2 0A06 90 SWAP1 0A07 91 SWAP2 0A08 17 OR 0A09 90 SWAP1 0A0A 55 SSTORE 0A0B 56 *JUMP // Stack delta = -2 // Outputs[1] { @0A0A storage[0x0b] = (storage[0x0b] & ~((0x01 << 0xb0) - 0x010000)) | 0x010000 * (stack[-1] & (0x01 << 0xa0) - 0x01) } // Block ends with unconditional jump to stack[-2] label_0A0C: // Incoming jump from 0x0369 // Inputs[1] { @0A12 stack[-1] } 0A0C 5B JUMPDEST 0A0D 60 PUSH1 0x00 0A0F 61 PUSH2 0x0a17 0A12 82 DUP3 0A13 61 PUSH2 0x149d 0A16 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A0D stack[0] = 0x00 // @0A0F stack[1] = 0x0a17 // @0A12 stack[2] = stack[-1] // } // Block ends with call to 0x149d, returns to 0x0A17 label_0A17: // Incoming return from call to 0x149D at 0x0A16 // Inputs[1] { @0A18 stack[-1] } 0A17 5B JUMPDEST 0A18 80 DUP1 0A19 61 PUSH2 0x0a26 0A1C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a26, if stack[-1] label_0A1D: // Incoming jump from 0x0A1C, if not stack[-1] // Inputs[1] { @0A21 stack[-3] } 0A1D 50 POP 0A1E 61 PUSH2 0x0a26 0A21 82 DUP3 0A22 61 PUSH2 0x14d2 0A25 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0A1E stack[-1] = 0x0a26 // @0A21 stack[0] = stack[-3] // } // Block ends with call to 0x14d2, returns to 0x0A26 label_0A26: // Incoming jump from 0x0A1C, if stack[-1] // Incoming return from call to 0x14D2 at 0x0A25 // Inputs[1] { @0A27 stack[-1] } 0A26 5B JUMPDEST 0A27 80 DUP1 0A28 61 PUSH2 0x0a41 0A2B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a41, if stack[-1] label_0A2C: // Incoming jump from 0x0A2B, if not stack[-1] // Inputs[1] { @0A36 stack[-3] } 0A2C 50 POP 0A2D 60 PUSH1 0x01 0A2F 60 PUSH1 0x01 0A31 60 PUSH1 0xe0 0A33 1B SHL 0A34 03 SUB 0A35 19 NOT 0A36 82 DUP3 0A37 16 AND 0A38 63 PUSH4 0x0101c115 0A3D 60 PUSH1 0xe7 0A3F 1B SHL 0A40 14 EQ 0A41 5B JUMPDEST 0A42 80 DUP1 0A43 61 PUSH2 0x0a5c 0A46 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0A40 stack[-1] = 0x0101c115 << 0xe7 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0a5c, if 0x0101c115 << 0xe7 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_0A47: // Incoming jump from 0x0A46, if not stack[-1] // Incoming jump from 0x0A46, if not 0x0101c115 << 0xe7 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0A51 stack[-3] } 0A47 50 POP 0A48 60 PUSH1 0x01 0A4A 60 PUSH1 0x01 0A4C 60 PUSH1 0xe0 0A4E 1B SHL 0A4F 03 SUB 0A50 19 NOT 0A51 82 DUP3 0A52 16 AND 0A53 63 PUSH4 0x24832483 0A58 60 PUSH1 0xe1 0A5A 1B SHL 0A5B 14 EQ 0A5C 5B JUMPDEST 0A5D 80 DUP1 0A5E 61 PUSH2 0x09b4 0A61 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0A5B stack[-1] = 0x24832483 << 0xe1 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x09b4, if 0x24832483 << 0xe1 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_0A62: // Incoming jump from 0x0A61, if not stack[-1] // Incoming jump from 0x0A61, if not 0x24832483 << 0xe1 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0A66 stack[-3] } 0A62 50 POP 0A63 61 PUSH2 0x09b4 0A66 82 DUP3 0A67 61 PUSH2 0x1520 0A6A 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0A63 stack[-1] = 0x09b4 // @0A66 stack[0] = stack[-3] // } // Block ends with call to 0x1520, returns to 0x09B4 label_0A6B: // Incoming jump from 0x0389 // Inputs[1] { @0A71 msg.sender } 0A6B 5B JUMPDEST 0A6C 61 PUSH2 0x0a76 0A6F 60 PUSH1 0x00 0A71 33 CALLER 0A72 61 PUSH2 0x0fdc 0A75 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A6C stack[0] = 0x0a76 // @0A6F stack[1] = 0x00 // @0A71 stack[2] = msg.sender // } // Block ends with call to 0x0fdc, returns to 0x0A76 label_0A76: // Incoming return from call to 0x0FDC at 0x0A75 // Inputs[1] { @0A7A stack[-1] } 0A76 5B JUMPDEST 0A77 61 PUSH2 0x0a93 0A7A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a93, if stack[-1] label_0A7B: // Incoming jump from 0x0A7A, if not stack[-1] // Inputs[3] // { // @0A7D memory[0x40:0x60] // @0A8D memory[0x40:0x60] // @0A92 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A7B 60 PUSH1 0x40 0A7D 51 MLOAD 0A7E 63 PUSH4 0x5ee82311 0A83 60 PUSH1 0xe0 0A85 1B SHL 0A86 81 DUP2 0A87 52 MSTORE 0A88 60 PUSH1 0x04 0A8A 01 ADD 0A8B 60 PUSH1 0x40 0A8D 51 MLOAD 0A8E 80 DUP1 0A8F 91 SWAP2 0A90 03 SUB 0A91 90 SWAP1 0A92 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A87 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5ee82311 << 0xe0 // @0A92 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0A93: // Incoming jump from 0x0A7A, if stack[-1] // Inputs[3] // { // @0AB6 storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a61d] // @0AC9 stack[-1] // @0ACF stack[-2] // } 0A93 5B JUMPDEST 0A94 7F PUSH32 0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a61d 0AB5 80 DUP1 0AB6 54 SLOAD 0AB7 60 PUSH1 0x01 0AB9 60 PUSH1 0x01 0ABB 60 PUSH1 0xa0 0ABD 1B SHL 0ABE 03 SUB 0ABF 19 NOT 0AC0 16 AND 0AC1 60 PUSH1 0x01 0AC3 60 PUSH1 0x01 0AC5 60 PUSH1 0xa0 0AC7 1B SHL 0AC8 03 SUB 0AC9 83 DUP4 0ACA 16 AND 0ACB 17 OR 0ACC 90 SWAP1 0ACD 55 SSTORE 0ACE 50 POP 0ACF 56 *JUMP // Stack delta = -2 // Outputs[1] { @0ACD storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a61d] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a61d]) } // Block ends with unconditional jump to stack[-2] label_0AD0: // Incoming jump from 0x2429, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x17A0 at 0x0C6E // Incoming jump from 0x245C, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1EE3 at 0x199F // Incoming jump from 0x25FC, if stack[-1] == !!stack[-1] // Incoming return from call to 0x1E10 at 0x146D // Incoming return from call to 0x1B56 at 0x143C // Incoming return from call to 0x1BA8 at 0x0FA7 // Inputs[1] { @0AD2 stack[-2] } 0AD0 5B JUMPDEST 0AD1 50 POP 0AD2 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0AD3: // Incoming jump from 0x03A9 // Inputs[1] { @0AD9 msg.sender } 0AD3 5B JUMPDEST 0AD4 61 PUSH2 0x0ade 0AD7 60 PUSH1 0x00 0AD9 33 CALLER 0ADA 61 PUSH2 0x0fdc 0ADD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AD4 stack[0] = 0x0ade // @0AD7 stack[1] = 0x00 // @0AD9 stack[2] = msg.sender // } // Block ends with call to 0x0fdc, returns to 0x0ADE label_0ADE: // Incoming return from call to 0x0FDC at 0x0ADD // Inputs[1] { @0AE2 stack[-1] } 0ADE 5B JUMPDEST 0ADF 61 PUSH2 0x0afb 0AE2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0afb, if stack[-1] label_0AE3: // Incoming jump from 0x0AE2, if not stack[-1] // Inputs[3] // { // @0AE5 memory[0x40:0x60] // @0AF5 memory[0x40:0x60] // @0AFA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0AE3 60 PUSH1 0x40 0AE5 51 MLOAD 0AE6 63 PUSH4 0x5ee82311 0AEB 60 PUSH1 0xe0 0AED 1B SHL 0AEE 81 DUP2 0AEF 52 MSTORE 0AF0 60 PUSH1 0x04 0AF2 01 ADD 0AF3 60 PUSH1 0x40 0AF5 51 MLOAD 0AF6 80 DUP1 0AF7 91 SWAP2 0AF8 03 SUB 0AF9 90 SWAP1 0AFA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0AEF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5ee82311 << 0xe0 // @0AFA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0AFB: // Incoming jump from 0x0AE2, if stack[-1] // Inputs[2] // { // @0AFF stack[-2] // @0B00 stack[-1] // } 0AFB 5B JUMPDEST 0AFC 61 PUSH2 0x0b05 0AFF 82 DUP3 0B00 82 DUP3 0B01 61 PUSH2 0x1545 0B04 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AFC stack[0] = 0x0b05 // @0AFF stack[1] = stack[-2] // @0B00 stack[2] = stack[-1] // } // Block ends with call to 0x1545, returns to 0x0B05 label_0B05: // Incoming jump from 0x16D9, if !(stack[-2] & (0x01 << 0xa0) - 0x01) // Incoming jump from 0x1EF1, if stack[-1] // Incoming return from call to 0x1A26 at 0x0DEE // Incoming return from call to 0x1D98 at 0x137A // Incoming return from call to 0x1FB7 at 0x1DDA // Incoming jump from 0x1A35, if !stack[-1] // Incoming return from call to 0x1545 at 0x0B04 // Incoming jump from 0x16E7, if stack[-1] // Inputs[1] { @0B08 stack[-3] } 0B05 5B JUMPDEST 0B06 50 POP 0B07 50 POP 0B08 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0B09: // Incoming call from 0x03BE, returns to 0x03BF // Inputs[1] { @0B0F storage[0x02] } 0B09 5B JUMPDEST 0B0A 60 PUSH1 0x60 0B0C 60 PUSH1 0x02 0B0E 80 DUP1 0B0F 54 SLOAD 0B10 61 PUSH2 0x0b18 0B13 90 SWAP1 0B14 61 PUSH2 0x2798 0B17 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B0A stack[0] = 0x60 // @0B0C stack[1] = 0x02 // @0B13 stack[2] = 0x0b18 // @0B13 stack[3] = storage[0x02] // } // Block ends with call to 0x2798, returns to 0x0B18 label_0B18: // Incoming return from call to 0x2798 at 0x0B17 // Incoming return from call to 0x2798 at 0x1015 // Inputs[4] // { // @0B19 stack[-1] // @0B28 memory[0x40:0x60] // @0B30 stack[-2] // @0B3B storage[stack[-2]] // } 0B18 5B JUMPDEST 0B19 80 DUP1 0B1A 60 PUSH1 0x1f 0B1C 01 ADD 0B1D 60 PUSH1 0x20 0B1F 80 DUP1 0B20 91 SWAP2 0B21 04 DIV 0B22 02 MUL 0B23 60 PUSH1 0x20 0B25 01 ADD 0B26 60 PUSH1 0x40 0B28 51 MLOAD 0B29 90 SWAP1 0B2A 81 DUP2 0B2B 01 ADD 0B2C 60 PUSH1 0x40 0B2E 52 MSTORE 0B2F 80 DUP1 0B30 92 SWAP3 0B31 91 SWAP2 0B32 90 SWAP1 0B33 81 DUP2 0B34 81 DUP2 0B35 52 MSTORE 0B36 60 PUSH1 0x20 0B38 01 ADD 0B39 82 DUP3 0B3A 80 DUP1 0B3B 54 SLOAD 0B3C 61 PUSH2 0x0b44 0B3F 90 SWAP1 0B40 61 PUSH2 0x2798 0B43 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0B2E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0B30 stack[-2] = memory[0x40:0x60] // @0B31 stack[-1] = stack[-2] // @0B32 stack[0] = stack[-1] // @0B35 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0B38 stack[1] = 0x20 + memory[0x40:0x60] // @0B39 stack[2] = stack[-2] // @0B3F stack[4] = storage[stack[-2]] // @0B3F stack[3] = 0x0b44 // } // Block ends with call to 0x2798, returns to 0x0B44 label_0B44: // Incoming return from call to 0x2798 at 0x0B43 // Inputs[1] { @0B45 stack[-1] } 0B44 5B JUMPDEST 0B45 80 DUP1 0B46 15 ISZERO 0B47 61 PUSH2 0x0b91 0B4A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b91, if !stack[-1] label_0B4B: // Incoming jump from 0x0B4A, if not !stack[-1] // Inputs[1] { @0B4B stack[-1] } 0B4B 80 DUP1 0B4C 60 PUSH1 0x1f 0B4E 10 LT 0B4F 61 PUSH2 0x0b66 0B52 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b66, if 0x1f < stack[-1] label_0B53: // Incoming jump from 0x0B52, if not 0x1f < stack[-1] // Inputs[4] // { // @0B57 stack[-2] // @0B58 storage[stack[-2]] // @0B5B stack[-3] // @0B5D stack[-1] // } 0B53 61 PUSH2 0x0100 0B56 80 DUP1 0B57 83 DUP4 0B58 54 SLOAD 0B59 04 DIV 0B5A 02 MUL 0B5B 83 DUP4 0B5C 52 MSTORE 0B5D 91 SWAP2 0B5E 60 PUSH1 0x20 0B60 01 ADD 0B61 91 SWAP2 0B62 61 PUSH2 0x0b91 0B65 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0B5C memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0B61 stack[-1] = stack[-1] // @0B61 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0b91 label_0B66: // Incoming jump from 0x0B52, if 0x1f < stack[-1] // Inputs[5] // { // @0B67 stack[-3] // @0B68 stack[-1] // @0B6A stack[-2] // @0B72 memory[0x00:0x20] // @0B76 storage[keccak256(memory[0x00:0x20])] // } 0B66 5B JUMPDEST 0B67 82 DUP3 0B68 01 ADD 0B69 91 SWAP2 0B6A 90 SWAP1 0B6B 60 PUSH1 0x00 0B6D 52 MSTORE 0B6E 60 PUSH1 0x20 0B70 60 PUSH1 0x00 0B72 20 SHA3 0B73 90 SWAP1 0B74 5B JUMPDEST 0B75 81 DUP2 0B76 54 SLOAD 0B77 81 DUP2 0B78 52 MSTORE 0B79 90 SWAP1 0B7A 60 PUSH1 0x01 0B7C 01 ADD 0B7D 90 SWAP1 0B7E 60 PUSH1 0x20 0B80 01 ADD 0B81 80 DUP1 0B82 83 DUP4 0B83 11 GT 0B84 61 PUSH2 0x0b74 0B87 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0B69 stack[-3] = stack[-3] + stack[-1] // @0B6D memory[0x00:0x20] = stack[-2] // @0B78 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0B7D stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0B80 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0b74, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0B88: // Incoming jump from 0x0B87, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0B87, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0B88 stack[-3] // @0B89 stack[-1] // } 0B88 82 DUP3 0B89 90 SWAP1 0B8A 03 SUB 0B8B 60 PUSH1 0x1f 0B8D 16 AND 0B8E 82 DUP3 0B8F 01 ADD 0B90 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0B90 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0B90 stack[-1] = stack[-3] // } // Block continues label_0B91: // Incoming jump from 0x0B65 // Incoming jump from 0x0B4A, if !stack[-1] // Incoming jump from 0x0B90 // Inputs[3] // { // @0B97 stack[-7] // @0B97 stack[-6] // @0B99 stack[-8] // } 0B91 5B JUMPDEST 0B92 50 POP 0B93 50 POP 0B94 50 POP 0B95 50 POP 0B96 50 POP 0B97 90 SWAP1 0B98 50 POP 0B99 90 SWAP1 0B9A 56 *JUMP // Stack delta = -7 // Outputs[1] { @0B99 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0B9B: // Incoming jump from 0x03EB // Inputs[1] { @0B9E storage[0x0b] } 0B9B 5B JUMPDEST 0B9C 60 PUSH1 0x0b 0B9E 54 SLOAD 0B9F 60 PUSH1 0x00 0BA1 90 SWAP1 0BA2 61 PUSH2 0x0100 0BA5 90 SWAP1 0BA6 04 DIV 0BA7 60 PUSH1 0xff 0BA9 16 AND 0BAA 15 ISZERO 0BAB 61 PUSH2 0x0bb6 0BAE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BA1 stack[0] = 0x00 } // Block ends with conditional jump to 0x0bb6, if !(0xff & storage[0x0b] / 0x0100) label_0BAF: // Incoming jump from 0x0BAE, if not !(0xff & storage[0x0b] / 0x0100) // Inputs[2] // { // @0BB2 stack[-3] // @0BB3 stack[-2] // } 0BAF 50 POP 0BB0 60 PUSH1 0x00 0BB2 91 SWAP2 0BB3 90 SWAP1 0BB4 50 POP 0BB5 56 *JUMP // Stack delta = -2 // Outputs[1] { @0BB2 stack[-3] = 0x00 } // Block ends with unconditional jump to stack[-3] label_0BB6: // Incoming jump from 0x0BAE, if !(0xff & storage[0x0b] / 0x0100) // Inputs[1] { @0BBA stack[-2] } 0BB6 5B JUMPDEST 0BB7 61 PUSH2 0x09b4 0BBA 82 DUP3 0BBB 61 PUSH2 0x1642 0BBE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0BB7 stack[0] = 0x09b4 // @0BBA stack[1] = stack[-2] // } // Block ends with call to 0x1642, returns to 0x09B4 label_0BBF: // Incoming jump from 0x0416 // Inputs[1] { @0BC0 stack[-2] } 0BBF 5B JUMPDEST 0BC0 81 DUP2 0BC1 73 PUSH20 0x1e0049783f008a0085193e00003d00cd54003c71 0BD6 60 PUSH1 0x01 0BD8 60 PUSH1 0x01 0BDA 60 PUSH1 0xa0 0BDC 1B SHL 0BDD 03 SUB 0BDE 82 DUP3 0BDF 16 AND 0BE0 14 EQ 0BE1 61 PUSH2 0x0bf8 0BE4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BC0 stack[0] = stack[-2] } // Block ends with conditional jump to 0x0bf8, if stack[-2] & (0x01 << 0xa0) - 0x01 == 0x1e0049783f008a0085193e00003d00cd54003c71 label_0BE5: // Incoming jump from 0x0BE4, if not stack[-2] & (0x01 << 0xa0) - 0x01 == 0x1e0049783f008a0085193e00003d00cd54003c71 // Inputs[1] { @0BE7 storage[0x0b] } 0BE5 60 PUSH1 0x0b 0BE7 54 SLOAD 0BE8 60 PUSH1 0xff 0BEA 16 AND 0BEB 15 ISZERO 0BEC 61 PUSH2 0x0bf8 0BEF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bf8, if !(0xff & storage[0x0b]) label_0BF0: // Incoming jump from 0x0BEF, if not !(0xff & storage[0x0b]) // Inputs[1] { @0BF3 stack[-1] } 0BF0 61 PUSH2 0x0bf8 0BF3 81 DUP2 0BF4 61 PUSH2 0x1686 0BF7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0BF0 stack[0] = 0x0bf8 // @0BF3 stack[1] = stack[-1] // } // Block ends with call to 0x1686, returns to 0x0BF8 label_0BF8: // Incoming jump from 0x0BE4, if stack[-2] & (0x01 << 0xa0) - 0x01 == 0x1e0049783f008a0085193e00003d00cd54003c71 // Incoming return from call to 0x1686 at 0x0BF7 // Incoming jump from 0x0BEF, if !(0xff & storage[0x0b]) // Inputs[2] // { // @0BF9 stack[-3] // @0BFA stack[-2] // } 0BF8 5B JUMPDEST 0BF9 82 DUP3 0BFA 82 DUP3 0BFB 61 PUSH2 0x0c04 0BFE 82 DUP3 0BFF 82 DUP3 0C00 61 PUSH2 0x16ca 0C03 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0BF9 stack[0] = stack[-3] // @0BFA stack[1] = stack[-2] // @0BFB stack[2] = 0x0c04 // @0BFE stack[3] = stack[-3] // @0BFF stack[4] = stack[-2] // } // Block ends with call to 0x16ca, returns to 0x0C04 label_0C04: // Incoming return from call to 0x16CA at 0x0C03 // Inputs[1] { @0C07 storage[0x0b] } 0C04 5B JUMPDEST 0C05 60 PUSH1 0x0b 0C07 54 SLOAD 0C08 61 PUSH2 0x0100 0C0B 90 SWAP1 0C0C 04 DIV 0C0D 60 PUSH1 0xff 0C0F 16 AND 0C10 15 ISZERO 0C11 61 PUSH2 0x0c2d 0C14 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c2d, if !(0xff & storage[0x0b] / 0x0100) label_0C15: // Incoming jump from 0x0C14, if not !(0xff & storage[0x0b] / 0x0100) // Inputs[3] // { // @0C17 memory[0x40:0x60] // @0C27 memory[0x40:0x60] // @0C2C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C15 60 PUSH1 0x40 0C17 51 MLOAD 0C18 63 PUSH4 0x7a5418c3 0C1D 60 PUSH1 0xe1 0C1F 1B SHL 0C20 81 DUP2 0C21 52 MSTORE 0C22 60 PUSH1 0x04 0C24 01 ADD 0C25 60 PUSH1 0x40 0C27 51 MLOAD 0C28 80 DUP1 0C29 91 SWAP2 0C2A 03 SUB 0C2B 90 SWAP1 0C2C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C21 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x7a5418c3 << 0xe1 // @0C2C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C2D: // Incoming jump from 0x0C14, if !(0xff & storage[0x0b] / 0x0100) // Inputs[2] // { // @0C31 stack[-5] // @0C32 stack[-4] // } 0C2D 5B JUMPDEST 0C2E 61 PUSH2 0x0c37 0C31 85 DUP6 0C32 85 DUP6 0C33 61 PUSH2 0x1700 0C36 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C2E stack[0] = 0x0c37 // @0C31 stack[1] = stack[-5] // @0C32 stack[2] = stack[-4] // } // Block ends with call to 0x1700, returns to 0x0C37 label_0C37: // Incoming return from call to 0x1700 at 0x0C36 // Inputs[1] { @0C3D stack[-6] } 0C37 5B JUMPDEST 0C38 50 POP 0C39 50 POP 0C3A 50 POP 0C3B 50 POP 0C3C 50 POP 0C3D 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_0C3E: // Incoming jump from 0x046D // Inputs[1] { @0C44 msg.sender } 0C3E 5B JUMPDEST 0C3F 61 PUSH2 0x0c49 0C42 60 PUSH1 0x00 0C44 33 CALLER 0C45 61 PUSH2 0x0fdc 0C48 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C3F stack[0] = 0x0c49 // @0C42 stack[1] = 0x00 // @0C44 stack[2] = msg.sender // } // Block ends with call to 0x0fdc, returns to 0x0C49 label_0C49: // Incoming return from call to 0x0FDC at 0x0C48 // Inputs[1] { @0C4D stack[-1] } 0C49 5B JUMPDEST 0C4A 61 PUSH2 0x0c66 0C4D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c66, if stack[-1] label_0C4E: // Incoming jump from 0x0C4D, if not stack[-1] // Inputs[3] // { // @0C50 memory[0x40:0x60] // @0C60 memory[0x40:0x60] // @0C65 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C4E 60 PUSH1 0x40 0C50 51 MLOAD 0C51 63 PUSH4 0x5ee82311 0C56 60 PUSH1 0xe0 0C58 1B SHL 0C59 81 DUP2 0C5A 52 MSTORE 0C5B 60 PUSH1 0x04 0C5D 01 ADD 0C5E 60 PUSH1 0x40 0C60 51 MLOAD 0C61 80 DUP1 0C62 91 SWAP2 0C63 03 SUB 0C64 90 SWAP1 0C65 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C5A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5ee82311 << 0xe0 // @0C65 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C66: // Incoming jump from 0x0C4D, if stack[-1] // Inputs[1] { @0C6A stack[-1] } 0C66 5B JUMPDEST 0C67 61 PUSH2 0x0ad0 0C6A 81 DUP2 0C6B 61 PUSH2 0x17a0 0C6E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C67 stack[0] = 0x0ad0 // @0C6A stack[1] = stack[-1] // } // Block ends with call to 0x17a0, returns to 0x0AD0 label_0C6F: // Incoming jump from 0x113B // Incoming jump from 0x04A7 // Inputs[2] // { // @0C70 stack[-3] // @0C7B msg.sender // } 0C6F 5B JUMPDEST 0C70 82 DUP3 0C71 60 PUSH1 0x01 0C73 60 PUSH1 0x01 0C75 60 PUSH1 0xa0 0C77 1B SHL 0C78 03 SUB 0C79 81 DUP2 0C7A 16 AND 0C7B 33 CALLER 0C7C 14 EQ 0C7D 61 PUSH2 0x0caf 0C80 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C70 stack[0] = stack[-3] } // Block ends with conditional jump to 0x0caf, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 label_0C81: // Incoming jump from 0x0C80, if not msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0C96 msg.sender } 0C81 73 PUSH20 0x1e0049783f008a0085193e00003d00cd54003c71 0C96 33 CALLER 0C97 14 EQ 0C98 61 PUSH2 0x0caf 0C9B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0caf, if msg.sender == 0x1e0049783f008a0085193e00003d00cd54003c71 label_0C9C: // Incoming jump from 0x0C9B, if not msg.sender == 0x1e0049783f008a0085193e00003d00cd54003c71 // Inputs[1] { @0C9E storage[0x0b] } 0C9C 60 PUSH1 0x0b 0C9E 54 SLOAD 0C9F 60 PUSH1 0xff 0CA1 16 AND 0CA2 15 ISZERO 0CA3 61 PUSH2 0x0caf 0CA6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0caf, if !(0xff & storage[0x0b]) label_0CA7: // Incoming jump from 0x0CA6, if not !(0xff & storage[0x0b]) // Inputs[1] { @0CAA msg.sender } 0CA7 61 PUSH2 0x0caf 0CAA 33 CALLER 0CAB 61 PUSH2 0x1686 0CAE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0CA7 stack[0] = 0x0caf // @0CAA stack[1] = msg.sender // } // Block ends with call to 0x1686, returns to 0x0CAF label_0CAF: // Incoming jump from 0x0CA6, if !(0xff & storage[0x0b]) // Incoming jump from 0x0C80, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x1686 at 0x0CAE // Incoming jump from 0x0C9B, if msg.sender == 0x1e0049783f008a0085193e00003d00cd54003c71 // Inputs[1] { @0CB2 storage[0x0b] } 0CAF 5B JUMPDEST 0CB0 60 PUSH1 0x0b 0CB2 54 SLOAD 0CB3 61 PUSH2 0x0100 0CB6 90 SWAP1 0CB7 04 DIV 0CB8 60 PUSH1 0xff 0CBA 16 AND 0CBB 15 ISZERO 0CBC 61 PUSH2 0x0cd8 0CBF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cd8, if !(0xff & storage[0x0b] / 0x0100) label_0CC0: // Incoming jump from 0x0CBF, if not !(0xff & storage[0x0b] / 0x0100) // Inputs[3] // { // @0CC2 memory[0x40:0x60] // @0CD2 memory[0x40:0x60] // @0CD7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0CC0 60 PUSH1 0x40 0CC2 51 MLOAD 0CC3 63 PUSH4 0x7d79d205 0CC8 60 PUSH1 0xe0 0CCA 1B SHL 0CCB 81 DUP2 0CCC 52 MSTORE 0CCD 60 PUSH1 0x04 0CCF 01 ADD 0CD0 60 PUSH1 0x40 0CD2 51 MLOAD 0CD3 80 DUP1 0CD4 91 SWAP2 0CD5 03 SUB 0CD6 90 SWAP1 0CD7 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0CCC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x7d79d205 << 0xe0 // @0CD7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0CD8: // Incoming jump from 0x0CBF, if !(0xff & storage[0x0b] / 0x0100) // Inputs[3] // { // @0CDC stack[-4] // @0CDD stack[-3] // @0CDE stack[-2] // } 0CD8 5B JUMPDEST 0CD9 61 PUSH2 0x0ce3 0CDC 84 DUP5 0CDD 84 DUP5 0CDE 84 DUP5 0CDF 61 PUSH2 0x17f4 0CE2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0CD9 stack[0] = 0x0ce3 // @0CDC stack[1] = stack[-4] // @0CDD stack[2] = stack[-3] // @0CDE stack[3] = stack[-2] // } // Block ends with call to 0x17f4, returns to 0x0CE3 label_0CE3: // Incoming return from call to 0x17F4 at 0x0CE2 // Incoming jump from 0x20DB // Inputs[1] { @0CE8 stack[-5] } 0CE3 5B JUMPDEST 0CE4 50 POP 0CE5 50 POP 0CE6 50 POP 0CE7 50 POP 0CE8 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0CE9: // Incoming jump from 0x04F7 // Inputs[3] // { // @0CED memory[0x40:0x60] // @0CF6 storage[0x0a] // @0D29 stack[-1] // } 0CE9 5B JUMPDEST 0CEA 60 PUSH1 0x40 0CEC 80 DUP1 0CED 51 MLOAD 0CEE 80 DUP1 0CEF 82 DUP3 0CF0 01 ADD 0CF1 90 SWAP1 0CF2 91 SWAP2 0CF3 52 MSTORE 0CF4 60 PUSH1 0x0a 0CF6 54 SLOAD 0CF7 60 PUSH1 0x01 0CF9 60 PUSH1 0x01 0CFB 60 PUSH1 0xa0 0CFD 1B SHL 0CFE 03 SUB 0CFF 81 DUP2 0D00 16 AND 0D01 82 DUP3 0D02 52 MSTORE 0D03 60 PUSH1 0x01 0D05 60 PUSH1 0xa0 0D07 1B SHL 0D08 90 SWAP1 0D09 04 DIV 0D0A 60 PUSH1 0x01 0D0C 60 PUSH1 0x01 0D0E 60 PUSH1 0x60 0D10 1B SHL 0D11 03 SUB 0D12 16 AND 0D13 60 PUSH1 0x20 0D15 82 DUP3 0D16 01 ADD 0D17 81 DUP2 0D18 90 SWAP1 0D19 52 MSTORE 0D1A 60 PUSH1 0x00 0D1C 91 SWAP2 0D1D 82 DUP3 0D1E 91 SWAP2 0D1F 82 DUP3 0D20 90 SWAP1 0D21 61 PUSH2 0x2710 0D24 90 SWAP1 0D25 61 PUSH2 0x0d2e 0D28 90 SWAP1 0D29 87 DUP8 0D2A 61 PUSH2 0x27e8 0D2D 56 *JUMP // Stack delta = +8 // Outputs[11] // { // @0CF3 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0D02 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x0a] & (0x01 << 0xa0) - 0x01 // @0D19 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x60) - 0x01 & storage[0x0a] / (0x01 << 0xa0) // @0D1C stack[0] = 0x00 // @0D1C stack[2] = memory[0x40:0x60] // @0D1E stack[1] = 0x00 // @0D20 stack[3] = 0x00 // @0D24 stack[4] = 0x2710 // @0D28 stack[5] = 0x0d2e // @0D28 stack[6] = (0x01 << 0x60) - 0x01 & storage[0x0a] / (0x01 << 0xa0) // @0D29 stack[7] = stack[-1] // } // Block ends with call to 0x27e8, returns to 0x0D2E label_0D2E: // Incoming return from call to 0x27E8 at 0x0D2D // Inputs[2] // { // @0D32 stack[-2] // @0D33 stack[-1] // } 0D2E 5B JUMPDEST 0D2F 61 PUSH2 0x0d38 0D32 91 SWAP2 0D33 90 SWAP1 0D34 61 PUSH2 0x27ff 0D37 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0D32 stack[-2] = 0x0d38 // @0D33 stack[-1] = stack[-2] // @0D33 stack[0] = stack[-1] // } // Block ends with call to 0x27ff, returns to 0x0D38 label_0D38: // Incoming return from call to 0x27FF at 0x0D37 // Inputs[7] // { // @0D39 stack[-1] // @0D39 stack[-3] // @0D3A memory[stack[-3]:stack[-3] + 0x20] // @0D3B stack[-8] // @0D3D stack[-7] // @0D3F stack[-2] // @0D40 stack[-6] // } 0D38 5B JUMPDEST 0D39 91 SWAP2 0D3A 51 MLOAD 0D3B 96 SWAP7 0D3C 91 SWAP2 0D3D 95 SWAP6 0D3E 50 POP 0D3F 90 SWAP1 0D40 93 SWAP4 0D41 50 POP 0D42 50 POP 0D43 50 POP 0D44 50 POP 0D45 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @0D3B stack[-8] = memory[stack[-3]:stack[-3] + 0x20] // @0D3D stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_0D46: // Incoming jump from 0x0536 // Inputs[3] // { // @0D49 stack[-2] // @0D54 memory[0x00:0x40] // @0D58 storage[0x01 + keccak256(memory[0x00:0x40])] // } 0D46 5B JUMPDEST 0D47 60 PUSH1 0x00 0D49 82 DUP3 0D4A 81 DUP2 0D4B 52 MSTORE 0D4C 60 PUSH1 0x09 0D4E 60 PUSH1 0x20 0D50 52 MSTORE 0D51 60 PUSH1 0x40 0D53 90 SWAP1 0D54 20 SHA3 0D55 60 PUSH1 0x01 0D57 01 ADD 0D58 54 SLOAD 0D59 61 PUSH2 0x0d61 0D5C 81 DUP2 0D5D 61 PUSH2 0x1996 0D60 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0D4B memory[0x00:0x20] = stack[-2] // @0D50 memory[0x20:0x40] = 0x09 // @0D58 stack[0] = storage[0x01 + keccak256(memory[0x00:0x40])] // @0D59 stack[1] = 0x0d61 // @0D5C stack[2] = storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x1996 0D61 5B JUMPDEST 0D62 61 PUSH2 0x0d6b 0D65 83 DUP4 0D66 83 DUP4 0D67 61 PUSH2 0x19a0 0D6A 56 *JUMP 0D6B 5B JUMPDEST 0D6C 50 POP 0D6D 50 POP 0D6E 50 POP 0D6F 56 *JUMP label_0D70: // Incoming jump from 0x05B1 // Inputs[2] // { // @0D79 stack[-1] // @0D7B msg.sender // } 0D70 5B JUMPDEST 0D71 60 PUSH1 0x01 0D73 60 PUSH1 0x01 0D75 60 PUSH1 0xa0 0D77 1B SHL 0D78 03 SUB 0D79 81 DUP2 0D7A 16 AND 0D7B 33 CALLER 0D7C 14 EQ 0D7D 61 PUSH2 0x0de5 0D80 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0de5, if msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 label_0D81: // Incoming jump from 0x0D80, if not msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0D83 memory[0x40:0x60] } 0D81 60 PUSH1 0x40 0D83 51 MLOAD 0D84 62 PUSH3 0x461bcd 0D88 60 PUSH1 0xe5 0D8A 1B SHL 0D8B 81 DUP2 0D8C 52 MSTORE 0D8D 60 PUSH1 0x20 0D8F 60 PUSH1 0x04 0D91 82 DUP3 0D92 01 ADD 0D93 52 MSTORE 0D94 60 PUSH1 0x2f 0D96 60 PUSH1 0x24 0D98 82 DUP3 0D99 01 ADD 0D9A 52 MSTORE 0D9B 7F PUSH32 0x416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e6365 0DBC 60 PUSH1 0x44 0DBE 82 DUP3 0DBF 01 ADD 0DC0 52 MSTORE 0DC1 6E PUSH15 0x103937b632b9903337b91039b2b633 0DD1 60 PUSH1 0x89 0DD3 1B SHL 0DD4 60 PUSH1 0x64 0DD6 82 DUP3 0DD7 01 ADD 0DD8 52 MSTORE 0DD9 60 PUSH1 0x84 0DDB 01 ADD // Stack delta = +1 // Outputs[6] // { // @0D8C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D93 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D9A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @0DC0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e6365 // @0DD8 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x103937b632b9903337b91039b2b633 << 0x89 // @0DDB stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_0DDC: // Incoming jump from 0x2289 // Incoming jump from 0x1B55 // Incoming jump from 0x15B2 // Incoming jump from 0x0DDB // Incoming jump from 0x1608 // Incoming jump from 0x1433 // Inputs[3] // { // @0DDF memory[0x40:0x60] // @0DE1 stack[-1] // @0DE4 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0DDC 5B JUMPDEST 0DDD 60 PUSH1 0x40 0DDF 51 MLOAD 0DE0 80 DUP1 0DE1 91 SWAP2 0DE2 03 SUB 0DE3 90 SWAP1 0DE4 FD *REVERT // Stack delta = -1 // Outputs[1] { @0DE4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0DE5: // Incoming jump from 0x0D80, if msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0DE9 stack[-2] // @0DEA stack[-1] // } 0DE5 5B JUMPDEST 0DE6 61 PUSH2 0x0b05 0DE9 82 DUP3 0DEA 82 DUP3 0DEB 61 PUSH2 0x1a26 0DEE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DE6 stack[0] = 0x0b05 // @0DE9 stack[1] = stack[-2] // @0DEA stack[2] = stack[-1] // } // Block ends with call to 0x1a26, returns to 0x0B05 label_0DEF: // Incoming jump from 0x0601 // Inputs[4] // { // @0DF3 stack[-3] // @0DF4 stack[-2] // @0DF5 stack[-1] // @0DF8 memory[0x40:0x60] // } 0DEF 5B JUMPDEST 0DF0 61 PUSH2 0x0d6b 0DF3 83 DUP4 0DF4 83 DUP4 0DF5 83 DUP4 0DF6 60 PUSH1 0x40 0DF8 51 MLOAD 0DF9 80 DUP1 0DFA 60 PUSH1 0x20 0DFC 01 ADD 0DFD 60 PUSH1 0x40 0DFF 52 MSTORE 0E00 80 DUP1 0E01 60 PUSH1 0x00 0E03 81 DUP2 0E04 52 MSTORE 0E05 50 POP 0E06 61 PUSH2 0x1131 0E09 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0DF0 stack[0] = 0x0d6b // @0DF3 stack[1] = stack[-3] // @0DF4 stack[2] = stack[-2] // @0DF5 stack[3] = stack[-1] // @0DF8 stack[4] = memory[0x40:0x60] // @0DFF memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0E04 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x1131 label_0E0A: // Incoming jump from 0x0655 // Inputs[1] { @0E10 msg.sender } 0E0A 5B JUMPDEST 0E0B 61 PUSH2 0x0e15 0E0E 60 PUSH1 0x00 0E10 33 CALLER 0E11 61 PUSH2 0x0fdc 0E14 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E0B stack[0] = 0x0e15 // @0E0E stack[1] = 0x00 // @0E10 stack[2] = msg.sender // } // Block ends with call to 0x0fdc, returns to 0x0E15 label_0E15: // Incoming return from call to 0x0FDC at 0x0E14 // Inputs[1] { @0E19 stack[-1] } 0E15 5B JUMPDEST 0E16 61 PUSH2 0x0e32 0E19 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e32, if stack[-1] label_0E1A: // Incoming jump from 0x0E19, if not stack[-1] // Inputs[3] // { // @0E1C memory[0x40:0x60] // @0E2C memory[0x40:0x60] // @0E31 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E1A 60 PUSH1 0x40 0E1C 51 MLOAD 0E1D 63 PUSH4 0x5ee82311 0E22 60 PUSH1 0xe0 0E24 1B SHL 0E25 81 DUP2 0E26 52 MSTORE 0E27 60 PUSH1 0x04 0E29 01 ADD 0E2A 60 PUSH1 0x40 0E2C 51 MLOAD 0E2D 80 DUP1 0E2E 91 SWAP2 0E2F 03 SUB 0E30 90 SWAP1 0E31 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0E26 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5ee82311 << 0xe0 // @0E31 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0E32: // Incoming jump from 0x0E19, if stack[-1] // Inputs[3] // { // @0E36 storage[0x0b] // @0E37 stack[-1] // @0E4B stack[-2] // } 0E32 5B JUMPDEST 0E33 60 PUSH1 0x0b 0E35 80 DUP1 0E36 54 SLOAD 0E37 91 SWAP2 0E38 15 ISZERO 0E39 15 ISZERO 0E3A 61 PUSH2 0x0100 0E3D 02 MUL 0E3E 61 PUSH2 0xff00 0E41 19 NOT 0E42 90 SWAP1 0E43 92 SWAP3 0E44 16 AND 0E45 91 SWAP2 0E46 90 SWAP1 0E47 91 SWAP2 0E48 17 OR 0E49 90 SWAP1 0E4A 55 SSTORE 0E4B 56 *JUMP // Stack delta = -2 // Outputs[1] { @0E4A storage[0x0b] = (storage[0x0b] & ~0xff00) | 0x0100 * !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_0E4C: // Incoming jump from 0x0675 // Inputs[1] { @0E52 msg.sender } 0E4C 5B JUMPDEST 0E4D 61 PUSH2 0x0e57 0E50 60 PUSH1 0x00 0E52 33 CALLER 0E53 61 PUSH2 0x0fdc 0E56 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E4D stack[0] = 0x0e57 // @0E50 stack[1] = 0x00 // @0E52 stack[2] = msg.sender // } // Block ends with call to 0x0fdc, returns to 0x0E57 label_0E57: // Incoming return from call to 0x0FDC at 0x0E56 // Inputs[1] { @0E5B stack[-1] } 0E57 5B JUMPDEST 0E58 61 PUSH2 0x0e74 0E5B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e74, if stack[-1] label_0E5C: // Incoming jump from 0x0E5B, if not stack[-1] // Inputs[3] // { // @0E5E memory[0x40:0x60] // @0E6E memory[0x40:0x60] // @0E73 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E5C 60 PUSH1 0x40 0E5E 51 MLOAD 0E5F 63 PUSH4 0x5ee82311 0E64 60 PUSH1 0xe0 0E66 1B SHL 0E67 81 DUP2 0E68 52 MSTORE 0E69 60 PUSH1 0x04 0E6B 01 ADD 0E6C 60 PUSH1 0x40 0E6E 51 MLOAD 0E6F 80 DUP1 0E70 91 SWAP2 0E71 03 SUB 0E72 90 SWAP1 0E73 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0E68 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5ee82311 << 0xe0 // @0E73 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0E74: // Incoming jump from 0x0E5B, if stack[-1] // Inputs[6] // { // @0E78 memory[0x40:0x60] // @0E79 stack[-2] // @0E80 stack[-1] // @0EA8 memory[0x40:0x60] // @0EAD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0EB0 stack[-3] // } 0E74 5B JUMPDEST 0E75 60 PUSH1 0x40 0E77 80 DUP1 0E78 51 MLOAD 0E79 83 DUP4 0E7A 81 DUP2 0E7B 52 MSTORE 0E7C 60 PUSH1 0x20 0E7E 81 DUP2 0E7F 01 ADD 0E80 83 DUP4 0E81 90 SWAP1 0E82 52 MSTORE 0E83 7F PUSH32 0x6bd5c950a8d8df17f772f5af37cb3655737899cbf903264b9795592da439661c 0EA4 91 SWAP2 0EA5 01 ADD 0EA6 60 PUSH1 0x40 0EA8 51 MLOAD 0EA9 80 DUP1 0EAA 91 SWAP2 0EAB 03 SUB 0EAC 90 SWAP1 0EAD A1 LOG1 0EAE 50 POP 0EAF 50 POP 0EB0 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0E7B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0E82 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @0EAD log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x6bd5c950a8d8df17f772f5af37cb3655737899cbf903264b9795592da439661c]); // } // Block ends with unconditional jump to stack[-3] label_0EB1: // Incoming call from 0x170A, returns to 0x170B // Incoming jump from 0x0695 // Inputs[1] { @0EB7 stack[-1] } 0EB1 5B JUMPDEST 0EB2 60 PUSH1 0x00 0EB4 61 PUSH2 0x09b4 0EB7 82 DUP3 0EB8 61 PUSH2 0x1a8d 0EBB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0EB2 stack[0] = 0x00 // @0EB4 stack[1] = 0x09b4 // @0EB7 stack[2] = stack[-1] // } // Block ends with call to 0x1a8d, returns to 0x09B4 label_0EBC: // Incoming jump from 0x06B5 // Inputs[1] { @0EC2 msg.sender } 0EBC 5B JUMPDEST 0EBD 61 PUSH2 0x0ec7 0EC0 60 PUSH1 0x00 0EC2 33 CALLER 0EC3 61 PUSH2 0x0fdc 0EC6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0EBD stack[0] = 0x0ec7 // @0EC0 stack[1] = 0x00 // @0EC2 stack[2] = msg.sender // } // Block ends with call to 0x0fdc, returns to 0x0EC7 label_0EC7: // Incoming return from call to 0x0FDC at 0x0EC6 // Inputs[1] { @0ECB stack[-1] } 0EC7 5B JUMPDEST 0EC8 61 PUSH2 0x0ee4 0ECB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ee4, if stack[-1] label_0ECC: // Incoming jump from 0x0ECB, if not stack[-1] // Inputs[3] // { // @0ECE memory[0x40:0x60] // @0EDE memory[0x40:0x60] // @0EE3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0ECC 60 PUSH1 0x40 0ECE 51 MLOAD 0ECF 63 PUSH4 0x5ee82311 0ED4 60 PUSH1 0xe0 0ED6 1B SHL 0ED7 81 DUP2 0ED8 52 MSTORE 0ED9 60 PUSH1 0x04 0EDB 01 ADD 0EDC 60 PUSH1 0x40 0EDE 51 MLOAD 0EDF 80 DUP1 0EE0 91 SWAP2 0EE1 03 SUB 0EE2 90 SWAP1 0EE3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0ED8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5ee82311 << 0xe0 // @0EE3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0EE4: // Incoming jump from 0x0ECB, if stack[-1] // Inputs[3] // { // @0F07 storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a620] // @0F0C stack[-1] // @0F13 stack[-2] // } 0EE4 5B JUMPDEST 0EE5 7F PUSH32 0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a620 0F06 80 DUP1 0F07 54 SLOAD 0F08 60 PUSH1 0xff 0F0A 19 NOT 0F0B 16 AND 0F0C 82 DUP3 0F0D 15 ISZERO 0F0E 15 ISZERO 0F0F 17 OR 0F10 90 SWAP1 0F11 55 SSTORE 0F12 50 POP 0F13 56 *JUMP // Stack delta = -2 // Outputs[1] { @0F11 storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a620] = !!stack[-1] | (~0xff & storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a620]) } // Block ends with unconditional jump to stack[-2] label_0F14: // Incoming jump from 0x06FD // Inputs[1] { @0F1F stack[-1] } 0F14 5B JUMPDEST 0F15 60 PUSH1 0x00 0F17 60 PUSH1 0x01 0F19 60 PUSH1 0x01 0F1B 60 PUSH1 0xa0 0F1D 1B SHL 0F1E 03 SUB 0F1F 82 DUP3 0F20 16 AND 0F21 61 PUSH2 0x0f3d 0F24 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0F15 stack[0] = 0x00 } // Block ends with conditional jump to 0x0f3d, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0F25: // Incoming jump from 0x0F24, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0F27 memory[0x40:0x60] // @0F37 memory[0x40:0x60] // @0F3C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F25 60 PUSH1 0x40 0F27 51 MLOAD 0F28 63 PUSH4 0x23d3ad81 0F2D 60 PUSH1 0xe2 0F2F 1B SHL 0F30 81 DUP2 0F31 52 MSTORE 0F32 60 PUSH1 0x04 0F34 01 ADD 0F35 60 PUSH1 0x40 0F37 51 MLOAD 0F38 80 DUP1 0F39 91 SWAP2 0F3A 03 SUB 0F3B 90 SWAP1 0F3C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F31 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x23d3ad81 << 0xe2 // @0F3C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F3D: // Incoming jump from 0x0F24, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0F47 stack[-2] // @0F55 memory[0x00:0x40] // @0F56 storage[keccak256(memory[0x00:0x40])] // @0F61 stack[-3] // } 0F3D 5B JUMPDEST 0F3E 50 POP 0F3F 60 PUSH1 0x01 0F41 60 PUSH1 0x01 0F43 60 PUSH1 0xa0 0F45 1B SHL 0F46 03 SUB 0F47 16 AND 0F48 60 PUSH1 0x00 0F4A 90 SWAP1 0F4B 81 DUP2 0F4C 52 MSTORE 0F4D 60 PUSH1 0x05 0F4F 60 PUSH1 0x20 0F51 52 MSTORE 0F52 60 PUSH1 0x40 0F54 90 SWAP1 0F55 20 SHA3 0F56 54 SLOAD 0F57 67 PUSH8 0xffffffffffffffff 0F60 16 AND 0F61 90 SWAP1 0F62 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0F4C memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0F51 memory[0x20:0x40] = 0x05 // @0F61 stack[-3] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0F63: // Incoming jump from 0x0712 0F63 5B JUMPDEST 0F64 61 PUSH2 0x0f6b 0F67 61 PUSH2 0x1afc 0F6A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F64 stack[0] = 0x0f6b } // Block ends with call to 0x1afc, returns to 0x0F6B label_0F6B: // Incoming return from call to 0x1AFC at 0x0F6A 0F6B 5B JUMPDEST 0F6C 61 PUSH2 0x0f75 0F6F 60 PUSH1 0x00 0F71 61 PUSH2 0x1b56 0F74 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0F6C stack[0] = 0x0f75 // @0F6F stack[1] = 0x00 // } // Block ends with call to 0x1b56, returns to 0x0F75 label_0F75: // Incoming jump from 0x1B0E, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Incoming return from call to 0x1B56 at 0x0F74 // Inputs[1] { @0F76 stack[-1] } 0F75 5B JUMPDEST 0F76 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0F77: // Incoming jump from 0x0732 // Inputs[1] { @0F7D msg.sender } 0F77 5B JUMPDEST 0F78 61 PUSH2 0x0f82 0F7B 60 PUSH1 0x00 0F7D 33 CALLER 0F7E 61 PUSH2 0x0fdc 0F81 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F78 stack[0] = 0x0f82 // @0F7B stack[1] = 0x00 // @0F7D stack[2] = msg.sender // } // Block ends with call to 0x0fdc, returns to 0x0F82 label_0F82: // Incoming return from call to 0x0FDC at 0x0F81 // Inputs[1] { @0F86 stack[-1] } 0F82 5B JUMPDEST 0F83 61 PUSH2 0x0f9f 0F86 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f9f, if stack[-1] label_0F87: // Incoming jump from 0x0F86, if not stack[-1] // Inputs[3] // { // @0F89 memory[0x40:0x60] // @0F99 memory[0x40:0x60] // @0F9E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F87 60 PUSH1 0x40 0F89 51 MLOAD 0F8A 63 PUSH4 0x5ee82311 0F8F 60 PUSH1 0xe0 0F91 1B SHL 0F92 81 DUP2 0F93 52 MSTORE 0F94 60 PUSH1 0x04 0F96 01 ADD 0F97 60 PUSH1 0x40 0F99 51 MLOAD 0F9A 80 DUP1 0F9B 91 SWAP2 0F9C 03 SUB 0F9D 90 SWAP1 0F9E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F93 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5ee82311 << 0xe0 // @0F9E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F9F: // Incoming jump from 0x0F86, if stack[-1] // Inputs[1] { @0FA3 stack[-1] } 0F9F 5B JUMPDEST 0FA0 61 PUSH2 0x0ad0 0FA3 81 DUP2 0FA4 61 PUSH2 0x1ba8 0FA7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0FA0 stack[0] = 0x0ad0 // @0FA3 stack[1] = stack[-1] // } // Block ends with call to 0x1ba8, returns to 0x0AD0 label_0FA8: // Incoming jump from 0x0752 0FA8 5B JUMPDEST 0FA9 7F PUSH32 0x43f25613eb2f15fb17222a5d424ca2655743e71265d98e4b93c05e5fb589ecde 0FCA 61 PUSH2 0x0fd2 0FCD 81 DUP2 0FCE 61 PUSH2 0x1996 0FD1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FA9 stack[0] = 0x43f25613eb2f15fb17222a5d424ca2655743e71265d98e4b93c05e5fb589ecde // @0FCA stack[1] = 0x0fd2 // @0FCD stack[2] = 0x43f25613eb2f15fb17222a5d424ca2655743e71265d98e4b93c05e5fb589ecde // } // Block ends with unconditional jump to 0x1996 0FD2 5B JUMPDEST 0FD3 61 PUSH2 0x0d6b 0FD6 83 DUP4 0FD7 83 DUP4 0FD8 61 PUSH2 0x1bfa 0FDB 56 *JUMP label_0FDC: // Incoming call from 0x0F81, returns to 0x0F82 // Incoming call from 0x1020, returns to 0x1021 // Incoming call from 0x0A75, returns to 0x0A76 // Incoming call from 0x0E56, returns to 0x0E57 // Incoming call from 0x1EEC, returns to 0x1EED // Incoming jump from 0x0790 // Incoming call from 0x1100, returns to 0x1101 // Incoming call from 0x1447, returns to 0x1448 // Incoming call from 0x1A2F, returns to 0x1A30 // Incoming call from 0x09C4, returns to 0x09C5 // Incoming call from 0x0C48, returns to 0x0C49 // Incoming call from 0x0EC6, returns to 0x0EC7 // Incoming call from 0x0ADD, returns to 0x0ADE // Incoming call from 0x0E14, returns to 0x0E15 // Incoming call from 0x1353, returns to 0x1354 // Inputs[6] // { // @0FDF stack[-2] // @0FED memory[0x00:0x40] // @0FF6 stack[-1] // @1000 memory[0x00:0x40] // @1001 storage[keccak256(memory[0x00:0x40])] // @1005 stack[-3] // } 0FDC 5B JUMPDEST 0FDD 60 PUSH1 0x00 0FDF 91 SWAP2 0FE0 82 DUP3 0FE1 52 MSTORE 0FE2 60 PUSH1 0x09 0FE4 60 PUSH1 0x20 0FE6 90 SWAP1 0FE7 81 DUP2 0FE8 52 MSTORE 0FE9 60 PUSH1 0x40 0FEB 80 DUP1 0FEC 84 DUP5 0FED 20 SHA3 0FEE 60 PUSH1 0x01 0FF0 60 PUSH1 0x01 0FF2 60 PUSH1 0xa0 0FF4 1B SHL 0FF5 03 SUB 0FF6 93 SWAP4 0FF7 90 SWAP1 0FF8 93 SWAP4 0FF9 16 AND 0FFA 84 DUP5 0FFB 52 MSTORE 0FFC 91 SWAP2 0FFD 90 SWAP1 0FFE 52 MSTORE 0FFF 90 SWAP1 1000 20 SHA3 1001 54 SLOAD 1002 60 PUSH1 0xff 1004 16 AND 1005 90 SWAP1 1006 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0FE1 memory[0x00:0x20] = stack[-2] // @0FE8 memory[0x20:0x40] = 0x09 // @0FFB memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0FFE memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1005 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1007: // Incoming call from 0x07A5, returns to 0x03BF // Inputs[1] { @100D storage[0x03] } 1007 5B JUMPDEST 1008 60 PUSH1 0x60 100A 60 PUSH1 0x03 100C 80 DUP1 100D 54 SLOAD 100E 61 PUSH2 0x0b18 1011 90 SWAP1 1012 61 PUSH2 0x2798 1015 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1008 stack[0] = 0x60 // @100A stack[1] = 0x03 // @1011 stack[2] = 0x0b18 // @1011 stack[3] = storage[0x03] // } // Block ends with call to 0x2798, returns to 0x0B18 label_1016: // Incoming jump from 0x07C5 // Inputs[1] { @101C msg.sender } 1016 5B JUMPDEST 1017 61 PUSH2 0x1021 101A 60 PUSH1 0x00 101C 33 CALLER 101D 61 PUSH2 0x0fdc 1020 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1017 stack[0] = 0x1021 // @101A stack[1] = 0x00 // @101C stack[2] = msg.sender // } // Block ends with call to 0x0fdc, returns to 0x1021 label_1021: // Incoming return from call to 0x0FDC at 0x1020 // Inputs[1] { @1025 stack[-1] } 1021 5B JUMPDEST 1022 61 PUSH2 0x103e 1025 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x103e, if stack[-1] label_1026: // Incoming jump from 0x1025, if not stack[-1] // Inputs[3] // { // @1028 memory[0x40:0x60] // @1038 memory[0x40:0x60] // @103D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1026 60 PUSH1 0x40 1028 51 MLOAD 1029 63 PUSH4 0x5ee82311 102E 60 PUSH1 0xe0 1030 1B SHL 1031 81 DUP2 1032 52 MSTORE 1033 60 PUSH1 0x04 1035 01 ADD 1036 60 PUSH1 0x40 1038 51 MLOAD 1039 80 DUP1 103A 91 SWAP2 103B 03 SUB 103C 90 SWAP1 103D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1032 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5ee82311 << 0xe0 // @103D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_103E: // Incoming jump from 0x1025, if stack[-1] // Inputs[5] // { // @1041 memory[0x40:0x60] // @1042 stack[-1] // @106C memory[0x40:0x60] // @1071 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1073 stack[-2] // } 103E 5B JUMPDEST 103F 60 PUSH1 0x40 1041 51 MLOAD 1042 81 DUP2 1043 81 DUP2 1044 52 MSTORE 1045 7F PUSH32 0xf8e1a15aba9398e019f0b49df1a4fde98ee17ae345cb5f6b5e2c27f5033e8ce7 1066 90 SWAP1 1067 60 PUSH1 0x20 1069 01 ADD 106A 60 PUSH1 0x40 106C 51 MLOAD 106D 80 DUP1 106E 91 SWAP2 106F 03 SUB 1070 90 SWAP1 1071 A1 LOG1 1072 50 POP 1073 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1044 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1071 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xf8e1a15aba9398e019f0b49df1a4fde98ee17ae345cb5f6b5e2c27f5033e8ce7]); // } // Block ends with unconditional jump to stack[-2] 1074 5B JUMPDEST 1075 81 DUP2 1076 73 PUSH20 0x1e0049783f008a0085193e00003d00cd54003c71 108B 60 PUSH1 0x01 108D 60 PUSH1 0x01 108F 60 PUSH1 0xa0 1091 1B SHL 1092 03 SUB 1093 82 DUP3 1094 16 AND 1095 14 EQ 1096 61 PUSH2 0x10ad 1099 57 *JUMPI 109A 60 PUSH1 0x0b 109C 54 SLOAD 109D 60 PUSH1 0xff 109F 16 AND 10A0 15 ISZERO 10A1 61 PUSH2 0x10ad 10A4 57 *JUMPI 10A5 61 PUSH2 0x10ad 10A8 81 DUP2 10A9 61 PUSH2 0x1686 10AC 56 *JUMP 10AD 5B JUMPDEST 10AE 82 DUP3 10AF 33 CALLER 10B0 83 DUP4 10B1 61 PUSH2 0x10bb 10B4 83 DUP4 10B5 83 DUP4 10B6 83 DUP4 10B7 61 PUSH2 0x1c14 10BA 56 *JUMP 10BB 5B JUMPDEST 10BC 60 PUSH1 0x0b 10BE 54 SLOAD 10BF 61 PUSH2 0x0100 10C2 90 SWAP1 10C3 04 DIV 10C4 60 PUSH1 0xff 10C6 16 AND 10C7 15 ISZERO 10C8 61 PUSH2 0x10e4 10CB 57 *JUMPI 10CC 60 PUSH1 0x40 10CE 51 MLOAD 10CF 63 PUSH4 0x7a5418c3 10D4 60 PUSH1 0xe1 10D6 1B SHL 10D7 81 DUP2 10D8 52 MSTORE 10D9 60 PUSH1 0x04 10DB 01 ADD 10DC 60 PUSH1 0x40 10DE 51 MLOAD 10DF 80 DUP1 10E0 91 SWAP2 10E1 03 SUB 10E2 90 SWAP1 10E3 FD *REVERT 10E4 5B JUMPDEST 10E5 61 PUSH2 0x10ee 10E8 86 DUP7 10E9 86 DUP7 10EA 61 PUSH2 0x1c41 10ED 56 *JUMP label_10EE: // Incoming jump from 0x1995 // Inputs[1] { @10F5 stack[-7] } 10EE 5B JUMPDEST 10EF 50 POP 10F0 50 POP 10F1 50 POP 10F2 50 POP 10F3 50 POP 10F4 50 POP 10F5 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_10F6: // Incoming jump from 0x081A // Inputs[1] { @10FC msg.sender } 10F6 5B JUMPDEST 10F7 61 PUSH2 0x1101 10FA 60 PUSH1 0x00 10FC 33 CALLER 10FD 61 PUSH2 0x0fdc 1100 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10F7 stack[0] = 0x1101 // @10FA stack[1] = 0x00 // @10FC stack[2] = msg.sender // } // Block ends with call to 0x0fdc, returns to 0x1101 label_1101: // Incoming return from call to 0x0FDC at 0x1100 // Inputs[1] { @1105 stack[-1] } 1101 5B JUMPDEST 1102 61 PUSH2 0x111e 1105 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x111e, if stack[-1] label_1106: // Incoming jump from 0x1105, if not stack[-1] // Inputs[3] // { // @1108 memory[0x40:0x60] // @1118 memory[0x40:0x60] // @111D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1106 60 PUSH1 0x40 1108 51 MLOAD 1109 63 PUSH4 0x5ee82311 110E 60 PUSH1 0xe0 1110 1B SHL 1111 81 DUP2 1112 52 MSTORE 1113 60 PUSH1 0x04 1115 01 ADD 1116 60 PUSH1 0x40 1118 51 MLOAD 1119 80 DUP1 111A 91 SWAP2 111B 03 SUB 111C 90 SWAP1 111D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1112 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5ee82311 << 0xe0 // @111D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_111E: // Incoming jump from 0x1105, if stack[-1] // Inputs[3] // { // @1122 storage[0x0b] // @1127 stack[-1] // @1130 stack[-2] // } 111E 5B JUMPDEST 111F 60 PUSH1 0x0b 1121 80 DUP1 1122 54 SLOAD 1123 60 PUSH1 0xff 1125 19 NOT 1126 16 AND 1127 91 SWAP2 1128 15 ISZERO 1129 15 ISZERO 112A 91 SWAP2 112B 90 SWAP1 112C 91 SWAP2 112D 17 OR 112E 90 SWAP1 112F 55 SSTORE 1130 56 *JUMP // Stack delta = -2 // Outputs[1] { @112F storage[0x0b] = !!stack[-1] | (~0xff & storage[0x0b]) } // Block ends with unconditional jump to stack[-2] label_1131: // Incoming jump from 0x082D // Incoming jump from 0x0E09 // Inputs[3] // { // @1135 stack[-4] // @1136 stack[-3] // @1137 stack[-2] // } 1131 5B JUMPDEST 1132 61 PUSH2 0x113c 1135 84 DUP5 1136 84 DUP5 1137 84 DUP5 1138 61 PUSH2 0x0c6f 113B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1132 stack[0] = 0x113c // @1135 stack[1] = stack[-4] // @1136 stack[2] = stack[-3] // @1137 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x0c6f 113C 5B JUMPDEST 113D 60 PUSH1 0x01 113F 60 PUSH1 0x01 1141 60 PUSH1 0xa0 1143 1B SHL 1144 03 SUB 1145 83 DUP4 1146 16 AND 1147 3B EXTCODESIZE 1148 15 ISZERO 1149 61 PUSH2 0x0ce3 114C 57 *JUMPI 114D 61 PUSH2 0x1158 1150 84 DUP5 1151 84 DUP5 1152 84 DUP5 1153 84 DUP5 1154 61 PUSH2 0x1cad 1157 56 *JUMP 1158 5B JUMPDEST 1159 61 PUSH2 0x0ce3 115C 57 *JUMPI 115D 60 PUSH1 0x40 115F 51 MLOAD 1160 63 PUSH4 0x68d2bf6b 1165 60 PUSH1 0xe1 1167 1B SHL 1168 81 DUP2 1169 52 MSTORE 116A 60 PUSH1 0x04 116C 01 ADD 116D 60 PUSH1 0x40 116F 51 MLOAD 1170 80 DUP1 1171 91 SWAP2 1172 03 SUB 1173 90 SWAP1 1174 FD *REVERT label_1175: // Incoming jump from 0x084D // Incoming call from 0x1EC8, returns to 0x13C0 // Inputs[1] { @1197 storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a620] } 1175 5B JUMPDEST 1176 7F PUSH32 0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a620 1197 54 SLOAD 1198 60 PUSH1 0x00 119A 90 SWAP1 119B 60 PUSH1 0xff 119D 16 AND 119E 61 PUSH2 0x11a9 11A1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @119A stack[0] = 0x00 } // Block ends with conditional jump to 0x11a9, if 0xff & storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a620] label_11A2: // Incoming jump from 0x11A1, if not 0xff & storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a620] // Inputs[2] // { // @11A5 stack[-3] // @11A6 stack[-2] // } 11A2 50 POP 11A3 60 PUSH1 0x01 11A5 91 SWAP2 11A6 90 SWAP1 11A7 50 POP 11A8 56 *JUMP // Stack delta = -2 // Outputs[1] { @11A5 stack[-3] = 0x01 } // Block ends with unconditional jump to stack[-3] label_11A9: // Incoming jump from 0x11A1, if 0xff & storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a620] // Inputs[1] { @11AD stack[-2] } 11A9 5B JUMPDEST 11AA 61 PUSH2 0x11b2 11AD 82 DUP3 11AE 61 PUSH2 0x099a 11B1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @11AA stack[0] = 0x11b2 // @11AD stack[1] = stack[-2] // } // Block ends with call to 0x099a, returns to 0x11B2 label_11B2: // Incoming return from call to 0x099A at 0x11B1 // Inputs[1] { @11B3 stack[-1] } 11B2 5B JUMPDEST 11B3 80 DUP1 11B4 61 PUSH2 0x09b4 11B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09b4, if stack[-1] label_11B8: // Incoming jump from 0x11B7, if not stack[-1] // Inputs[8] // { // @11DA storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a61d] // @11FC storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a621] // @11FF memory[0x40:0x60] // @1212 stack[-3] // @1232 memory[0x40:0x60] // @1238 msg.gas // @1239 address(storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a61d] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @1239 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 11B8 50 POP 11B9 7F PUSH32 0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a61d 11DA 54 SLOAD 11DB 7F PUSH32 0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a621 11FC 54 SLOAD 11FD 60 PUSH1 0x40 11FF 51 MLOAD 1200 63 PUSH4 0x0f8350ed 1205 60 PUSH1 0xe4 1207 1B SHL 1208 81 DUP2 1209 52 MSTORE 120A 60 PUSH1 0x01 120C 60 PUSH1 0x01 120E 60 PUSH1 0xa0 1210 1B SHL 1211 03 SUB 1212 85 DUP6 1213 81 DUP2 1214 16 AND 1215 60 PUSH1 0x04 1217 83 DUP4 1218 01 ADD 1219 52 MSTORE 121A 60 PUSH1 0x24 121C 82 DUP3 121D 01 ADD 121E 92 SWAP3 121F 90 SWAP1 1220 92 SWAP3 1221 52 MSTORE 1222 91 SWAP2 1223 16 AND 1224 90 SWAP1 1225 63 PUSH4 0xf8350ed0 122A 90 SWAP1 122B 60 PUSH1 0x44 122D 01 ADD 122E 60 PUSH1 0x20 1230 60 PUSH1 0x40 1232 51 MLOAD 1233 80 DUP1 1234 83 DUP4 1235 03 SUB 1236 81 DUP2 1237 86 DUP7 1238 5A GAS 1239 FA STATICCALL 123A 15 ISZERO 123B 80 DUP1 123C 15 ISZERO 123D 61 PUSH2 0x124a 1240 57 *JUMPI // Stack delta = +3 // Outputs[8] // { // @1209 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0f8350ed << 0xe4 // @1219 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @1221 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a621] // @1224 stack[-1] = storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a61d] & (0x01 << 0xa0) - 0x01 // @122A stack[0] = 0xf8350ed0 // @122D stack[1] = 0x44 + memory[0x40:0x60] // @1239 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a61d] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @123A stack[2] = !address(storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a61d] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x124a, if !!address(storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a61d] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_1241: // Incoming jump from 0x1240, if not !!address(storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a61d] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @1241 returndata.length // @1245 returndata[0x00:0x00 + returndata.length] // @1246 returndata.length // @1249 memory[0x00:0x00 + returndata.length] // } 1241 3D RETURNDATASIZE 1242 60 PUSH1 0x00 1244 80 DUP1 1245 3E RETURNDATACOPY 1246 3D RETURNDATASIZE 1247 60 PUSH1 0x00 1249 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1245 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1249 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_124A: // Incoming jump from 0x1240, if !!address(storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a61d] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[2] // { // @1251 memory[0x40:0x60] // @1252 returndata.length // } 124A 5B JUMPDEST 124B 50 POP 124C 50 POP 124D 50 POP 124E 50 POP 124F 60 PUSH1 0x40 1251 51 MLOAD 1252 3D RETURNDATASIZE 1253 60 PUSH1 0x1f 1255 19 NOT 1256 60 PUSH1 0x1f 1258 82 DUP3 1259 01 ADD 125A 16 AND 125B 82 DUP3 125C 01 ADD 125D 80 DUP1 125E 60 PUSH1 0x40 1260 52 MSTORE 1261 50 POP 1262 81 DUP2 1263 01 ADD 1264 90 SWAP1 1265 61 PUSH2 0x09b4 1268 91 SWAP2 1269 90 SWAP1 126A 61 PUSH2 0x2821 126D 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1260 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @1268 stack[-4] = 0x09b4 // @1269 stack[-2] = memory[0x40:0x60] // @1269 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x2821, returns to 0x09B4 label_126E: // Incoming jump from 0x086D 126E 5B JUMPDEST 126F 7F PUSH32 0x43f25613eb2f15fb17222a5d424ca2655743e71265d98e4b93c05e5fb589ecde 1290 61 PUSH2 0x1298 1293 81 DUP2 1294 61 PUSH2 0x1996 1297 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @126F stack[0] = 0x43f25613eb2f15fb17222a5d424ca2655743e71265d98e4b93c05e5fb589ecde // @1290 stack[1] = 0x1298 // @1293 stack[2] = 0x43f25613eb2f15fb17222a5d424ca2655743e71265d98e4b93c05e5fb589ecde // } // Block ends with unconditional jump to 0x1996 1298 5B JUMPDEST 1299 61 PUSH2 0x0d6b 129C 83 DUP4 129D 83 DUP4 129E 61 PUSH2 0x1d98 12A1 56 *JUMP label_12A2: // Incoming jump from 0x088D // Inputs[1] { @12A8 stack[-1] } 12A2 5B JUMPDEST 12A3 60 PUSH1 0x60 12A5 61 PUSH2 0x12ad 12A8 82 DUP3 12A9 61 PUSH2 0x1ddb 12AC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12A3 stack[0] = 0x60 // @12A5 stack[1] = 0x12ad // @12A8 stack[2] = stack[-1] // } // Block ends with call to 0x1ddb, returns to 0x12AD label_12AD: // Incoming return from call to 0x1DDB at 0x12AC // Inputs[7] // { // @12B1 storage[0x0b] // @12B4 memory[0x40:0x60] // @12C3 stack[-3] // @12E4 memory[0x40:0x60] // @12EA msg.gas // @12EB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]] // @12EB address((0x01 << 0xa0) - 0x01 & storage[0x0b] / 0x010000).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } 12AD 5B JUMPDEST 12AE 50 POP 12AF 60 PUSH1 0x0b 12B1 54 SLOAD 12B2 60 PUSH1 0x40 12B4 51 MLOAD 12B5 63 PUSH4 0xc87b56dd 12BA 60 PUSH1 0xe0 12BC 1B SHL 12BD 81 DUP2 12BE 52 MSTORE 12BF 60 PUSH1 0x04 12C1 81 DUP2 12C2 01 ADD 12C3 84 DUP5 12C4 90 SWAP1 12C5 52 MSTORE 12C6 62 PUSH3 0x010000 12CA 90 SWAP1 12CB 91 SWAP2 12CC 04 DIV 12CD 60 PUSH1 0x01 12CF 60 PUSH1 0x01 12D1 60 PUSH1 0xa0 12D3 1B SHL 12D4 03 SUB 12D5 16 AND 12D6 90 SWAP1 12D7 63 PUSH4 0xc87b56dd 12DC 90 SWAP1 12DD 60 PUSH1 0x24 12DF 01 ADD 12E0 60 PUSH1 0x00 12E2 60 PUSH1 0x40 12E4 51 MLOAD 12E5 80 DUP1 12E6 83 DUP4 12E7 03 SUB 12E8 81 DUP2 12E9 86 DUP7 12EA 5A GAS 12EB FA STATICCALL 12EC 15 ISZERO 12ED 80 DUP1 12EE 15 ISZERO 12EF 61 PUSH2 0x12fc 12F2 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @12BE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xc87b56dd << 0xe0 // @12C5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-3] // @12D6 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x0b] / 0x010000 // @12DC stack[0] = 0xc87b56dd // @12DF stack[1] = 0x24 + memory[0x40:0x60] // @12EB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address((0x01 << 0xa0) - 0x01 & storage[0x0b] / 0x010000).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @12EC stack[2] = !address((0x01 << 0xa0) - 0x01 & storage[0x0b] / 0x010000).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x12fc, if !!address((0x01 << 0xa0) - 0x01 & storage[0x0b] / 0x010000).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_12F3: // Incoming jump from 0x12F2, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x0b] / 0x010000).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @12F3 returndata.length // @12F7 returndata[0x00:0x00 + returndata.length] // @12F8 returndata.length // @12FB memory[0x00:0x00 + returndata.length] // } 12F3 3D RETURNDATASIZE 12F4 60 PUSH1 0x00 12F6 80 DUP1 12F7 3E RETURNDATACOPY 12F8 3D RETURNDATASIZE 12F9 60 PUSH1 0x00 12FB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @12F7 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @12FB revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_12FC: // Incoming jump from 0x12F2, if !!address((0x01 << 0xa0) - 0x01 & storage[0x0b] / 0x010000).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @1303 memory[0x40:0x60] // @1304 returndata.length // @1308 returndata[0x00:0x00 + returndata.length] // @130B returndata.length // } 12FC 5B JUMPDEST 12FD 50 POP 12FE 50 POP 12FF 50 POP 1300 50 POP 1301 60 PUSH1 0x40 1303 51 MLOAD 1304 3D RETURNDATASIZE 1305 60 PUSH1 0x00 1307 82 DUP3 1308 3E RETURNDATACOPY 1309 60 PUSH1 0x1f 130B 3D RETURNDATASIZE 130C 90 SWAP1 130D 81 DUP2 130E 01 ADD 130F 60 PUSH1 0x1f 1311 19 NOT 1312 16 AND 1313 82 DUP3 1314 01 ADD 1315 60 PUSH1 0x40 1317 52 MSTORE 1318 61 PUSH2 0x09b4 131B 91 SWAP2 131C 90 SWAP1 131D 81 DUP2 131E 01 ADD 131F 90 SWAP1 1320 61 PUSH2 0x283e 1323 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1308 memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1317 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @131B stack[-4] = 0x09b4 // @131F stack[-2] = memory[0x40:0x60] // @131F stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x283e, returns to 0x09B4 label_1324: // Incoming jump from 0x08AD // Inputs[3] // { // @1327 stack[-2] // @1332 memory[0x00:0x40] // @1336 storage[0x01 + keccak256(memory[0x00:0x40])] // } 1324 5B JUMPDEST 1325 60 PUSH1 0x00 1327 82 DUP3 1328 81 DUP2 1329 52 MSTORE 132A 60 PUSH1 0x09 132C 60 PUSH1 0x20 132E 52 MSTORE 132F 60 PUSH1 0x40 1331 90 SWAP1 1332 20 SHA3 1333 60 PUSH1 0x01 1335 01 ADD 1336 54 SLOAD 1337 61 PUSH2 0x133f 133A 81 DUP2 133B 61 PUSH2 0x1996 133E 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1329 memory[0x00:0x20] = stack[-2] // @132E memory[0x20:0x40] = 0x09 // @1336 stack[0] = storage[0x01 + keccak256(memory[0x00:0x40])] // @1337 stack[1] = 0x133f // @133A stack[2] = storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x1996 133F 5B JUMPDEST 1340 61 PUSH2 0x0d6b 1343 83 DUP4 1344 83 DUP4 1345 61 PUSH2 0x1a26 1348 56 *JUMP label_1349: // Incoming jump from 0x0901 // Inputs[1] { @134F msg.sender } 1349 5B JUMPDEST 134A 61 PUSH2 0x1354 134D 60 PUSH1 0x00 134F 33 CALLER 1350 61 PUSH2 0x0fdc 1353 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @134A stack[0] = 0x1354 // @134D stack[1] = 0x00 // @134F stack[2] = msg.sender // } // Block ends with call to 0x0fdc, returns to 0x1354 label_1354: // Incoming return from call to 0x0FDC at 0x1353 // Inputs[1] { @1358 stack[-1] } 1354 5B JUMPDEST 1355 61 PUSH2 0x1371 1358 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1371, if stack[-1] label_1359: // Incoming jump from 0x1358, if not stack[-1] // Inputs[3] // { // @135B memory[0x40:0x60] // @136B memory[0x40:0x60] // @1370 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1359 60 PUSH1 0x40 135B 51 MLOAD 135C 63 PUSH4 0x5ee82311 1361 60 PUSH1 0xe0 1363 1B SHL 1364 81 DUP2 1365 52 MSTORE 1366 60 PUSH1 0x04 1368 01 ADD 1369 60 PUSH1 0x40 136B 51 MLOAD 136C 80 DUP1 136D 91 SWAP2 136E 03 SUB 136F 90 SWAP1 1370 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1365 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5ee82311 << 0xe0 // @1370 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1371: // Incoming jump from 0x1358, if stack[-1] // Inputs[2] // { // @1375 stack[-2] // @1376 stack[-1] // } 1371 5B JUMPDEST 1372 61 PUSH2 0x0b05 1375 82 DUP3 1376 82 DUP3 1377 61 PUSH2 0x1d98 137A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1372 stack[0] = 0x0b05 // @1375 stack[1] = stack[-2] // @1376 stack[2] = stack[-1] // } // Block ends with call to 0x1d98, returns to 0x0B05 label_137B: // Incoming call from 0x1726, returns to 0x1727 // Incoming call from 0x1861, returns to 0x1862 // Inputs[1] { @137E storage[0x0b] } 137B 5B JUMPDEST 137C 60 PUSH1 0x0b 137E 54 SLOAD 137F 60 PUSH1 0x00 1381 90 SWAP1 1382 61 PUSH2 0x0100 1385 90 SWAP1 1386 04 DIV 1387 60 PUSH1 0xff 1389 16 AND 138A 15 ISZERO 138B 61 PUSH2 0x1396 138E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1381 stack[0] = 0x00 } // Block ends with conditional jump to 0x1396, if !(0xff & storage[0x0b] / 0x0100) label_138F: // Incoming jump from 0x138E, if not !(0xff & storage[0x0b] / 0x0100) 138F 50 POP 1390 60 PUSH1 0x00 1392 61 PUSH2 0x09b4 1395 56 *JUMP // Stack delta = +0 // Outputs[1] { @1390 stack[-1] = 0x00 } // Block ends with unconditional jump to 0x09b4 label_1396: // Incoming jump from 0x138E, if !(0xff & storage[0x0b] / 0x0100) // Inputs[5] // { // @13A0 stack[-3] // @13B2 memory[0x00:0x40] // @13B4 stack[-2] // @13BB memory[0x00:0x40] // @13BC storage[keccak256(memory[0x00:0x40])] // } 1396 5B JUMPDEST 1397 60 PUSH1 0x01 1399 60 PUSH1 0x01 139B 60 PUSH1 0xa0 139D 1B SHL 139E 03 SUB 139F 80 DUP1 13A0 84 DUP5 13A1 16 AND 13A2 60 PUSH1 0x00 13A4 90 SWAP1 13A5 81 DUP2 13A6 52 MSTORE 13A7 60 PUSH1 0x07 13A9 60 PUSH1 0x20 13AB 90 SWAP1 13AC 81 DUP2 13AD 52 MSTORE 13AE 60 PUSH1 0x40 13B0 80 DUP1 13B1 83 DUP4 13B2 20 SHA3 13B3 93 SWAP4 13B4 86 DUP7 13B5 16 AND 13B6 83 DUP4 13B7 52 MSTORE 13B8 92 SWAP3 13B9 90 SWAP1 13BA 52 MSTORE 13BB 20 SHA3 13BC 54 SLOAD 13BD 60 PUSH1 0xff 13BF 16 AND // Stack delta = +1 // Outputs[5] // { // @13A6 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @13AD memory[0x20:0x40] = 0x07 // @13B7 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @13BA memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @13BF stack[0] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block continues label_13C0: // Incoming return from call to 0x2419 at 0x244A // Incoming jump from 0x2242, if !stack[-5] // Incoming return from call to 0x25F3 at 0x261D // Incoming return from call to 0x228A at 0x1F50 // Incoming jump from 0x13BF // Incoming jump from 0x149C // Incoming return from call to 0x237D at 0x20D6 // Incoming return from call to 0x1E62 at 0x147A // Incoming return from call to 0x24E7 at 0x2525 // Incoming jump from 0x1AC8, if 0x00 - stack[-1] // Incoming return from call to 0x1175 at 0x1EC8 // Incoming return from call to 0x1175 at 0x1EC8 // Incoming return from call to 0x25F3 at 0x283D // Incoming return from call to 0x244B at 0x247D // Inputs[3] // { // @13C1 stack[-5] // @13C1 stack[-1] // @13C2 stack[-4] // } 13C0 5B JUMPDEST 13C1 93 SWAP4 13C2 92 SWAP3 13C3 50 POP 13C4 50 POP 13C5 50 POP 13C6 56 *JUMP // Stack delta = -4 // Outputs[1] { @13C1 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_13C7: // Incoming jump from 0x0941 13C7 5B JUMPDEST 13C8 61 PUSH2 0x13cf 13CB 61 PUSH2 0x1afc 13CE 56 *JUMP // Stack delta = +1 // Outputs[1] { @13C8 stack[0] = 0x13cf } // Block ends with call to 0x1afc, returns to 0x13CF label_13CF: // Incoming return from call to 0x1AFC at 0x13CE // Inputs[1] { @13D8 stack[-1] } 13CF 5B JUMPDEST 13D0 60 PUSH1 0x01 13D2 60 PUSH1 0x01 13D4 60 PUSH1 0xa0 13D6 1B SHL 13D7 03 SUB 13D8 81 DUP2 13D9 16 AND 13DA 61 PUSH2 0x1434 13DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1434, if stack[-1] & (0x01 << 0xa0) - 0x01 label_13DE: // Incoming jump from 0x13DD, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @13E0 memory[0x40:0x60] } 13DE 60 PUSH1 0x40 13E0 51 MLOAD 13E1 62 PUSH3 0x461bcd 13E5 60 PUSH1 0xe5 13E7 1B SHL 13E8 81 DUP2 13E9 52 MSTORE 13EA 60 PUSH1 0x20 13EC 60 PUSH1 0x04 13EE 82 DUP3 13EF 01 ADD 13F0 52 MSTORE 13F1 60 PUSH1 0x26 13F3 60 PUSH1 0x24 13F5 82 DUP3 13F6 01 ADD 13F7 52 MSTORE 13F8 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 1419 60 PUSH1 0x44 141B 82 DUP3 141C 01 ADD 141D 52 MSTORE 141E 65 PUSH6 0x646472657373 1425 60 PUSH1 0xd0 1427 1B SHL 1428 60 PUSH1 0x64 142A 82 DUP3 142B 01 ADD 142C 52 MSTORE 142D 60 PUSH1 0x84 142F 01 ADD 1430 61 PUSH2 0x0ddc 1433 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @13E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13F0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @13F7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @141D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @142C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @142F stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0ddc label_1434: // Incoming jump from 0x13DD, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1438 stack[-1] } 1434 5B JUMPDEST 1435 61 PUSH2 0x0ad0 1438 81 DUP2 1439 61 PUSH2 0x1b56 143C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1435 stack[0] = 0x0ad0 // @1438 stack[1] = stack[-1] // } // Block ends with call to 0x1b56, returns to 0x0AD0 label_143D: // Incoming jump from 0x097B // Inputs[1] { @1443 msg.sender } 143D 5B JUMPDEST 143E 61 PUSH2 0x1448 1441 60 PUSH1 0x00 1443 33 CALLER 1444 61 PUSH2 0x0fdc 1447 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @143E stack[0] = 0x1448 // @1441 stack[1] = 0x00 // @1443 stack[2] = msg.sender // } // Block ends with call to 0x0fdc, returns to 0x1448 label_1448: // Incoming return from call to 0x0FDC at 0x1447 // Inputs[1] { @144C stack[-1] } 1448 5B JUMPDEST 1449 61 PUSH2 0x1465 144C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1465, if stack[-1] label_144D: // Incoming jump from 0x144C, if not stack[-1] // Inputs[3] // { // @144F memory[0x40:0x60] // @145F memory[0x40:0x60] // @1464 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 144D 60 PUSH1 0x40 144F 51 MLOAD 1450 63 PUSH4 0x5ee82311 1455 60 PUSH1 0xe0 1457 1B SHL 1458 81 DUP2 1459 52 MSTORE 145A 60 PUSH1 0x04 145C 01 ADD 145D 60 PUSH1 0x40 145F 51 MLOAD 1460 80 DUP1 1461 91 SWAP2 1462 03 SUB 1463 90 SWAP1 1464 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1459 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5ee82311 << 0xe0 // @1464 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1465: // Incoming jump from 0x144C, if stack[-1] // Inputs[1] { @1469 stack[-1] } 1465 5B JUMPDEST 1466 61 PUSH2 0x0ad0 1469 81 DUP2 146A 61 PUSH2 0x1e10 146D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1466 stack[0] = 0x0ad0 // @1469 stack[1] = stack[-1] // } // Block ends with call to 0x1e10, returns to 0x0AD0 label_146E: // Incoming call from 0x0994, returns to 0x0995 // Inputs[1] { @1476 stack[-1] } 146E 5B JUMPDEST 146F 60 PUSH1 0x60 1471 60 PUSH1 0x00 1473 61 PUSH2 0x13c0 1476 83 DUP4 1477 61 PUSH2 0x1e62 147A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @146F stack[0] = 0x60 // @1471 stack[1] = 0x00 // @1473 stack[2] = 0x13c0 // @1476 stack[3] = stack[-1] // } // Block ends with call to 0x1e62, returns to 0x13C0 label_147B: // Incoming call from 0x09B3, returns to 0x09B4 // Inputs[4] // { // @1484 stack[-1] // @148D stack[-2] // @1495 memory[0x00:0x40] // @1496 storage[keccak256(memory[0x00:0x40])] // } 147B 5B JUMPDEST 147C 60 PUSH1 0x01 147E 60 PUSH1 0x01 1480 60 PUSH1 0xa0 1482 1B SHL 1483 03 SUB 1484 81 DUP2 1485 16 AND 1486 60 PUSH1 0x00 1488 90 SWAP1 1489 81 DUP2 148A 52 MSTORE 148B 60 PUSH1 0x01 148D 83 DUP4 148E 01 ADD 148F 60 PUSH1 0x20 1491 52 MSTORE 1492 60 PUSH1 0x40 1494 81 DUP2 1495 20 SHA3 1496 54 SLOAD 1497 15 ISZERO 1498 15 ISZERO 1499 61 PUSH2 0x13c0 149C 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1488 stack[0] = 0x00 // @148A memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1491 memory[0x20:0x40] = stack[-2] + 0x01 // @1498 stack[1] = !!storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x13c0 label_149D: // Incoming call from 0x0A16, returns to 0x0A17 // Incoming call from 0x1544, returns to 0x09B4 // Inputs[1] { @14A9 stack[-1] } 149D 5B JUMPDEST 149E 60 PUSH1 0x00 14A0 60 PUSH1 0x01 14A2 60 PUSH1 0x01 14A4 60 PUSH1 0xe0 14A6 1B SHL 14A7 03 SUB 14A8 19 NOT 14A9 82 DUP3 14AA 16 AND 14AB 63 PUSH4 0x7965db0b 14B0 60 PUSH1 0xe0 14B2 1B SHL 14B3 14 EQ 14B4 80 DUP1 14B5 61 PUSH2 0x09b4 14B8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @149E stack[0] = 0x00 // @14B3 stack[1] = 0x7965db0b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x09b4, if 0x7965db0b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_14B9: // Incoming jump from 0x14B8, if not 0x7965db0b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @14CB stack[-3] } 14B9 50 POP 14BA 63 PUSH4 0x01ffc9a7 14BF 60 PUSH1 0xe0 14C1 1B SHL 14C2 60 PUSH1 0x01 14C4 60 PUSH1 0x01 14C6 60 PUSH1 0xe0 14C8 1B SHL 14C9 03 SUB 14CA 19 NOT 14CB 83 DUP4 14CC 16 AND 14CD 14 EQ 14CE 61 PUSH2 0x09b4 14D1 56 *JUMP // Stack delta = +0 // Outputs[1] { @14CD stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to 0x09b4 label_14D2: // Incoming call from 0x0A25, returns to 0x0A26 // Inputs[1] { @14E6 stack[-1] } 14D2 5B JUMPDEST 14D3 60 PUSH1 0x00 14D5 63 PUSH4 0x01ffc9a7 14DA 60 PUSH1 0xe0 14DC 1B SHL 14DD 60 PUSH1 0x01 14DF 60 PUSH1 0x01 14E1 60 PUSH1 0xe0 14E3 1B SHL 14E4 03 SUB 14E5 19 NOT 14E6 83 DUP4 14E7 16 AND 14E8 14 EQ 14E9 80 DUP1 14EA 61 PUSH2 0x1503 14ED 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14D3 stack[0] = 0x00 // @14E8 stack[1] = stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // } // Block ends with conditional jump to 0x1503, if stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 label_14EE: // Incoming jump from 0x14ED, if not stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // Inputs[1] { @1500 stack[-3] } 14EE 50 POP 14EF 63 PUSH4 0x80ac58cd 14F4 60 PUSH1 0xe0 14F6 1B SHL 14F7 60 PUSH1 0x01 14F9 60 PUSH1 0x01 14FB 60 PUSH1 0xe0 14FD 1B SHL 14FE 03 SUB 14FF 19 NOT 1500 83 DUP4 1501 16 AND 1502 14 EQ 1503 5B JUMPDEST 1504 80 DUP1 1505 61 PUSH2 0x09b4 1508 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1502 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 } // Block ends with conditional jump to 0x09b4, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 label_1509: // Incoming jump from 0x1508, if not stack[-1] // Incoming jump from 0x1508, if not stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Inputs[2] // { // @1514 stack[-3] // @151E stack[-4] // } 1509 50 POP 150A 50 POP 150B 60 PUSH1 0x01 150D 60 PUSH1 0x01 150F 60 PUSH1 0xe0 1511 1B SHL 1512 03 SUB 1513 19 NOT 1514 16 AND 1515 63 PUSH4 0x5b5e139f 151A 60 PUSH1 0xe0 151C 1B SHL 151D 14 EQ 151E 90 SWAP1 151F 56 *JUMP // Stack delta = -3 // Outputs[1] { @151E stack[-4] = 0x5b5e139f << 0xe0 == ~((0x01 << 0xe0) - 0x01) & stack[-3] } // Block ends with unconditional jump to stack[-4] label_1520: // Incoming call from 0x0A6A, returns to 0x09B4 // Inputs[1] { @152C stack[-1] } 1520 5B JUMPDEST 1521 60 PUSH1 0x00 1523 60 PUSH1 0x01 1525 60 PUSH1 0x01 1527 60 PUSH1 0xe0 1529 1B SHL 152A 03 SUB 152B 19 NOT 152C 82 DUP3 152D 16 AND 152E 63 PUSH4 0x152a902d 1533 60 PUSH1 0xe1 1535 1B SHL 1536 14 EQ 1537 80 DUP1 1538 61 PUSH2 0x09b4 153B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1521 stack[0] = 0x00 // @1536 stack[1] = 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x09b4, if 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_153C: // Incoming jump from 0x153B, if not 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1540 stack[-3] } 153C 50 POP 153D 61 PUSH2 0x09b4 1540 82 DUP3 1541 61 PUSH2 0x149d 1544 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @153D stack[-1] = 0x09b4 // @1540 stack[0] = stack[-3] // } // Block ends with call to 0x149d, returns to 0x09B4 label_1545: // Incoming call from 0x0B04, returns to 0x0B05 // Inputs[1] { @1551 stack[-1] } 1545 5B JUMPDEST 1546 61 PUSH2 0x2710 1549 60 PUSH1 0x01 154B 60 PUSH1 0x01 154D 60 PUSH1 0x60 154F 1B SHL 1550 03 SUB 1551 82 DUP3 1552 16 AND 1553 11 GT 1554 15 ISZERO 1555 61 PUSH2 0x15b3 1558 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15b3, if !(stack[-1] & (0x01 << 0x60) - 0x01 > 0x2710) label_1559: // Incoming jump from 0x1558, if not !(stack[-1] & (0x01 << 0x60) - 0x01 > 0x2710) // Inputs[1] { @155B memory[0x40:0x60] } 1559 60 PUSH1 0x40 155B 51 MLOAD 155C 62 PUSH3 0x461bcd 1560 60 PUSH1 0xe5 1562 1B SHL 1563 81 DUP2 1564 52 MSTORE 1565 60 PUSH1 0x20 1567 60 PUSH1 0x04 1569 82 DUP3 156A 01 ADD 156B 52 MSTORE 156C 60 PUSH1 0x2a 156E 60 PUSH1 0x24 1570 82 DUP3 1571 01 ADD 1572 52 MSTORE 1573 7F PUSH32 0x455243323938313a20726f79616c7479206665652077696c6c20657863656564 1594 60 PUSH1 0x44 1596 82 DUP3 1597 01 ADD 1598 52 MSTORE 1599 69 PUSH10 0x2073616c655072696365 15A4 60 PUSH1 0xb0 15A6 1B SHL 15A7 60 PUSH1 0x64 15A9 82 DUP3 15AA 01 ADD 15AB 52 MSTORE 15AC 60 PUSH1 0x84 15AE 01 ADD 15AF 61 PUSH2 0x0ddc 15B2 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1564 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @156B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1572 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @1598 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243323938313a20726f79616c7479206665652077696c6c20657863656564 // @15AB memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x2073616c655072696365 << 0xb0 // @15AE stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0ddc label_15B3: // Incoming jump from 0x1558, if !(stack[-1] & (0x01 << 0x60) - 0x01 > 0x2710) // Inputs[1] { @15BC stack[-2] } 15B3 5B JUMPDEST 15B4 60 PUSH1 0x01 15B6 60 PUSH1 0x01 15B8 60 PUSH1 0xa0 15BA 1B SHL 15BB 03 SUB 15BC 82 DUP3 15BD 16 AND 15BE 61 PUSH2 0x1609 15C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1609, if stack[-2] & (0x01 << 0xa0) - 0x01 label_15C2: // Incoming jump from 0x15C1, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @15C4 memory[0x40:0x60] } 15C2 60 PUSH1 0x40 15C4 51 MLOAD 15C5 62 PUSH3 0x461bcd 15C9 60 PUSH1 0xe5 15CB 1B SHL 15CC 81 DUP2 15CD 52 MSTORE 15CE 60 PUSH1 0x20 15D0 60 PUSH1 0x04 15D2 82 DUP3 15D3 01 ADD 15D4 52 MSTORE 15D5 60 PUSH1 0x19 15D7 60 PUSH1 0x24 15D9 82 DUP3 15DA 01 ADD 15DB 52 MSTORE 15DC 7F PUSH32 0x455243323938313a20696e76616c696420726563656976657200000000000000 15FD 60 PUSH1 0x44 15FF 82 DUP3 1600 01 ADD 1601 52 MSTORE 1602 60 PUSH1 0x64 1604 01 ADD 1605 61 PUSH2 0x0ddc 1608 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @15CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @15D4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @15DB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @1601 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243323938313a20696e76616c696420726563656976657200000000000000 // @1604 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0ddc label_1609: // Incoming jump from 0x15C1, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @160D memory[0x40:0x60] // @161D stack[-2] // @162B stack[-1] // @1641 stack[-3] // } 1609 5B JUMPDEST 160A 60 PUSH1 0x40 160C 80 DUP1 160D 51 MLOAD 160E 80 DUP1 160F 82 DUP3 1610 01 ADD 1611 90 SWAP1 1612 91 SWAP2 1613 52 MSTORE 1614 60 PUSH1 0x01 1616 60 PUSH1 0x01 1618 60 PUSH1 0xa0 161A 1B SHL 161B 03 SUB 161C 90 SWAP1 161D 92 SWAP3 161E 16 AND 161F 80 DUP1 1620 83 DUP4 1621 52 MSTORE 1622 60 PUSH1 0x01 1624 60 PUSH1 0x01 1626 60 PUSH1 0x60 1628 1B SHL 1629 03 SUB 162A 90 SWAP1 162B 91 SWAP2 162C 16 AND 162D 60 PUSH1 0x20 162F 90 SWAP1 1630 92 SWAP3 1631 01 ADD 1632 82 DUP3 1633 90 SWAP1 1634 52 MSTORE 1635 60 PUSH1 0x01 1637 60 PUSH1 0xa0 1639 1B SHL 163A 90 SWAP1 163B 91 SWAP2 163C 02 MUL 163D 17 OR 163E 60 PUSH1 0x0a 1640 55 SSTORE 1641 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @1613 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1621 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1634 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] & (0x01 << 0x60) - 0x01 // @1640 storage[0x0a] = (stack[-1] & (0x01 << 0x60) - 0x01) * (0x01 << 0xa0) | (stack[-2] & (0x01 << 0xa0) - 0x01) // } // Block ends with unconditional jump to stack[-3] label_1642: // Incoming call from 0x0BBE, returns to 0x09B4 // Inputs[1] { @1648 stack[-1] } 1642 5B JUMPDEST 1643 60 PUSH1 0x00 1645 61 PUSH2 0x164d 1648 82 DUP3 1649 61 PUSH2 0x1ddb 164C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1643 stack[0] = 0x00 // @1645 stack[1] = 0x164d // @1648 stack[2] = stack[-1] // } // Block ends with call to 0x1ddb, returns to 0x164D label_164D: // Incoming return from call to 0x1DDB at 0x164C // Inputs[1] { @1651 stack[-1] } 164D 5B JUMPDEST 164E 61 PUSH2 0x166a 1651 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x166a, if stack[-1] label_1652: // Incoming jump from 0x1651, if not stack[-1] // Inputs[3] // { // @1654 memory[0x40:0x60] // @1664 memory[0x40:0x60] // @1669 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1652 60 PUSH1 0x40 1654 51 MLOAD 1655 63 PUSH4 0x33d1c039 165A 60 PUSH1 0xe2 165C 1B SHL 165D 81 DUP2 165E 52 MSTORE 165F 60 PUSH1 0x04 1661 01 ADD 1662 60 PUSH1 0x40 1664 51 MLOAD 1665 80 DUP1 1666 91 SWAP2 1667 03 SUB 1668 90 SWAP1 1669 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @165E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x33d1c039 << 0xe2 // @1669 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_166A: // Incoming jump from 0x1651, if stack[-1] // Inputs[4] // { // @166E stack[-2] // @1679 memory[0x00:0x40] // @167A storage[keccak256(memory[0x00:0x40])] // @1684 stack[-3] // } 166A 5B JUMPDEST 166B 50 POP 166C 60 PUSH1 0x00 166E 90 SWAP1 166F 81 DUP2 1670 52 MSTORE 1671 60 PUSH1 0x06 1673 60 PUSH1 0x20 1675 52 MSTORE 1676 60 PUSH1 0x40 1678 90 SWAP1 1679 20 SHA3 167A 54 SLOAD 167B 60 PUSH1 0x01 167D 60 PUSH1 0x01 167F 60 PUSH1 0xa0 1681 1B SHL 1682 03 SUB 1683 16 AND 1684 90 SWAP1 1685 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @1670 memory[0x00:0x20] = stack[-2] // @1675 memory[0x20:0x40] = 0x06 // @1684 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1686: // Incoming call from 0x0CAE, returns to 0x0CAF // Incoming call from 0x0BF7, returns to 0x0BF8 // Inputs[5] // { // @1695 address(this) // @1699 stack[-1] // @16B3 msg.gas // @16B4 memory[0x16:0x5a] // @16B4 address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[0x16:0x5a]) // } 1686 5B JUMPDEST 1687 69 PUSH10 0xc6171134001122334455 1692 60 PUSH1 0x00 1694 52 MSTORE 1695 30 ADDRESS 1696 60 PUSH1 0x1a 1698 52 MSTORE 1699 80 DUP1 169A 60 PUSH1 0x3a 169C 52 MSTORE 169D 60 PUSH1 0x00 169F 80 DUP1 16A0 60 PUSH1 0x44 16A2 60 PUSH1 0x16 16A4 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 16B3 5A GAS 16B4 FA STATICCALL 16B5 61 PUSH2 0x16c2 16B8 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1694 memory[0x00:0x20] = 0xc6171134001122334455 // @1698 memory[0x1a:0x3a] = address(this) // @169C memory[0x3a:0x5a] = stack[-1] // @16B4 memory[0x00:0x00] = address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[0x16:0x5a]) // } // Block ends with conditional jump to 0x16c2, if address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[0x16:0x5a]) label_16B9: // Incoming jump from 0x16B8, if not address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[0x16:0x5a]) // Inputs[4] // { // @16B9 returndata.length // @16BD returndata[0x00:0x00 + returndata.length] // @16BE returndata.length // @16C1 memory[0x00:0x00 + returndata.length] // } 16B9 3D RETURNDATASIZE 16BA 60 PUSH1 0x00 16BC 80 DUP1 16BD 3E RETURNDATACOPY 16BE 3D RETURNDATASIZE 16BF 60 PUSH1 0x00 16C1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @16BD memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @16C1 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_16C2: // Incoming jump from 0x16B8, if address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[0x16:0x5a]) // Inputs[1] { @16C9 stack[-2] } 16C2 5B JUMPDEST 16C3 60 PUSH1 0x00 16C5 60 PUSH1 0x3a 16C7 52 MSTORE 16C8 50 POP 16C9 56 *JUMP // Stack delta = -2 // Outputs[1] { @16C7 memory[0x3a:0x5a] = 0x00 } // Block ends with unconditional jump to stack[-2] label_16CA: // Incoming call from 0x0C03, returns to 0x0C04 // Inputs[1] { @16D3 stack[-2] } 16CA 5B JUMPDEST 16CB 60 PUSH1 0x01 16CD 60 PUSH1 0x01 16CF 60 PUSH1 0xa0 16D1 1B SHL 16D2 03 SUB 16D3 82 DUP3 16D4 16 AND 16D5 15 ISZERO 16D6 61 PUSH2 0x0b05 16D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b05, if !(stack[-2] & (0x01 << 0xa0) - 0x01) label_16DA: // Incoming jump from 0x16D9, if not !(stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[2] // { // @16DD stack[-2] // @16DE stack[-1] // } 16DA 61 PUSH2 0x16e3 16DD 82 DUP3 16DE 82 DUP3 16DF 61 PUSH2 0x1ebe 16E2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @16DA stack[0] = 0x16e3 // @16DD stack[1] = stack[-2] // @16DE stack[2] = stack[-1] // } // Block ends with call to 0x1ebe, returns to 0x16E3 label_16E3: // Incoming return from call to 0x1EBE at 0x16E2 // Inputs[1] { @16E7 stack[-1] } 16E3 5B JUMPDEST 16E4 61 PUSH2 0x0b05 16E7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b05, if stack[-1] label_16E8: // Incoming jump from 0x16E7, if not stack[-1] // Inputs[3] // { // @16EA memory[0x40:0x60] // @16FA memory[0x40:0x60] // @16FF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 16E8 60 PUSH1 0x40 16EA 51 MLOAD 16EB 63 PUSH4 0x0a9934af 16F0 60 PUSH1 0xe3 16F2 1B SHL 16F3 81 DUP2 16F4 52 MSTORE 16F5 60 PUSH1 0x04 16F7 01 ADD 16F8 60 PUSH1 0x40 16FA 51 MLOAD 16FB 80 DUP1 16FC 91 SWAP2 16FD 03 SUB 16FE 90 SWAP1 16FF FD *REVERT // Stack delta = +0 // Outputs[2] // { // @16F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a9934af << 0xe3 // @16FF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1700: // Incoming call from 0x0C36, returns to 0x0C37 // Inputs[1] { @1706 stack[-1] } 1700 5B JUMPDEST 1701 60 PUSH1 0x00 1703 61 PUSH2 0x170b 1706 82 DUP3 1707 61 PUSH2 0x0eb1 170A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1701 stack[0] = 0x00 // @1703 stack[1] = 0x170b // @1706 stack[2] = stack[-1] // } // Block ends with call to 0x0eb1, returns to 0x170B label_170B: // Incoming return from call to 0x0EB1 at 0x170A // Inputs[3] // { // @170C stack[-1] // @170C stack[-2] // @170E msg.sender // } 170B 5B JUMPDEST 170C 90 SWAP1 170D 50 POP 170E 33 CALLER 170F 60 PUSH1 0x01 1711 60 PUSH1 0x01 1713 60 PUSH1 0xa0 1715 1B SHL 1716 03 SUB 1717 82 DUP3 1718 16 AND 1719 14 EQ 171A 61 PUSH2 0x1744 171D 57 *JUMPI // Stack delta = -1 // Outputs[1] { @170C stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1744, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_171E: // Incoming jump from 0x171D, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @1721 stack[-1] // @1722 msg.sender // } 171E 61 PUSH2 0x1727 1721 81 DUP2 1722 33 CALLER 1723 61 PUSH2 0x137b 1726 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @171E stack[0] = 0x1727 // @1721 stack[1] = stack[-1] // @1722 stack[2] = msg.sender // } // Block ends with call to 0x137b, returns to 0x1727 label_1727: // Incoming return from call to 0x137B at 0x1726 // Incoming return from call to 0x137B at 0x1726 // Inputs[1] { @172B stack[-1] } 1727 5B JUMPDEST 1728 61 PUSH2 0x1744 172B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1744, if stack[-1] label_172C: // Incoming jump from 0x172B, if not stack[-1] // Inputs[3] // { // @172E memory[0x40:0x60] // @173E memory[0x40:0x60] // @1743 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 172C 60 PUSH1 0x40 172E 51 MLOAD 172F 63 PUSH4 0x67d9dca1 1734 60 PUSH1 0xe1 1736 1B SHL 1737 81 DUP2 1738 52 MSTORE 1739 60 PUSH1 0x04 173B 01 ADD 173C 60 PUSH1 0x40 173E 51 MLOAD 173F 80 DUP1 1740 91 SWAP2 1741 03 SUB 1742 90 SWAP1 1743 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1738 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x67d9dca1 << 0xe1 // @1743 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1744: // Incoming jump from 0x171D, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming jump from 0x172B, if stack[-1] // Inputs[8] // { // @1747 stack[-2] // @1753 memory[0x00:0x40] // @1755 storage[keccak256(memory[0x00:0x40])] // @1768 stack[-3] // @1772 memory[0x40:0x60] // @1776 stack[-1] // @179B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @179F stack[-4] // } 1744 5B JUMPDEST 1745 60 PUSH1 0x00 1747 82 DUP3 1748 81 DUP2 1749 52 MSTORE 174A 60 PUSH1 0x06 174C 60 PUSH1 0x20 174E 52 MSTORE 174F 60 PUSH1 0x40 1751 80 DUP1 1752 82 DUP3 1753 20 SHA3 1754 80 DUP1 1755 54 SLOAD 1756 60 PUSH1 0x01 1758 60 PUSH1 0x01 175A 60 PUSH1 0xa0 175C 1B SHL 175D 03 SUB 175E 19 NOT 175F 16 AND 1760 60 PUSH1 0x01 1762 60 PUSH1 0x01 1764 60 PUSH1 0xa0 1766 1B SHL 1767 03 SUB 1768 87 DUP8 1769 81 DUP2 176A 16 AND 176B 91 SWAP2 176C 82 DUP3 176D 17 OR 176E 90 SWAP1 176F 92 SWAP3 1770 55 SSTORE 1771 91 SWAP2 1772 51 MLOAD 1773 85 DUP6 1774 93 SWAP4 1775 91 SWAP2 1776 85 DUP6 1777 16 AND 1778 91 SWAP2 1779 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 179A 91 SWAP2 179B A4 LOG4 179C 50 POP 179D 50 POP 179E 50 POP 179F 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1749 memory[0x00:0x20] = stack[-2] // @174E memory[0x20:0x40] = 0x06 // @1770 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @179B 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_17A0: // Incoming call from 0x0C6E, returns to 0x0AD0 // Inputs[5] // { // @17C2 stack[-1] // @17C7 memory[0x40:0x60] // @17CA msg.sender // @17F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @17F3 stack[-2] // } 17A0 5B JUMPDEST 17A1 7F PUSH32 0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a621 17C2 81 DUP2 17C3 90 SWAP1 17C4 55 SSTORE 17C5 60 PUSH1 0x40 17C7 51 MLOAD 17C8 81 DUP2 17C9 90 SWAP1 17CA 33 CALLER 17CB 90 SWAP1 17CC 7F PUSH32 0x8962277f6a1fe666523bc8356e92ca0332d6cbbc6ac21edbbcbb5ceaa258536a 17ED 90 SWAP1 17EE 60 PUSH1 0x00 17F0 90 SWAP1 17F1 A3 LOG3 17F2 50 POP 17F3 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @17C4 storage[0x7182bc540a919506f5dbc9f55afae7cdd4ca476499f0017cee40bdc99f34a621] = stack[-1] // @17F1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8962277f6a1fe666523bc8356e92ca0332d6cbbc6ac21edbbcbb5ceaa258536a, msg.sender, stack[-1]]); // } // Block ends with unconditional jump to stack[-2] label_17F4: // Incoming call from 0x0CE2, returns to 0x0CE3 // Inputs[1] { @17FA stack[-1] } 17F4 5B JUMPDEST 17F5 60 PUSH1 0x00 17F7 61 PUSH2 0x17ff 17FA 82 DUP3 17FB 61 PUSH2 0x1a8d 17FE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @17F5 stack[0] = 0x00 // @17F7 stack[1] = 0x17ff // @17FA stack[2] = stack[-1] // } // Block ends with call to 0x1a8d, returns to 0x17FF label_17FF: // Incoming return from call to 0x1A8D at 0x17FE // Inputs[3] // { // @1800 stack[-2] // @1800 stack[-1] // @1802 stack[-5] // } 17FF 5B JUMPDEST 1800 90 SWAP1 1801 50 POP 1802 83 DUP4 1803 60 PUSH1 0x01 1805 60 PUSH1 0x01 1807 60 PUSH1 0xa0 1809 1B SHL 180A 03 SUB 180B 16 AND 180C 81 DUP2 180D 60 PUSH1 0x01 180F 60 PUSH1 0x01 1811 60 PUSH1 0xa0 1813 1B SHL 1814 03 SUB 1815 16 AND 1816 14 EQ 1817 61 PUSH2 0x1832 181A 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1800 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1832, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] label_181B: // Incoming jump from 0x181A, if not (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @181D memory[0x40:0x60] // @182C memory[0x40:0x60] // @1831 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 181B 60 PUSH1 0x40 181D 51 MLOAD 181E 62 PUSH3 0xa11481 1822 60 PUSH1 0xe8 1824 1B SHL 1825 81 DUP2 1826 52 MSTORE 1827 60 PUSH1 0x04 1829 01 ADD 182A 60 PUSH1 0x40 182C 51 MLOAD 182D 80 DUP1 182E 91 SWAP2 182F 03 SUB 1830 90 SWAP1 1831 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1826 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa11481 << 0xe8 // @1831 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1832: // Incoming jump from 0x181A, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[5] // { // @1835 stack[-2] // @1840 memory[0x00:0x40] // @1842 storage[keccak256(memory[0x00:0x40])] // @1843 msg.sender // @184F stack[-4] // } 1832 5B JUMPDEST 1833 60 PUSH1 0x00 1835 82 DUP3 1836 81 DUP2 1837 52 MSTORE 1838 60 PUSH1 0x06 183A 60 PUSH1 0x20 183C 52 MSTORE 183D 60 PUSH1 0x40 183F 90 SWAP1 1840 20 SHA3 1841 80 DUP1 1842 54 SLOAD 1843 33 CALLER 1844 80 DUP1 1845 82 DUP3 1846 14 EQ 1847 60 PUSH1 0x01 1849 60 PUSH1 0x01 184B 60 PUSH1 0xa0 184D 1B SHL 184E 03 SUB 184F 88 DUP9 1850 16 AND 1851 90 SWAP1 1852 91 SWAP2 1853 14 EQ 1854 17 OR 1855 61 PUSH2 0x187f 1858 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1837 memory[0x00:0x20] = stack[-2] // @183C memory[0x20:0x40] = 0x06 // @1840 stack[0] = keccak256(memory[0x00:0x40]) // @1842 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x187f, if (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) label_1859: // Incoming jump from 0x1858, if not (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Inputs[2] // { // @185C stack[-6] // @185D msg.sender // } 1859 61 PUSH2 0x1862 185C 86 DUP7 185D 33 CALLER 185E 61 PUSH2 0x137b 1861 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1859 stack[0] = 0x1862 // @185C stack[1] = stack[-6] // @185D stack[2] = msg.sender // } // Block ends with call to 0x137b, returns to 0x1862 label_1862: // Incoming return from call to 0x137B at 0x1861 // Incoming return from call to 0x137B at 0x1861 // Inputs[1] { @1866 stack[-1] } 1862 5B JUMPDEST 1863 61 PUSH2 0x187f 1866 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x187f, if stack[-1] label_1867: // Incoming jump from 0x1866, if not stack[-1] // Inputs[3] // { // @1869 memory[0x40:0x60] // @1879 memory[0x40:0x60] // @187E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1867 60 PUSH1 0x40 1869 51 MLOAD 186A 63 PUSH4 0x2ce44b5f 186F 60 PUSH1 0xe1 1871 1B SHL 1872 81 DUP2 1873 52 MSTORE 1874 60 PUSH1 0x04 1876 01 ADD 1877 60 PUSH1 0x40 1879 51 MLOAD 187A 80 DUP1 187B 91 SWAP2 187C 03 SUB 187D 90 SWAP1 187E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1873 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @187E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_187F: // Incoming jump from 0x1858, if (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Incoming jump from 0x1866, if stack[-1] // Inputs[1] { @1888 stack[-5] } 187F 5B JUMPDEST 1880 60 PUSH1 0x01 1882 60 PUSH1 0x01 1884 60 PUSH1 0xa0 1886 1B SHL 1887 03 SUB 1888 85 DUP6 1889 16 AND 188A 61 PUSH2 0x18a6 188D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x18a6, if stack[-5] & (0x01 << 0xa0) - 0x01 label_188E: // Incoming jump from 0x188D, if not stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1890 memory[0x40:0x60] // @18A0 memory[0x40:0x60] // @18A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 188E 60 PUSH1 0x40 1890 51 MLOAD 1891 63 PUSH4 0x3a954ecd 1896 60 PUSH1 0xe2 1898 1B SHL 1899 81 DUP2 189A 52 MSTORE 189B 60 PUSH1 0x04 189D 01 ADD 189E 60 PUSH1 0x40 18A0 51 MLOAD 18A1 80 DUP1 18A2 91 SWAP2 18A3 03 SUB 18A4 90 SWAP1 18A5 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @189A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3a954ecd << 0xe2 // @18A5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_18A6: // Incoming jump from 0x188D, if stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @18AA stack[-6] // @18AB stack[-5] // @18AC stack[-4] // } 18A6 5B JUMPDEST 18A7 61 PUSH2 0x18b3 18AA 86 DUP7 18AB 86 DUP7 18AC 86 DUP7 18AD 60 PUSH1 0x01 18AF 61 PUSH2 0x1ec9 18B2 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @18A7 stack[0] = 0x18b3 // @18AA stack[1] = stack[-6] // @18AB stack[2] = stack[-5] // @18AC stack[3] = stack[-4] // @18AD stack[4] = 0x01 // } // Block ends with call to 0x1ec9, returns to 0x18B3 label_18B3: // Incoming return from call to 0x1EC9 at 0x18B2 // Inputs[1] { @18B4 stack[-1] } 18B3 5B JUMPDEST 18B4 80 DUP1 18B5 15 ISZERO 18B6 61 PUSH2 0x18be 18B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x18be, if !stack[-1] label_18BA: // Incoming jump from 0x18B9, if not !stack[-1] // Inputs[11] // { // @18BC stack[-2] // @18C7 stack[-6] // @18D8 memory[0x00:0x40] // @18DA storage[keccak256(memory[0x00:0x40])] // @18E2 stack[-5] // @18E9 memory[0x00:0x40] // @18EB storage[keccak256(memory[0x00:0x40])] // @18F1 block.timestamp // @18FE stack[-4] // @1909 memory[0x00:0x40] // @1913 stack[-3] // } 18BA 60 PUSH1 0x00 18BC 82 DUP3 18BD 55 SSTORE 18BE 5B JUMPDEST 18BF 60 PUSH1 0x01 18C1 60 PUSH1 0x01 18C3 60 PUSH1 0xa0 18C5 1B SHL 18C6 03 SUB 18C7 86 DUP7 18C8 81 DUP2 18C9 16 AND 18CA 60 PUSH1 0x00 18CC 90 SWAP1 18CD 81 DUP2 18CE 52 MSTORE 18CF 60 PUSH1 0x05 18D1 60 PUSH1 0x20 18D3 52 MSTORE 18D4 60 PUSH1 0x40 18D6 80 DUP1 18D7 82 DUP3 18D8 20 SHA3 18D9 80 DUP1 18DA 54 SLOAD 18DB 60 PUSH1 0x00 18DD 19 NOT 18DE 01 ADD 18DF 90 SWAP1 18E0 55 SSTORE 18E1 91 SWAP2 18E2 87 DUP8 18E3 16 AND 18E4 80 DUP1 18E5 82 DUP3 18E6 52 MSTORE 18E7 91 SWAP2 18E8 90 SWAP1 18E9 20 SHA3 18EA 80 DUP1 18EB 54 SLOAD 18EC 60 PUSH1 0x01 18EE 01 ADD 18EF 90 SWAP1 18F0 55 SSTORE 18F1 42 TIMESTAMP 18F2 60 PUSH1 0xa0 18F4 1B SHL 18F5 17 OR 18F6 60 PUSH1 0x01 18F8 60 PUSH1 0xe1 18FA 1B SHL 18FB 17 OR 18FC 60 PUSH1 0x00 18FE 85 DUP6 18FF 81 DUP2 1900 52 MSTORE 1901 60 PUSH1 0x04 1903 60 PUSH1 0x20 1905 52 MSTORE 1906 60 PUSH1 0x40 1908 81 DUP2 1909 20 SHA3 190A 91 SWAP2 190B 90 SWAP1 190C 91 SWAP2 190D 55 SSTORE 190E 60 PUSH1 0x01 1910 60 PUSH1 0xe1 1912 1B SHL 1913 84 DUP5 1914 16 AND 1915 90 SWAP1 1916 03 SUB 1917 61 PUSH2 0x1950 191A 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @18BD storage[stack[-2]] = 0x00 // @18CE memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @18D3 memory[0x20:0x40] = 0x05 // @18E0 storage[keccak256(memory[0x00:0x40])] = ~0x00 + storage[keccak256(memory[0x00:0x40])] // @18E6 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @18F0 storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // @1900 memory[0x00:0x20] = stack[-4] // @1905 memory[0x20:0x40] = 0x04 // @190D storage[keccak256(memory[0x00:0x40])] = (0x01 << 0xe1) | (block.timestamp << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) // } // Block ends with conditional jump to 0x1950, if 0x00 - (stack[-3] & (0x01 << 0xe1)) label_191B: // Incoming jump from 0x191A, if not 0x00 - (stack[-3] & (0x01 << 0xe1)) // Incoming jump from 0x191A, if not 0x00 - (stack[-3] & (0x01 << 0xe1)) // Inputs[3] // { // @191D stack[-4] // @192C memory[0x00:0x40] // @192D storage[keccak256(memory[0x00:0x40])] // } 191B 60 PUSH1 0x01 191D 84 DUP5 191E 01 ADD 191F 60 PUSH1 0x00 1921 81 DUP2 1922 81 DUP2 1923 52 MSTORE 1924 60 PUSH1 0x04 1926 60 PUSH1 0x20 1928 52 MSTORE 1929 60 PUSH1 0x40 192B 81 DUP2 192C 20 SHA3 192D 54 SLOAD 192E 90 SWAP1 192F 03 SUB 1930 61 PUSH2 0x194e 1933 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @191E stack[0] = stack[-4] + 0x01 // @1923 memory[0x00:0x20] = stack[-4] + 0x01 // @1928 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x194e, if 0x00 - storage[keccak256(memory[0x00:0x40])] label_1934: // Incoming jump from 0x1933, if not 0x00 - storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @1936 storage[0x00] // @1937 stack[-1] // } 1934 60 PUSH1 0x00 1936 54 SLOAD 1937 81 DUP2 1938 14 EQ 1939 61 PUSH2 0x194e 193C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x194e, if stack[-1] == storage[0x00] label_193D: // Incoming jump from 0x193C, if not stack[-1] == storage[0x00] // Inputs[3] // { // @193F stack[-1] // @194A memory[0x00:0x40] // @194B stack[-4] // } 193D 60 PUSH1 0x00 193F 81 DUP2 1940 81 DUP2 1941 52 MSTORE 1942 60 PUSH1 0x04 1944 60 PUSH1 0x20 1946 52 MSTORE 1947 60 PUSH1 0x40 1949 90 SWAP1 194A 20 SHA3 194B 84 DUP5 194C 90 SWAP1 194D 55 SSTORE // Stack delta = +0 // Outputs[3] // { // @1941 memory[0x00:0x20] = stack[-1] // @1946 memory[0x20:0x40] = 0x04 // @194D storage[keccak256(memory[0x00:0x40])] = stack[-4] // } // Block continues label_194E: // Incoming jump from 0x1933, if 0x00 - storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x194D // Incoming jump from 0x193C, if stack[-1] == storage[0x00] 194E 5B JUMPDEST 194F 50 POP // Stack delta = -1 // Block continues label_1950: // Incoming jump from 0x191A, if 0x00 - (stack[-3] & (0x01 << 0xe1)) // Incoming jump from 0x194F // Incoming jump from 0x191A, if 0x00 - (stack[-3] & (0x01 << 0xe1)) // Inputs[6] // { // @1951 stack[-4] // @1952 stack[-5] // @195C stack[-6] // @1989 memory[0x40:0x60] // @198C memory[0x40:0x60] // @1991 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 1950 5B JUMPDEST 1951 83 DUP4 1952 85 DUP6 1953 60 PUSH1 0x01 1955 60 PUSH1 0x01 1957 60 PUSH1 0xa0 1959 1B SHL 195A 03 SUB 195B 16 AND 195C 87 DUP8 195D 60 PUSH1 0x01 195F 60 PUSH1 0x01 1961 60 PUSH1 0xa0 1963 1B SHL 1964 03 SUB 1965 16 AND 1966 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1987 60 PUSH1 0x40 1989 51 MLOAD 198A 60 PUSH1 0x40 198C 51 MLOAD 198D 80 DUP1 198E 91 SWAP2 198F 03 SUB 1990 90 SWAP1 1991 A4 LOG4 1992 61 PUSH2 0x10ee 1995 56 *JUMP // Stack delta = +0 // Outputs[1] { @1991 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5] & (0x01 << 0xa0) - 0x01, stack[-4]]); } // Block ends with unconditional jump to 0x10ee label_1996: // Incoming jump from 0x1297 // Incoming jump from 0x133E // Incoming jump from 0x0D60 // Incoming jump from 0x0FD1 // Inputs[2] // { // @199A stack[-1] // @199B msg.sender // } 1996 5B JUMPDEST 1997 61 PUSH2 0x0ad0 199A 81 DUP2 199B 33 CALLER 199C 61 PUSH2 0x1ee3 199F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1997 stack[0] = 0x0ad0 // @199A stack[1] = stack[-1] // @199B stack[2] = msg.sender // } // Block ends with call to 0x1ee3, returns to 0x0AD0 19A0 5B JUMPDEST 19A1 61 PUSH2 0x19aa 19A4 82 DUP3 19A5 82 DUP3 19A6 61 PUSH2 0x0fdc 19A9 56 *JUMP 19AA 5B JUMPDEST 19AB 61 PUSH2 0x0b05 19AE 57 *JUMPI 19AF 60 PUSH1 0x00 19B1 82 DUP3 19B2 81 DUP2 19B3 52 MSTORE 19B4 60 PUSH1 0x09 19B6 60 PUSH1 0x20 19B8 90 SWAP1 19B9 81 DUP2 19BA 52 MSTORE 19BB 60 PUSH1 0x40 19BD 80 DUP1 19BE 83 DUP4 19BF 20 SHA3 19C0 60 PUSH1 0x01 19C2 60 PUSH1 0x01 19C4 60 PUSH1 0xa0 19C6 1B SHL 19C7 03 SUB 19C8 85 DUP6 19C9 16 AND 19CA 84 DUP5 19CB 52 MSTORE 19CC 90 SWAP1 19CD 91 SWAP2 19CE 52 MSTORE 19CF 90 SWAP1 19D0 20 SHA3 19D1 80 DUP1 19D2 54 SLOAD 19D3 60 PUSH1 0xff 19D5 19 NOT 19D6 16 AND 19D7 60 PUSH1 0x01 19D9 17 OR 19DA 90 SWAP1 19DB 55 SSTORE 19DC 61 PUSH2 0x19e2 19DF 33 CALLER 19E0 90 SWAP1 19E1 56 *JUMP 19E2 5B JUMPDEST 19E3 60 PUSH1 0x01 19E5 60 PUSH1 0x01 19E7 60 PUSH1 0xa0 19E9 1B SHL 19EA 03 SUB 19EB 16 AND 19EC 81 DUP2 19ED 60 PUSH1 0x01 19EF 60 PUSH1 0x01 19F1 60 PUSH1 0xa0 19F3 1B SHL 19F4 03 SUB 19F5 16 AND 19F6 83 DUP4 19F7 7F PUSH32 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d 1A18 60 PUSH1 0x40 1A1A 51 MLOAD 1A1B 60 PUSH1 0x40 1A1D 51 MLOAD 1A1E 80 DUP1 1A1F 91 SWAP2 1A20 03 SUB 1A21 90 SWAP1 1A22 A4 LOG4 1A23 50 POP 1A24 50 POP 1A25 56 *JUMP label_1A26: // Incoming call from 0x0DEE, returns to 0x0B05 // Inputs[2] // { // @1A2A stack[-2] // @1A2B stack[-1] // } 1A26 5B JUMPDEST 1A27 61 PUSH2 0x1a30 1A2A 82 DUP3 1A2B 82 DUP3 1A2C 61 PUSH2 0x0fdc 1A2F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A27 stack[0] = 0x1a30 // @1A2A stack[1] = stack[-2] // @1A2B stack[2] = stack[-1] // } // Block ends with call to 0x0fdc, returns to 0x1A30 label_1A30: // Incoming return from call to 0x0FDC at 0x1A2F // Inputs[1] { @1A31 stack[-1] } 1A30 5B JUMPDEST 1A31 15 ISZERO 1A32 61 PUSH2 0x0b05 1A35 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b05, if !stack[-1] label_1A36: // Incoming jump from 0x1A35, if not !stack[-1] // Inputs[9] // { // @1A38 stack[-2] // @1A46 memory[0x00:0x40] // @1A4F stack[-1] // @1A58 memory[0x00:0x40] // @1A5A storage[keccak256(memory[0x00:0x40])] // @1A61 memory[0x40:0x60] // @1A62 msg.sender // @1A89 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1A8C stack[-3] // } 1A36 60 PUSH1 0x00 1A38 82 DUP3 1A39 81 DUP2 1A3A 52 MSTORE 1A3B 60 PUSH1 0x09 1A3D 60 PUSH1 0x20 1A3F 90 SWAP1 1A40 81 DUP2 1A41 52 MSTORE 1A42 60 PUSH1 0x40 1A44 80 DUP1 1A45 83 DUP4 1A46 20 SHA3 1A47 60 PUSH1 0x01 1A49 60 PUSH1 0x01 1A4B 60 PUSH1 0xa0 1A4D 1B SHL 1A4E 03 SUB 1A4F 85 DUP6 1A50 16 AND 1A51 80 DUP1 1A52 85 DUP6 1A53 52 MSTORE 1A54 92 SWAP3 1A55 52 MSTORE 1A56 80 DUP1 1A57 83 DUP4 1A58 20 SHA3 1A59 80 DUP1 1A5A 54 SLOAD 1A5B 60 PUSH1 0xff 1A5D 19 NOT 1A5E 16 AND 1A5F 90 SWAP1 1A60 55 SSTORE 1A61 51 MLOAD 1A62 33 CALLER 1A63 92 SWAP3 1A64 85 DUP6 1A65 91 SWAP2 1A66 7F PUSH32 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b 1A87 91 SWAP2 1A88 90 SWAP1 1A89 A4 LOG4 1A8A 50 POP 1A8B 50 POP 1A8C 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @1A3A memory[0x00:0x20] = stack[-2] // @1A41 memory[0x20:0x40] = 0x09 // @1A53 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1A55 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1A60 storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // @1A89 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b, stack[-2], stack[-1] & (0x01 << 0xa0) - 0x01, msg.sender]); // } // Block ends with unconditional jump to stack[-3] label_1A8D: // Incoming call from 0x0EBB, returns to 0x09B4 // Incoming call from 0x17FE, returns to 0x17FF // Inputs[1] { @1A90 stack[-1] } 1A8D 5B JUMPDEST 1A8E 60 PUSH1 0x00 1A90 81 DUP2 1A91 80 DUP1 1A92 60 PUSH1 0x01 1A94 11 GT 1A95 61 PUSH2 0x1ae3 1A98 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A8E stack[0] = 0x00 // @1A90 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1ae3, if 0x01 > stack[-1] label_1A99: // Incoming jump from 0x1A98, if not 0x01 > stack[-1] // Inputs[2] // { // @1A9B storage[0x00] // @1A9C stack[-1] // } 1A99 60 PUSH1 0x00 1A9B 54 SLOAD 1A9C 81 DUP2 1A9D 10 LT 1A9E 15 ISZERO 1A9F 61 PUSH2 0x1ae3 1AA2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ae3, if !(stack[-1] < storage[0x00]) label_1AA3: // Incoming jump from 0x1AA2, if not !(stack[-1] < storage[0x00]) // Inputs[3] // { // @1AA5 stack[-1] // @1AB0 memory[0x00:0x40] // @1AB1 storage[keccak256(memory[0x00:0x40])] // } 1AA3 60 PUSH1 0x00 1AA5 81 DUP2 1AA6 81 DUP2 1AA7 52 MSTORE 1AA8 60 PUSH1 0x04 1AAA 60 PUSH1 0x20 1AAC 52 MSTORE 1AAD 60 PUSH1 0x40 1AAF 81 DUP2 1AB0 20 SHA3 1AB1 54 SLOAD 1AB2 90 SWAP1 1AB3 60 PUSH1 0x01 1AB5 60 PUSH1 0xe0 1AB7 1B SHL 1AB8 82 DUP3 1AB9 16 AND 1ABA 90 SWAP1 1ABB 03 SUB 1ABC 61 PUSH2 0x1ae1 1ABF 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1AA7 memory[0x00:0x20] = stack[-1] // @1AAC memory[0x20:0x40] = 0x04 // @1AB2 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1ae1, if 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) label_1AC0: // Incoming jump from 0x1ABF, if not 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) // Incoming jump from 0x1AE0 // Inputs[1] { @1AC1 stack[-1] } 1AC0 5B JUMPDEST 1AC1 80 DUP1 1AC2 60 PUSH1 0x00 1AC4 03 SUB 1AC5 61 PUSH2 0x13c0 1AC8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13c0, if 0x00 - stack[-1] label_1AC9: // Incoming jump from 0x1AC8, if not 0x00 - stack[-1] // Inputs[3] // { // @1ACD stack[-2] // @1ADB memory[0x00:0x40] // @1ADC storage[keccak256(memory[0x00:0x40])] // } 1AC9 50 POP 1ACA 60 PUSH1 0x00 1ACC 19 NOT 1ACD 01 ADD 1ACE 60 PUSH1 0x00 1AD0 81 DUP2 1AD1 81 DUP2 1AD2 52 MSTORE 1AD3 60 PUSH1 0x04 1AD5 60 PUSH1 0x20 1AD7 52 MSTORE 1AD8 60 PUSH1 0x40 1ADA 90 SWAP1 1ADB 20 SHA3 1ADC 54 SLOAD 1ADD 61 PUSH2 0x1ac0 1AE0 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1ACD stack[-2] = ~0x00 + stack[-2] // @1AD2 memory[0x00:0x20] = ~0x00 + stack[-2] // @1AD7 memory[0x20:0x40] = 0x04 // @1ADC stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x1ac0 label_1AE1: // Incoming jump from 0x1ABF, if 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) 1AE1 5B JUMPDEST 1AE2 50 POP // Stack delta = -1 // Block continues label_1AE3: // Incoming jump from 0x1AA2, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x1AE2 // Incoming jump from 0x1A98, if 0x01 > stack[-1] // Inputs[3] // { // @1AE6 memory[0x40:0x60] // @1AF6 memory[0x40:0x60] // @1AFB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1AE3 5B JUMPDEST 1AE4 60 PUSH1 0x40 1AE6 51 MLOAD 1AE7 63 PUSH4 0x6f96cda1 1AEC 60 PUSH1 0xe1 1AEE 1B SHL 1AEF 81 DUP2 1AF0 52 MSTORE 1AF1 60 PUSH1 0x04 1AF3 01 ADD 1AF4 60 PUSH1 0x40 1AF6 51 MLOAD 1AF7 80 DUP1 1AF8 91 SWAP2 1AF9 03 SUB 1AFA 90 SWAP1 1AFB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1AF0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @1AFB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1AFC: // Incoming call from 0x0F6A, returns to 0x0F6B // Incoming call from 0x13CE, returns to 0x13CF // Inputs[2] // { // @1AFF storage[0x08] // @1B09 msg.sender // } 1AFC 5B JUMPDEST 1AFD 60 PUSH1 0x08 1AFF 54 SLOAD 1B00 60 PUSH1 0x01 1B02 60 PUSH1 0x01 1B04 60 PUSH1 0xa0 1B06 1B SHL 1B07 03 SUB 1B08 16 AND 1B09 33 CALLER 1B0A 14 EQ 1B0B 61 PUSH2 0x0f75 1B0E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f75, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_1B0F: // Incoming jump from 0x1B0E, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @1B11 memory[0x40:0x60] } 1B0F 60 PUSH1 0x40 1B11 51 MLOAD 1B12 62 PUSH3 0x461bcd 1B16 60 PUSH1 0xe5 1B18 1B SHL 1B19 81 DUP2 1B1A 52 MSTORE 1B1B 60 PUSH1 0x20 1B1D 60 PUSH1 0x04 1B1F 82 DUP3 1B20 01 ADD 1B21 81 DUP2 1B22 90 SWAP1 1B23 52 MSTORE 1B24 60 PUSH1 0x24 1B26 82 DUP3 1B27 01 ADD 1B28 52 MSTORE 1B29 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1B4A 60 PUSH1 0x44 1B4C 82 DUP3 1B4D 01 ADD 1B4E 52 MSTORE 1B4F 60 PUSH1 0x64 1B51 01 ADD 1B52 61 PUSH2 0x0ddc 1B55 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1B1A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B23 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1B28 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1B4E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1B51 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0ddc label_1B56: // Incoming call from 0x143C, returns to 0x0AD0 // Incoming call from 0x0F74, returns to 0x0F75 // Inputs[5] // { // @1B5A storage[0x08] // @1B63 stack[-1] // @1B78 memory[0x40:0x60] // @1BA4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1BA7 stack[-2] // } 1B56 5B JUMPDEST 1B57 60 PUSH1 0x08 1B59 80 DUP1 1B5A 54 SLOAD 1B5B 60 PUSH1 0x01 1B5D 60 PUSH1 0x01 1B5F 60 PUSH1 0xa0 1B61 1B SHL 1B62 03 SUB 1B63 83 DUP4 1B64 81 DUP2 1B65 16 AND 1B66 60 PUSH1 0x01 1B68 60 PUSH1 0x01 1B6A 60 PUSH1 0xa0 1B6C 1B SHL 1B6D 03 SUB 1B6E 19 NOT 1B6F 83 DUP4 1B70 16 AND 1B71 81 DUP2 1B72 17 OR 1B73 90 SWAP1 1B74 93 SWAP4 1B75 55 SSTORE 1B76 60 PUSH1 0x40 1B78 51 MLOAD 1B79 91 SWAP2 1B7A 16 AND 1B7B 91 SWAP2 1B7C 90 SWAP1 1B7D 82 DUP3 1B7E 90 SWAP1 1B7F 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1BA0 90 SWAP1 1BA1 60 PUSH1 0x00 1BA3 90 SWAP1 1BA4 A3 LOG3 1BA5 50 POP 1BA6 50 POP 1BA7 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1B75 storage[0x08] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x08] & ~((0x01 << 0xa0) - 0x01)) // @1BA4 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x08] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_1BA8: // Incoming call from 0x0FA7, returns to 0x0AD0 // Inputs[3] // { // @1BAF memory[0x00:0x20] // @1BB8 memory[0x00:0x20] // @1BBB stack[-1] // } 1BA8 5B JUMPDEST 1BA9 61 PUSH2 0x1bc0 1BAC 60 PUSH1 0x00 1BAE 80 DUP1 1BAF 51 MLOAD 1BB0 60 PUSH1 0x20 1BB2 61 PUSH2 0x29ee 1BB5 83 DUP4 1BB6 39 CODECOPY 1BB7 81 DUP2 1BB8 51 MLOAD 1BB9 91 SWAP2 1BBA 52 MSTORE 1BBB 82 DUP3 1BBC 61 PUSH2 0x1f3c 1BBF 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1BA9 stack[0] = 0x1bc0 // @1BB6 memory[0x00:0x20] = code[0x29ee:0x2a0e] // @1BB9 stack[1] = memory[0x00:0x20] // @1BBA memory[0x00:0x20] = memory[0x00:0x20] // @1BBB stack[2] = stack[-1] // } // Block ends with call to 0x1f3c, returns to 0x1BC0 label_1BC0: // Incoming return from call to 0x1F3C at 0x1BBF // Inputs[5] // { // @1BC4 memory[0x40:0x60] // @1BCD stack[-2] // @1BD0 msg.sender // @1BF7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1BF9 stack[-3] // } 1BC0 5B JUMPDEST 1BC1 50 POP 1BC2 60 PUSH1 0x40 1BC4 51 MLOAD 1BC5 60 PUSH1 0x01 1BC7 60 PUSH1 0x01 1BC9 60 PUSH1 0xa0 1BCB 1B SHL 1BCC 03 SUB 1BCD 82 DUP3 1BCE 16 AND 1BCF 90 SWAP1 1BD0 33 CALLER 1BD1 90 SWAP1 1BD2 7F PUSH32 0x3b01c97343869ca2757fcc37cdb8f71683b0a7aed858e3755f4529a1db857292 1BF3 90 SWAP1 1BF4 60 PUSH1 0x00 1BF6 90 SWAP1 1BF7 A3 LOG3 1BF8 50 POP 1BF9 56 *JUMP // Stack delta = -3 // Outputs[1] { @1BF7 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x3b01c97343869ca2757fcc37cdb8f71683b0a7aed858e3755f4529a1db857292, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-3] 1BFA 5B JUMPDEST 1BFB 61 PUSH2 0x0b05 1BFE 82 DUP3 1BFF 82 DUP3 1C00 60 PUSH1 0x40 1C02 51 MLOAD 1C03 80 DUP1 1C04 60 PUSH1 0x20 1C06 01 ADD 1C07 60 PUSH1 0x40 1C09 52 MSTORE 1C0A 80 DUP1 1C0B 60 PUSH1 0x00 1C0D 81 DUP2 1C0E 52 MSTORE 1C0F 50 POP 1C10 61 PUSH2 0x1f51 1C13 56 *JUMP 1C14 5B JUMPDEST 1C15 80 DUP1 1C16 15 ISZERO 1C17 61 PUSH2 0x0d6b 1C1A 57 *JUMPI 1C1B 61 PUSH2 0x1c24 1C1E 83 DUP4 1C1F 83 DUP4 1C20 61 PUSH2 0x1ebe 1C23 56 *JUMP 1C24 5B JUMPDEST 1C25 61 PUSH2 0x0d6b 1C28 57 *JUMPI 1C29 60 PUSH1 0x40 1C2B 51 MLOAD 1C2C 63 PUSH4 0x0a9934af 1C31 60 PUSH1 0xe3 1C33 1B SHL 1C34 81 DUP2 1C35 52 MSTORE 1C36 60 PUSH1 0x04 1C38 01 ADD 1C39 60 PUSH1 0x40 1C3B 51 MLOAD 1C3C 80 DUP1 1C3D 91 SWAP2 1C3E 03 SUB 1C3F 90 SWAP1 1C40 FD *REVERT 1C41 5B JUMPDEST 1C42 33 CALLER 1C43 60 PUSH1 0x00 1C45 81 DUP2 1C46 81 DUP2 1C47 52 MSTORE 1C48 60 PUSH1 0x07 1C4A 60 PUSH1 0x20 1C4C 90 SWAP1 1C4D 81 DUP2 1C4E 52 MSTORE 1C4F 60 PUSH1 0x40 1C51 80 DUP1 1C52 83 DUP4 1C53 20 SHA3 1C54 60 PUSH1 0x01 1C56 60 PUSH1 0x01 1C58 60 PUSH1 0xa0 1C5A 1B SHL 1C5B 03 SUB 1C5C 87 DUP8 1C5D 16 AND 1C5E 80 DUP1 1C5F 85 DUP6 1C60 52 MSTORE 1C61 90 SWAP1 1C62 83 DUP4 1C63 52 MSTORE 1C64 92 SWAP3 1C65 81 DUP2 1C66 90 SWAP1 1C67 20 SHA3 1C68 80 DUP1 1C69 54 SLOAD 1C6A 60 PUSH1 0xff 1C6C 19 NOT 1C6D 16 AND 1C6E 86 DUP7 1C6F 15 ISZERO 1C70 15 ISZERO 1C71 90 SWAP1 1C72 81 DUP2 1C73 17 OR 1C74 90 SWAP1 1C75 91 SWAP2 1C76 55 SSTORE 1C77 90 SWAP1 1C78 51 MLOAD 1C79 90 SWAP1 1C7A 81 DUP2 1C7B 52 MSTORE 1C7C 91 SWAP2 1C7D 92 SWAP3 1C7E 91 SWAP2 1C7F 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1CA0 91 SWAP2 1CA1 01 ADD 1CA2 60 PUSH1 0x40 1CA4 51 MLOAD 1CA5 80 DUP1 1CA6 91 SWAP2 1CA7 03 SUB 1CA8 90 SWAP1 1CA9 A3 LOG3 1CAA 50 POP 1CAB 50 POP 1CAC 56 *JUMP 1CAD 5B JUMPDEST 1CAE 60 PUSH1 0x40 1CB0 51 MLOAD 1CB1 63 PUSH4 0x0a85bd01 1CB6 60 PUSH1 0xe1 1CB8 1B SHL 1CB9 81 DUP2 1CBA 52 MSTORE 1CBB 60 PUSH1 0x00 1CBD 90 SWAP1 1CBE 60 PUSH1 0x01 1CC0 60 PUSH1 0x01 1CC2 60 PUSH1 0xa0 1CC4 1B SHL 1CC5 03 SUB 1CC6 85 DUP6 1CC7 16 AND 1CC8 90 SWAP1 1CC9 63 PUSH4 0x150b7a02 1CCE 90 SWAP1 1CCF 61 PUSH2 0x1ce2 1CD2 90 SWAP1 1CD3 33 CALLER 1CD4 90 SWAP1 1CD5 89 DUP10 1CD6 90 SWAP1 1CD7 88 DUP9 1CD8 90 SWAP1 1CD9 88 DUP9 1CDA 90 SWAP1 1CDB 60 PUSH1 0x04 1CDD 01 ADD 1CDE 61 PUSH2 0x28b5 1CE1 56 *JUMP 1CE2 5B JUMPDEST 1CE3 60 PUSH1 0x20 1CE5 60 PUSH1 0x40 1CE7 51 MLOAD 1CE8 80 DUP1 1CE9 83 DUP4 1CEA 03 SUB 1CEB 81 DUP2 1CEC 60 PUSH1 0x00 1CEE 87 DUP8 1CEF 5A GAS 1CF0 F1 CALL 1CF1 92 SWAP3 1CF2 50 POP 1CF3 50 POP 1CF4 50 POP 1CF5 80 DUP1 1CF6 15 ISZERO 1CF7 61 PUSH2 0x1d1d 1CFA 57 *JUMPI 1CFB 50 POP 1CFC 60 PUSH1 0x40 1CFE 80 DUP1 1CFF 51 MLOAD 1D00 60 PUSH1 0x1f 1D02 3D RETURNDATASIZE 1D03 90 SWAP1 1D04 81 DUP2 1D05 01 ADD 1D06 60 PUSH1 0x1f 1D08 19 NOT 1D09 16 AND 1D0A 82 DUP3 1D0B 01 ADD 1D0C 90 SWAP1 1D0D 92 SWAP3 1D0E 52 MSTORE 1D0F 61 PUSH2 0x1d1a 1D12 91 SWAP2 1D13 81 DUP2 1D14 01 ADD 1D15 90 SWAP1 1D16 61 PUSH2 0x28f2 1D19 56 *JUMP 1D1A 5B JUMPDEST 1D1B 60 PUSH1 0x01 1D1D 5B JUMPDEST 1D1E 61 PUSH2 0x1d7b 1D21 57 *JUMPI 1D22 3D RETURNDATASIZE 1D23 80 DUP1 1D24 80 DUP1 1D25 15 ISZERO 1D26 61 PUSH2 0x1d4b 1D29 57 *JUMPI 1D2A 60 PUSH1 0x40 1D2C 51 MLOAD 1D2D 91 SWAP2 1D2E 50 POP 1D2F 60 PUSH1 0x1f 1D31 19 NOT 1D32 60 PUSH1 0x3f 1D34 3D RETURNDATASIZE 1D35 01 ADD 1D36 16 AND 1D37 82 DUP3 1D38 01 ADD 1D39 60 PUSH1 0x40 1D3B 52 MSTORE 1D3C 3D RETURNDATASIZE 1D3D 82 DUP3 1D3E 52 MSTORE 1D3F 3D RETURNDATASIZE 1D40 60 PUSH1 0x00 1D42 60 PUSH1 0x20 1D44 84 DUP5 1D45 01 ADD 1D46 3E RETURNDATACOPY 1D47 61 PUSH2 0x1d50 1D4A 56 *JUMP 1D4B 5B JUMPDEST 1D4C 60 PUSH1 0x60 1D4E 91 SWAP2 1D4F 50 POP 1D50 5B JUMPDEST 1D51 50 POP 1D52 80 DUP1 1D53 51 MLOAD 1D54 60 PUSH1 0x00 1D56 03 SUB 1D57 61 PUSH2 0x1d73 1D5A 57 *JUMPI 1D5B 60 PUSH1 0x40 1D5D 51 MLOAD 1D5E 63 PUSH4 0x68d2bf6b 1D63 60 PUSH1 0xe1 1D65 1B SHL 1D66 81 DUP2 1D67 52 MSTORE 1D68 60 PUSH1 0x04 1D6A 01 ADD 1D6B 60 PUSH1 0x40 1D6D 51 MLOAD 1D6E 80 DUP1 1D6F 91 SWAP2 1D70 03 SUB 1D71 90 SWAP1 1D72 FD *REVERT 1D73 5B JUMPDEST 1D74 80 DUP1 1D75 51 MLOAD 1D76 81 DUP2 1D77 60 PUSH1 0x20 1D79 01 ADD 1D7A FD *REVERT 1D7B 5B JUMPDEST 1D7C 60 PUSH1 0x01 1D7E 60 PUSH1 0x01 1D80 60 PUSH1 0xe0 1D82 1B SHL 1D83 03 SUB 1D84 19 NOT 1D85 16 AND 1D86 63 PUSH4 0x0a85bd01 1D8B 60 PUSH1 0xe1 1D8D 1B SHL 1D8E 14 EQ 1D8F 90 SWAP1 1D90 50 POP 1D91 94 SWAP5 1D92 93 SWAP4 1D93 50 POP 1D94 50 POP 1D95 50 POP 1D96 50 POP 1D97 56 *JUMP label_1D98: // Incoming call from 0x137A, returns to 0x0B05 // Inputs[3] // { // @1D9B storage[0x01] // @1D9E storage[0x00] // @1DAD stack[-1] // } 1D98 5B JUMPDEST 1D99 60 PUSH1 0x01 1D9B 54 SLOAD 1D9C 60 PUSH1 0x00 1D9E 54 SLOAD 1D9F 61 PUSH2 0x0bb8 1DA2 91 SWAP2 1DA3 90 SWAP1 1DA4 03 SUB 1DA5 60 PUSH1 0x00 1DA7 19 NOT 1DA8 01 ADD 1DA9 61 PUSH2 0x1db2 1DAC 90 SWAP1 1DAD 83 DUP4 1DAE 61 PUSH2 0x290f 1DB1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DA2 stack[0] = 0x0bb8 // @1DAC stack[1] = 0x1db2 // @1DAC stack[2] = ~0x00 + (storage[0x00] - storage[0x01]) // @1DAD stack[3] = stack[-1] // } // Block ends with call to 0x290f, returns to 0x1DB2 label_1DB2: // Incoming return from call to 0x290F at 0x1DB1 // Inputs[2] // { // @1DB3 stack[-1] // @1DB3 stack[-2] // } 1DB2 5B JUMPDEST 1DB3 11 GT 1DB4 15 ISZERO 1DB5 61 PUSH2 0x1dd1 1DB8 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1dd1, if !(stack[-1] > stack[-2]) label_1DB9: // Incoming jump from 0x1DB8, if not !(stack[-1] > stack[-2]) // Inputs[3] // { // @1DBB memory[0x40:0x60] // @1DCB memory[0x40:0x60] // @1DD0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1DB9 60 PUSH1 0x40 1DBB 51 MLOAD 1DBC 63 PUSH4 0x5d6f15a1 1DC1 60 PUSH1 0xe1 1DC3 1B SHL 1DC4 81 DUP2 1DC5 52 MSTORE 1DC6 60 PUSH1 0x04 1DC8 01 ADD 1DC9 60 PUSH1 0x40 1DCB 51 MLOAD 1DCC 80 DUP1 1DCD 91 SWAP2 1DCE 03 SUB 1DCF 90 SWAP1 1DD0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1DC5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5d6f15a1 << 0xe1 // @1DD0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1DD1: // Incoming jump from 0x1DB8, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @1DD5 stack[-2] // @1DD6 stack[-1] // } 1DD1 5B JUMPDEST 1DD2 61 PUSH2 0x0b05 1DD5 82 DUP3 1DD6 82 DUP3 1DD7 61 PUSH2 0x1fb7 1DDA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1DD2 stack[0] = 0x0b05 // @1DD5 stack[1] = stack[-2] // @1DD6 stack[2] = stack[-1] // } // Block ends with call to 0x1fb7, returns to 0x0B05 label_1DDB: // Incoming call from 0x164C, returns to 0x164D // Incoming call from 0x12AC, returns to 0x12AD // Inputs[1] { @1DDE stack[-1] } 1DDB 5B JUMPDEST 1DDC 60 PUSH1 0x00 1DDE 81 DUP2 1DDF 60 PUSH1 0x01 1DE1 11 GT 1DE2 15 ISZERO 1DE3 80 DUP1 1DE4 15 ISZERO 1DE5 61 PUSH2 0x1def 1DE8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DDC stack[0] = 0x00 // @1DE2 stack[1] = !(0x01 > stack[-1]) // } // Block ends with conditional jump to 0x1def, if !!(0x01 > stack[-1]) label_1DE9: // Incoming jump from 0x1DE8, if not !!(0x01 > stack[-1]) // Inputs[2] // { // @1DEC storage[0x00] // @1DED stack[-3] // } 1DE9 50 POP 1DEA 60 PUSH1 0x00 1DEC 54 SLOAD 1DED 82 DUP3 1DEE 10 LT 1DEF 5B JUMPDEST 1DF0 80 DUP1 1DF1 15 ISZERO 1DF2 61 PUSH2 0x09b4 1DF5 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1DEE stack[-1] = stack[-3] < storage[0x00] } // Block ends with conditional jump to 0x09b4, if !(stack[-3] < storage[0x00]) label_1DF6: // Incoming jump from 0x1DF5, if not !stack[-1] // Incoming jump from 0x1DF5, if not !(stack[-3] < storage[0x00]) // Inputs[4] // { // @1DFA stack[-3] // @1E05 memory[0x00:0x40] // @1E06 storage[keccak256(memory[0x00:0x40])] // @1E0E stack[-4] // } 1DF6 50 POP 1DF7 50 POP 1DF8 60 PUSH1 0x00 1DFA 90 SWAP1 1DFB 81 DUP2 1DFC 52 MSTORE 1DFD 60 PUSH1 0x04 1DFF 60 PUSH1 0x20 1E01 52 MSTORE 1E02 60 PUSH1 0x40 1E04 90 SWAP1 1E05 20 SHA3 1E06 54 SLOAD 1E07 60 PUSH1 0x01 1E09 60 PUSH1 0xe0 1E0B 1B SHL 1E0C 16 AND 1E0D 15 ISZERO 1E0E 90 SWAP1 1E0F 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1DFC memory[0x00:0x20] = stack[-3] // @1E01 memory[0x20:0x40] = 0x04 // @1E0E stack[-4] = !((0x01 << 0xe0) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-4] label_1E10: // Incoming call from 0x146D, returns to 0x0AD0 // Inputs[3] // { // @1E17 memory[0x00:0x20] // @1E20 memory[0x00:0x20] // @1E23 stack[-1] // } 1E10 5B JUMPDEST 1E11 61 PUSH2 0x1e28 1E14 60 PUSH1 0x00 1E16 80 DUP1 1E17 51 MLOAD 1E18 60 PUSH1 0x20 1E1A 61 PUSH2 0x29ee 1E1D 83 DUP4 1E1E 39 CODECOPY 1E1F 81 DUP2 1E20 51 MLOAD 1E21 91 SWAP2 1E22 52 MSTORE 1E23 82 DUP3 1E24 61 PUSH2 0x20c2 1E27 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1E11 stack[0] = 0x1e28 // @1E1E memory[0x00:0x20] = code[0x29ee:0x2a0e] // @1E21 stack[1] = memory[0x00:0x20] // @1E22 memory[0x00:0x20] = memory[0x00:0x20] // @1E23 stack[2] = stack[-1] // } // Block ends with call to 0x20c2, returns to 0x1E28 label_1E28: // Incoming return from call to 0x20C2 at 0x1E27 // Inputs[5] // { // @1E2C memory[0x40:0x60] // @1E35 stack[-2] // @1E38 msg.sender // @1E5F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1E61 stack[-3] // } 1E28 5B JUMPDEST 1E29 50 POP 1E2A 60 PUSH1 0x40 1E2C 51 MLOAD 1E2D 60 PUSH1 0x01 1E2F 60 PUSH1 0x01 1E31 60 PUSH1 0xa0 1E33 1B SHL 1E34 03 SUB 1E35 82 DUP3 1E36 16 AND 1E37 90 SWAP1 1E38 33 CALLER 1E39 90 SWAP1 1E3A 7F PUSH32 0xbd0af1fe0a2c1c7bb340c17a284a291138979c8eeb797e176dbd1c415199af3c 1E5B 90 SWAP1 1E5C 60 PUSH1 0x00 1E5E 90 SWAP1 1E5F A3 LOG3 1E60 50 POP 1E61 56 *JUMP // Stack delta = -3 // Outputs[1] { @1E5F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xbd0af1fe0a2c1c7bb340c17a284a291138979c8eeb797e176dbd1c415199af3c, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-3] label_1E62: // Incoming call from 0x147A, returns to 0x13C0 // Inputs[4] // { // @1E65 stack[-1] // @1E6A storage[0x00 + stack[-1]] // @1E74 memory[0x40:0x60] // @1E87 storage[0x00 + stack[-1]] // } 1E62 5B JUMPDEST 1E63 60 PUSH1 0x60 1E65 81 DUP2 1E66 60 PUSH1 0x00 1E68 01 ADD 1E69 80 DUP1 1E6A 54 SLOAD 1E6B 80 DUP1 1E6C 60 PUSH1 0x20 1E6E 02 MUL 1E6F 60 PUSH1 0x20 1E71 01 ADD 1E72 60 PUSH1 0x40 1E74 51 MLOAD 1E75 90 SWAP1 1E76 81 DUP2 1E77 01 ADD 1E78 60 PUSH1 0x40 1E7A 52 MSTORE 1E7B 80 DUP1 1E7C 92 SWAP3 1E7D 91 SWAP2 1E7E 90 SWAP1 1E7F 81 DUP2 1E80 81 DUP2 1E81 52 MSTORE 1E82 60 PUSH1 0x20 1E84 01 ADD 1E85 82 DUP3 1E86 80 DUP1 1E87 54 SLOAD 1E88 80 DUP1 1E89 15 ISZERO 1E8A 61 PUSH2 0x1eb2 1E8D 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @1E63 stack[0] = 0x60 // @1E7A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * storage[0x00 + stack[-1]] // @1E7C stack[1] = memory[0x40:0x60] // @1E7D stack[2] = 0x00 + stack[-1] // @1E7E stack[3] = storage[0x00 + stack[-1]] // @1E81 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x00 + stack[-1]] // @1E84 stack[4] = 0x20 + memory[0x40:0x60] // @1E85 stack[5] = 0x00 + stack[-1] // @1E87 stack[6] = storage[0x00 + stack[-1]] // } // Block ends with conditional jump to 0x1eb2, if !storage[0x00 + stack[-1]] label_1E8E: // Incoming jump from 0x1E8D, if not !storage[0x00 + stack[-1]] // Inputs[5] // { // @1E90 stack[-1] // @1E91 stack[-3] // @1E94 stack[-2] // @1E9C memory[0x00:0x20] // @1EA0 storage[keccak256(memory[0x00:0x20])] // } 1E8E 60 PUSH1 0x20 1E90 02 MUL 1E91 82 DUP3 1E92 01 ADD 1E93 91 SWAP2 1E94 90 SWAP1 1E95 60 PUSH1 0x00 1E97 52 MSTORE 1E98 60 PUSH1 0x20 1E9A 60 PUSH1 0x00 1E9C 20 SHA3 1E9D 90 SWAP1 1E9E 5B JUMPDEST 1E9F 81 DUP2 1EA0 54 SLOAD 1EA1 81 DUP2 1EA2 52 MSTORE 1EA3 60 PUSH1 0x20 1EA5 01 ADD 1EA6 90 SWAP1 1EA7 60 PUSH1 0x01 1EA9 01 ADD 1EAA 90 SWAP1 1EAB 80 DUP1 1EAC 83 DUP4 1EAD 11 GT 1EAE 61 PUSH2 0x1e9e 1EB1 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1E93 stack[-3] = stack[-3] + 0x20 * stack[-1] // @1E97 memory[0x00:0x20] = stack[-2] // @1EA2 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1EAA stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1EAA stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1e9e, if stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] label_1EB2: // Incoming jump from 0x1EB1, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1EB1, if not stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1E8D, if !storage[0x00 + stack[-1]] // Inputs[4] // { // @1EB8 stack[-7] // @1EB8 stack[-6] // @1EBA stack[-9] // @1EBB stack[-8] // } 1EB2 5B JUMPDEST 1EB3 50 POP 1EB4 50 POP 1EB5 50 POP 1EB6 50 POP 1EB7 50 POP 1EB8 90 SWAP1 1EB9 50 POP 1EBA 91 SWAP2 1EBB 90 SWAP1 1EBC 50 POP 1EBD 56 *JUMP // Stack delta = -8 // Outputs[1] { @1EBA stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_1EBE: // Incoming call from 0x16E2, returns to 0x16E3 // Inputs[1] { @1EC4 stack[-2] } 1EBE 5B JUMPDEST 1EBF 60 PUSH1 0x00 1EC1 61 PUSH2 0x13c0 1EC4 83 DUP4 1EC5 61 PUSH2 0x1175 1EC8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1EBF stack[0] = 0x00 // @1EC1 stack[1] = 0x13c0 // @1EC4 stack[2] = stack[-2] // } // Block ends with call to 0x1175, returns to 0x13C0 label_1EC9: // Incoming call from 0x1FE8, returns to 0x1FE9 // Incoming call from 0x18B2, returns to 0x18B3 // Inputs[4] // { // @1ECA stack[-4] // @1ECB stack[-3] // @1ECC stack[-2] // @1ECD stack[-1] // } 1EC9 5B JUMPDEST 1ECA 83 DUP4 1ECB 83 DUP4 1ECC 83 DUP4 1ECD 83 DUP4 1ECE 61 PUSH2 0x1ed9 1ED1 84 DUP5 1ED2 84 DUP5 1ED3 84 DUP5 1ED4 84 DUP5 1ED5 61 PUSH2 0x20d7 1ED8 56 *JUMP // Stack delta = +9 // Outputs[9] // { // @1ECA stack[0] = stack[-4] // @1ECB stack[1] = stack[-3] // @1ECC stack[2] = stack[-2] // @1ECD stack[3] = stack[-1] // @1ECE stack[4] = 0x1ed9 // @1ED1 stack[5] = stack[-4] // @1ED2 stack[6] = stack[-3] // @1ED3 stack[7] = stack[-2] // @1ED4 stack[8] = stack[-1] // } // Block ends with call to 0x20d7, returns to 0x1ED9 label_1ED9: // Incoming return from call to 0x20D7 at 0x1ED8 // Inputs[1] { @1EE2 stack[-9] } 1ED9 5B JUMPDEST 1EDA 50 POP 1EDB 50 POP 1EDC 50 POP 1EDD 50 POP 1EDE 50 POP 1EDF 50 POP 1EE0 50 POP 1EE1 50 POP 1EE2 56 *JUMP // Stack delta = -9 // Block ends with unconditional jump to stack[-9] label_1EE3: // Incoming call from 0x199F, returns to 0x0AD0 // Inputs[2] // { // @1EE7 stack[-2] // @1EE8 stack[-1] // } 1EE3 5B JUMPDEST 1EE4 61 PUSH2 0x1eed 1EE7 82 DUP3 1EE8 82 DUP3 1EE9 61 PUSH2 0x0fdc 1EEC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1EE4 stack[0] = 0x1eed // @1EE7 stack[1] = stack[-2] // @1EE8 stack[2] = stack[-1] // } // Block ends with call to 0x0fdc, returns to 0x1EED label_1EED: // Incoming return from call to 0x0FDC at 0x1EEC // Inputs[1] { @1EF1 stack[-1] } 1EED 5B JUMPDEST 1EEE 61 PUSH2 0x0b05 1EF1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b05, if stack[-1] label_1EF2: // Incoming jump from 0x1EF1, if not stack[-1] // Inputs[1] { @1EF5 stack[-1] } 1EF2 61 PUSH2 0x1efa 1EF5 81 DUP2 1EF6 61 PUSH2 0x20dc 1EF9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1EF2 stack[0] = 0x1efa // @1EF5 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x20dc 1EFA 5B JUMPDEST 1EFB 61 PUSH2 0x1f05 1EFE 83 DUP4 1EFF 60 PUSH1 0x20 1F01 61 PUSH2 0x20ee 1F04 56 *JUMP 1F05 5B JUMPDEST 1F06 60 PUSH1 0x40 1F08 51 MLOAD 1F09 60 PUSH1 0x20 1F0B 01 ADD 1F0C 61 PUSH2 0x1f16 1F0F 92 SWAP3 1F10 91 SWAP2 1F11 90 SWAP1 1F12 61 PUSH2 0x2922 1F15 56 *JUMP 1F16 5B JUMPDEST 1F17 60 PUSH1 0x40 1F19 80 DUP1 1F1A 51 MLOAD 1F1B 60 PUSH1 0x1f 1F1D 19 NOT 1F1E 81 DUP2 1F1F 84 DUP5 1F20 03 SUB 1F21 01 ADD 1F22 81 DUP2 1F23 52 MSTORE 1F24 90 SWAP1 1F25 82 DUP3 1F26 90 SWAP1 1F27 52 MSTORE 1F28 62 PUSH3 0x461bcd 1F2C 60 PUSH1 0xe5 1F2E 1B SHL 1F2F 82 DUP3 1F30 52 MSTORE 1F31 61 PUSH2 0x0ddc 1F34 91 SWAP2 1F35 60 PUSH1 0x04 1F37 01 ADD 1F38 61 PUSH2 0x2513 1F3B 56 *JUMP label_1F3C: // Incoming call from 0x1BBF, returns to 0x1BC0 // Inputs[2] // { // @1F42 stack[-2] // @1F4B stack[-1] // } 1F3C 5B JUMPDEST 1F3D 60 PUSH1 0x00 1F3F 61 PUSH2 0x13c0 1F42 83 DUP4 1F43 60 PUSH1 0x01 1F45 60 PUSH1 0x01 1F47 60 PUSH1 0xa0 1F49 1B SHL 1F4A 03 SUB 1F4B 84 DUP5 1F4C 16 AND 1F4D 61 PUSH2 0x228a 1F50 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F3D stack[0] = 0x00 // @1F3F stack[1] = 0x13c0 // @1F42 stack[2] = stack[-2] // @1F4C stack[3] = stack[-1] & (0x01 << 0xa0) - 0x01 // } // Block ends with call to 0x228a, returns to 0x13C0 1F51 5B JUMPDEST 1F52 61 PUSH2 0x1f5b 1F55 83 DUP4 1F56 83 DUP4 1F57 61 PUSH2 0x1d98 1F5A 56 *JUMP 1F5B 5B JUMPDEST 1F5C 60 PUSH1 0x01 1F5E 60 PUSH1 0x01 1F60 60 PUSH1 0xa0 1F62 1B SHL 1F63 03 SUB 1F64 83 DUP4 1F65 16 AND 1F66 3B EXTCODESIZE 1F67 15 ISZERO 1F68 61 PUSH2 0x0d6b 1F6B 57 *JUMPI 1F6C 60 PUSH1 0x00 1F6E 54 SLOAD 1F6F 82 DUP3 1F70 81 DUP2 1F71 03 SUB 1F72 5B JUMPDEST 1F73 61 PUSH2 0x1f85 1F76 60 PUSH1 0x00 1F78 86 DUP7 1F79 83 DUP4 1F7A 80 DUP1 1F7B 60 PUSH1 0x01 1F7D 01 ADD 1F7E 94 SWAP5 1F7F 50 POP 1F80 86 DUP7 1F81 61 PUSH2 0x1cad 1F84 56 *JUMP 1F85 5B JUMPDEST 1F86 61 PUSH2 0x1fa2 1F89 57 *JUMPI 1F8A 60 PUSH1 0x40 1F8C 51 MLOAD 1F8D 63 PUSH4 0x68d2bf6b 1F92 60 PUSH1 0xe1 1F94 1B SHL 1F95 81 DUP2 1F96 52 MSTORE 1F97 60 PUSH1 0x04 1F99 01 ADD 1F9A 60 PUSH1 0x40 1F9C 51 MLOAD 1F9D 80 DUP1 1F9E 91 SWAP2 1F9F 03 SUB 1FA0 90 SWAP1 1FA1 FD *REVERT 1FA2 5B JUMPDEST 1FA3 81 DUP2 1FA4 81 DUP2 1FA5 10 LT 1FA6 61 PUSH2 0x1f72 1FA9 57 *JUMPI 1FAA 81 DUP2 1FAB 60 PUSH1 0x00 1FAD 54 SLOAD 1FAE 14 EQ 1FAF 61 PUSH2 0x0c37 1FB2 57 *JUMPI 1FB3 60 PUSH1 0x00 1FB5 80 DUP1 1FB6 FD *REVERT label_1FB7: // Incoming call from 0x1DDA, returns to 0x0B05 // Inputs[2] // { // @1FBB storage[0x00] // @1FBD stack[-1] // } 1FB7 5B JUMPDEST 1FB8 60 PUSH1 0x00 1FBA 80 DUP1 1FBB 54 SLOAD 1FBC 90 SWAP1 1FBD 82 DUP3 1FBE 90 SWAP1 1FBF 03 SUB 1FC0 61 PUSH2 0x1fdc 1FC3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1FBC stack[0] = storage[0x00] } // Block ends with conditional jump to 0x1fdc, if 0x00 - stack[-1] label_1FC4: // Incoming jump from 0x1FC3, if not 0x00 - stack[-1] // Inputs[3] // { // @1FC6 memory[0x40:0x60] // @1FD6 memory[0x40:0x60] // @1FDB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1FC4 60 PUSH1 0x40 1FC6 51 MLOAD 1FC7 63 PUSH4 0xb562e8dd 1FCC 60 PUSH1 0xe0 1FCE 1B SHL 1FCF 81 DUP2 1FD0 52 MSTORE 1FD1 60 PUSH1 0x04 1FD3 01 ADD 1FD4 60 PUSH1 0x40 1FD6 51 MLOAD 1FD7 80 DUP1 1FD8 91 SWAP2 1FD9 03 SUB 1FDA 90 SWAP1 1FDB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1FD0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd << 0xe0 // @1FDB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1FDC: // Incoming jump from 0x1FC3, if 0x00 - stack[-1] // Inputs[3] // { // @1FE2 stack[-3] // @1FE3 stack[-1] // @1FE4 stack[-2] // } 1FDC 5B JUMPDEST 1FDD 61 PUSH2 0x1fe9 1FE0 60 PUSH1 0x00 1FE2 84 DUP5 1FE3 83 DUP4 1FE4 85 DUP6 1FE5 61 PUSH2 0x1ec9 1FE8 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1FDD stack[0] = 0x1fe9 // @1FE0 stack[1] = 0x00 // @1FE2 stack[2] = stack[-3] // @1FE3 stack[3] = stack[-1] // @1FE4 stack[4] = stack[-2] // } // Block ends with call to 0x1ec9, returns to 0x1FE9 label_1FE9: // Incoming return from call to 0x1EC9 at 0x1FE8 // Inputs[8] // { // @1FF2 stack[-3] // @2004 memory[0x00:0x40] // @2006 storage[keccak256(memory[0x00:0x40])] // @2011 stack[-2] // @2016 stack[-1] // @201F memory[0x00:0x40] // @2027 block.timestamp // @205B memory[0x00:0x00] // } 1FE9 5B JUMPDEST 1FEA 60 PUSH1 0x01 1FEC 60 PUSH1 0x01 1FEE 60 PUSH1 0xa0 1FF0 1B SHL 1FF1 03 SUB 1FF2 83 DUP4 1FF3 16 AND 1FF4 60 PUSH1 0x00 1FF6 81 DUP2 1FF7 81 DUP2 1FF8 52 MSTORE 1FF9 60 PUSH1 0x05 1FFB 60 PUSH1 0x20 1FFD 90 SWAP1 1FFE 81 DUP2 1FFF 52 MSTORE 2000 60 PUSH1 0x40 2002 80 DUP1 2003 83 DUP4 2004 20 SHA3 2005 80 DUP1 2006 54 SLOAD 2007 68 PUSH9 0x010000000000000001 2011 88 DUP9 2012 02 MUL 2013 01 ADD 2014 90 SWAP1 2015 55 SSTORE 2016 84 DUP5 2017 83 DUP4 2018 52 MSTORE 2019 60 PUSH1 0x04 201B 90 SWAP1 201C 91 SWAP2 201D 52 MSTORE 201E 81 DUP2 201F 20 SHA3 2020 60 PUSH1 0x01 2022 85 DUP6 2023 14 EQ 2024 60 PUSH1 0xe1 2026 1B SHL 2027 42 TIMESTAMP 2028 60 PUSH1 0xa0 202A 1B SHL 202B 17 OR 202C 83 DUP4 202D 17 OR 202E 90 SWAP1 202F 55 SSTORE 2030 82 DUP3 2031 84 DUP5 2032 01 ADD 2033 90 SWAP1 2034 83 DUP4 2035 90 SWAP1 2036 83 DUP4 2037 90 SWAP1 2038 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 2059 81 DUP2 205A 80 DUP1 205B A4 LOG4 205C 60 PUSH1 0x01 205E 83 DUP4 205F 01 ADD 2060 5B JUMPDEST 2061 81 DUP2 2062 81 DUP2 2063 14 EQ 2064 61 PUSH2 0x2098 2067 57 *JUMPI // Stack delta = +3 // Outputs[10] // { // @1FF3 stack[0] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1FF8 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1FFF memory[0x20:0x40] = 0x05 // @2015 storage[keccak256(memory[0x00:0x40])] = stack[-2] * 0x010000000000000001 + storage[keccak256(memory[0x00:0x40])] // @2018 memory[0x00:0x20] = stack[-1] // @201D memory[0x20:0x40] = 0x04 // @202F storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (block.timestamp << 0xa0) | ((stack[-2] == 0x01) << 0xe1) // @2033 stack[1] = stack[-2] + stack[-1] // @205B log(memory[0x00:0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-1]]); // @205F stack[2] = stack[-1] + 0x01 // } // Block ends with conditional jump to 0x2098, if stack[-1] + 0x01 == stack[-2] + stack[-1] label_2068: // Incoming jump from 0x2067, if not stack[-1] + 0x01 == stack[-2] + stack[-1] // Incoming jump from 0x2067, if not stack[-1] == stack[-2] // Inputs[3] // { // @2068 stack[-1] // @2069 stack[-3] // @2090 memory[0x00:0x00] // } 2068 80 DUP1 2069 83 DUP4 206A 60 PUSH1 0x00 206C 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 208D 60 PUSH1 0x00 208F 80 DUP1 2090 A4 LOG4 2091 60 PUSH1 0x01 2093 01 ADD 2094 61 PUSH2 0x2060 2097 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2090 log(memory[0x00:0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-3], stack[-1]]); // @2093 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2060 label_2098: // Incoming jump from 0x2067, if stack[-1] + 0x01 == stack[-2] + stack[-1] // Incoming jump from 0x2067, if stack[-1] == stack[-2] // Inputs[1] { @209A stack[-3] } 2098 5B JUMPDEST 2099 50 POP 209A 81 DUP2 209B 60 PUSH1 0x00 209D 03 SUB 209E 61 PUSH2 0x20b9 20A1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x20b9, if 0x00 - stack[-3] label_20A2: // Incoming jump from 0x20A1, if not 0x00 - stack[-3] // Inputs[3] // { // @20A4 memory[0x40:0x60] // @20B3 memory[0x40:0x60] // @20B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 20A2 60 PUSH1 0x40 20A4 51 MLOAD 20A5 62 PUSH3 0x2e0763 20A9 60 PUSH1 0xe8 20AB 1B SHL 20AC 81 DUP2 20AD 52 MSTORE 20AE 60 PUSH1 0x04 20B0 01 ADD 20B1 60 PUSH1 0x40 20B3 51 MLOAD 20B4 80 DUP1 20B5 91 SWAP2 20B6 03 SUB 20B7 90 SWAP1 20B8 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @20AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e0763 << 0xe8 // @20B8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_20B9: // Incoming jump from 0x20A1, if 0x00 - stack[-3] // Inputs[2] // { // @20BC stack[-1] // @20C1 stack[-6] // } 20B9 5B JUMPDEST 20BA 60 PUSH1 0x00 20BC 55 SSTORE 20BD 50 POP 20BE 50 POP 20BF 50 POP 20C0 50 POP 20C1 56 *JUMP // Stack delta = -6 // Outputs[1] { @20BC storage[0x00] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_20C2: // Incoming call from 0x1E27, returns to 0x1E28 // Inputs[2] // { // @20C8 stack[-2] // @20D1 stack[-1] // } 20C2 5B JUMPDEST 20C3 60 PUSH1 0x00 20C5 61 PUSH2 0x13c0 20C8 83 DUP4 20C9 60 PUSH1 0x01 20CB 60 PUSH1 0x01 20CD 60 PUSH1 0xa0 20CF 1B SHL 20D0 03 SUB 20D1 84 DUP5 20D2 16 AND 20D3 61 PUSH2 0x237d 20D6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @20C3 stack[0] = 0x00 // @20C5 stack[1] = 0x13c0 // @20C8 stack[2] = stack[-2] // @20D2 stack[3] = stack[-1] & (0x01 << 0xa0) - 0x01 // } // Block ends with call to 0x237d, returns to 0x13C0 label_20D7: // Incoming call from 0x1ED8, returns to 0x1ED9 20D7 5B JUMPDEST 20D8 61 PUSH2 0x0ce3 20DB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ce3 label_20DC: // Incoming jump from 0x1EF9 // Inputs[1] { @20EA stack[-1] } 20DC 5B JUMPDEST 20DD 60 PUSH1 0x60 20DF 61 PUSH2 0x09b4 20E2 60 PUSH1 0x01 20E4 60 PUSH1 0x01 20E6 60 PUSH1 0xa0 20E8 1B SHL 20E9 03 SUB 20EA 83 DUP4 20EB 16 AND 20EC 60 PUSH1 0x14 20EE 5B JUMPDEST 20EF 60 PUSH1 0x60 20F1 60 PUSH1 0x00 20F3 61 PUSH2 0x20fd 20F6 83 DUP4 20F7 60 PUSH1 0x02 20F9 61 PUSH2 0x27e8 20FC 56 *JUMP // Stack delta = +9 // Outputs[9] // { // @20DD stack[0] = 0x60 // @20DF stack[1] = 0x09b4 // @20EB stack[2] = stack[-1] & (0x01 << 0xa0) - 0x01 // @20EC stack[3] = 0x14 // @20EF stack[4] = 0x60 // @20F1 stack[5] = 0x00 // @20F3 stack[6] = 0x20fd // @20F6 stack[7] = 0x14 // @20F7 stack[8] = 0x02 // } // Block ends with call to 0x27e8, returns to 0x20FD label_20FD: // Incoming return from call to 0x27E8 at 0x20FC // Inputs[1] { @2101 stack[-1] } 20FD 5B JUMPDEST 20FE 61 PUSH2 0x2108 2101 90 SWAP1 2102 60 PUSH1 0x02 2104 61 PUSH2 0x290f 2107 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2101 stack[0] = stack[-1] // @2101 stack[-1] = 0x2108 // @2102 stack[1] = 0x02 // } // Block ends with call to 0x290f, returns to 0x2108 label_2108: // Incoming return from call to 0x290F at 0x2107 // Inputs[1] { @2112 stack[-1] } 2108 5B JUMPDEST 2109 67 PUSH8 0xffffffffffffffff 2112 81 DUP2 2113 11 GT 2114 15 ISZERO 2115 61 PUSH2 0x2120 2118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2120, if !(stack[-1] > 0xffffffffffffffff) label_2119: // Incoming jump from 0x2118, if not !(stack[-1] > 0xffffffffffffffff) 2119 61 PUSH2 0x2120 211C 61 PUSH2 0x264c 211F 56 *JUMP // Stack delta = +1 // Outputs[1] { @2119 stack[0] = 0x2120 } // Block ends with unconditional jump to 0x264c label_2120: // Incoming jump from 0x2118, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @2123 memory[0x40:0x60] // @2124 stack[-1] // } 2120 5B JUMPDEST 2121 60 PUSH1 0x40 2123 51 MLOAD 2124 90 SWAP1 2125 80 DUP1 2126 82 DUP3 2127 52 MSTORE 2128 80 DUP1 2129 60 PUSH1 0x1f 212B 01 ADD 212C 60 PUSH1 0x1f 212E 19 NOT 212F 16 AND 2130 60 PUSH1 0x20 2132 01 ADD 2133 82 DUP3 2134 01 ADD 2135 60 PUSH1 0x40 2137 52 MSTORE 2138 80 DUP1 2139 15 ISZERO 213A 61 PUSH2 0x214a 213D 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @2124 stack[-1] = memory[0x40:0x60] // @2124 stack[0] = stack[-1] // @2127 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @2137 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x214a, if !stack[-1] label_213E: // Incoming jump from 0x213D, if not !stack[-1] // Inputs[6] // { // @2140 stack[-2] // @2142 stack[-1] // @2144 msg.data.length // @2146 msg.data[msg.data.length:msg.data.length + stack[-1]] // @214C stack[-3] // @2157 memory[stack[-2]:stack[-2] + 0x20] // } 213E 60 PUSH1 0x20 2140 82 DUP3 2141 01 ADD 2142 81 DUP2 2143 80 DUP1 2144 36 CALLDATASIZE 2145 83 DUP4 2146 37 CALLDATACOPY 2147 01 ADD 2148 90 SWAP1 2149 50 POP 214A 5B JUMPDEST 214B 50 POP 214C 90 SWAP1 214D 50 POP 214E 60 PUSH1 0x03 2150 60 PUSH1 0xfc 2152 1B SHL 2153 81 DUP2 2154 60 PUSH1 0x00 2156 81 DUP2 2157 51 MLOAD 2158 81 DUP2 2159 10 LT 215A 61 PUSH2 0x2165 215D 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @2146 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @214C stack[-3] = stack[-2] // @2152 stack[-2] = 0x03 << 0xfc // @2153 stack[-1] = stack[-2] // @2154 stack[0] = 0x00 // } // Block ends with conditional jump to 0x2165, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_215E: // Incoming jump from 0x215D, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x215D, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 215E 61 PUSH2 0x2165 2161 61 PUSH2 0x2997 2164 56 *JUMP // Stack delta = +1 // Outputs[1] { @215E stack[0] = 0x2165 } // Block ends with unconditional jump to 0x2997 label_2165: // Incoming jump from 0x215D, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x215D, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @2168 stack[-1] // @2169 stack[-2] // @216A stack[-3] // @2182 stack[-4] // @2186 memory[stack[-4]:stack[-4] + 0x20] // } 2165 5B JUMPDEST 2166 60 PUSH1 0x20 2168 01 ADD 2169 01 ADD 216A 90 SWAP1 216B 60 PUSH1 0x01 216D 60 PUSH1 0x01 216F 60 PUSH1 0xf8 2171 1B SHL 2172 03 SUB 2173 19 NOT 2174 16 AND 2175 90 SWAP1 2176 81 DUP2 2177 60 PUSH1 0x00 2179 1A BYTE 217A 90 SWAP1 217B 53 MSTORE8 217C 50 POP 217D 60 PUSH1 0x0f 217F 60 PUSH1 0xfb 2181 1B SHL 2182 81 DUP2 2183 60 PUSH1 0x01 2185 81 DUP2 2186 51 MLOAD 2187 81 DUP2 2188 10 LT 2189 61 PUSH2 0x2194 218C 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @217B memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @2181 stack[-3] = 0x0f << 0xfb // @2182 stack[-2] = stack[-4] // @2183 stack[-1] = 0x01 // } // Block ends with conditional jump to 0x2194, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] label_218D: // Incoming jump from 0x218C, if not 0x01 < memory[stack[-4]:stack[-4] + 0x20] 218D 61 PUSH2 0x2194 2190 61 PUSH2 0x2997 2193 56 *JUMP // Stack delta = +1 // Outputs[1] { @218D stack[0] = 0x2194 } // Block ends with unconditional jump to 0x2997 label_2194: // Incoming jump from 0x218C, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @2197 stack[-1] // @2198 stack[-2] // @2199 stack[-3] // @21B1 stack[-6] // } 2194 5B JUMPDEST 2195 60 PUSH1 0x20 2197 01 ADD 2198 01 ADD 2199 90 SWAP1 219A 60 PUSH1 0x01 219C 60 PUSH1 0x01 219E 60 PUSH1 0xf8 21A0 1B SHL 21A1 03 SUB 21A2 19 NOT 21A3 16 AND 21A4 90 SWAP1 21A5 81 DUP2 21A6 60 PUSH1 0x00 21A8 1A BYTE 21A9 90 SWAP1 21AA 53 MSTORE8 21AB 50 POP 21AC 60 PUSH1 0x00 21AE 61 PUSH2 0x21b8 21B1 84 DUP5 21B2 60 PUSH1 0x02 21B4 61 PUSH2 0x27e8 21B7 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @21AA memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @21AC stack[-3] = 0x00 // @21AE stack[-2] = 0x21b8 // @21B1 stack[-1] = stack[-6] // @21B2 stack[0] = 0x02 // } // Block ends with call to 0x27e8, returns to 0x21B8 label_21B8: // Incoming return from call to 0x27E8 at 0x21B7 // Inputs[1] { @21BC stack[-1] } 21B8 5B JUMPDEST 21B9 61 PUSH2 0x21c3 21BC 90 SWAP1 21BD 60 PUSH1 0x01 21BF 61 PUSH2 0x290f 21C2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @21BC stack[0] = stack[-1] // @21BC stack[-1] = 0x21c3 // @21BD stack[1] = 0x01 // } // Block ends with call to 0x290f, returns to 0x21C3 label_21C3: // Incoming return from call to 0x290F at 0x21C2 // Inputs[2] // { // @21C4 stack[-2] // @21C4 stack[-1] // } 21C3 5B JUMPDEST 21C4 90 SWAP1 21C5 50 POP 21C6 5B JUMPDEST 21C7 60 PUSH1 0x01 21C9 81 DUP2 21CA 11 GT 21CB 15 ISZERO 21CC 61 PUSH2 0x223b 21CF 57 *JUMPI // Stack delta = -1 // Outputs[1] { @21C4 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x223b, if !(stack[-1] > 0x01) label_21D0: // Incoming jump from 0x21CF, if not !(stack[-1] > 0x01) // Incoming jump from 0x21CF, if not !(stack[-1] > 0x01) // Inputs[1] { @21E4 stack[-5] } 21D0 6F PUSH16 0x181899199a1a9b1b9c1cb0b131b232b3 21E1 60 PUSH1 0x81 21E3 1B SHL 21E4 85 DUP6 21E5 60 PUSH1 0x0f 21E7 16 AND 21E8 60 PUSH1 0x10 21EA 81 DUP2 21EB 10 LT 21EC 61 PUSH2 0x21f7 21EF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21E3 stack[0] = 0x181899199a1a9b1b9c1cb0b131b232b3 << 0x81 // @21E7 stack[1] = 0x0f & stack[-5] // } // Block ends with conditional jump to 0x21f7, if 0x0f & stack[-5] < 0x10 label_21F0: // Incoming jump from 0x21EF, if not 0x0f & stack[-5] < 0x10 21F0 61 PUSH2 0x21f7 21F3 61 PUSH2 0x2997 21F6 56 *JUMP // Stack delta = +1 // Outputs[1] { @21F0 stack[0] = 0x21f7 } // Block ends with unconditional jump to 0x2997 label_21F7: // Incoming jump from 0x21EF, if 0x0f & stack[-5] < 0x10 // Inputs[5] // { // @21F8 stack[-2] // @21F8 stack[-1] // @21FC stack[-4] // @21FD stack[-3] // @21FF memory[stack[-4]:stack[-4] + 0x20] // } 21F7 5B JUMPDEST 21F8 1A BYTE 21F9 60 PUSH1 0xf8 21FB 1B SHL 21FC 82 DUP3 21FD 82 DUP3 21FE 81 DUP2 21FF 51 MLOAD 2200 81 DUP2 2201 10 LT 2202 61 PUSH2 0x220d 2205 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @21FB stack[-2] = byte(stack[-2], stack[-1]) << 0xf8 // @21FC stack[-1] = stack[-4] // @21FD stack[0] = stack[-3] // } // Block ends with conditional jump to 0x220d, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_2206: // Incoming jump from 0x2205, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 2206 61 PUSH2 0x220d 2209 61 PUSH2 0x2997 220C 56 *JUMP // Stack delta = +1 // Outputs[1] { @2206 stack[0] = 0x220d } // Block ends with unconditional jump to 0x2997 label_220D: // Incoming jump from 0x2205, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[5] // { // @2210 stack[-1] // @2211 stack[-2] // @2212 stack[-3] // @2227 stack[-8] // @2228 stack[-4] // } 220D 5B JUMPDEST 220E 60 PUSH1 0x20 2210 01 ADD 2211 01 ADD 2212 90 SWAP1 2213 60 PUSH1 0x01 2215 60 PUSH1 0x01 2217 60 PUSH1 0xf8 2219 1B SHL 221A 03 SUB 221B 19 NOT 221C 16 AND 221D 90 SWAP1 221E 81 DUP2 221F 60 PUSH1 0x00 2221 1A BYTE 2222 90 SWAP1 2223 53 MSTORE8 2224 50 POP 2225 60 PUSH1 0x04 2227 94 SWAP5 2228 90 SWAP1 2229 94 SWAP5 222A 1C SHR 222B 93 SWAP4 222C 61 PUSH2 0x2234 222F 81 DUP2 2230 61 PUSH2 0x29ad 2233 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2223 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @222B stack[-4] = stack[-4] // @222B stack[-8] = stack[-8] >> 0x04 // @222C stack[-3] = 0x2234 // @222F stack[-2] = stack[-4] // } // Block ends with call to 0x29ad, returns to 0x2234 label_2234: // Incoming return from call to 0x29AD at 0x2233 // Inputs[2] // { // @2235 stack[-1] // @2235 stack[-2] // } 2234 5B JUMPDEST 2235 90 SWAP1 2236 50 POP 2237 61 PUSH2 0x21c6 223A 56 *JUMP // Stack delta = -1 // Outputs[1] { @2235 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x21c6 label_223B: // Incoming jump from 0x21CF, if !(stack[-1] > 0x01) // Incoming jump from 0x21CF, if !(stack[-1] > 0x01) // Inputs[1] { @223D stack[-5] } 223B 5B JUMPDEST 223C 50 POP 223D 83 DUP4 223E 15 ISZERO 223F 61 PUSH2 0x13c0 2242 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x13c0, if !stack[-5] label_2243: // Incoming jump from 0x2242, if not !stack[-5] // Inputs[1] { @2245 memory[0x40:0x60] } 2243 60 PUSH1 0x40 2245 51 MLOAD 2246 62 PUSH3 0x461bcd 224A 60 PUSH1 0xe5 224C 1B SHL 224D 81 DUP2 224E 52 MSTORE 224F 60 PUSH1 0x20 2251 60 PUSH1 0x04 2253 82 DUP3 2254 01 ADD 2255 81 DUP2 2256 90 SWAP1 2257 52 MSTORE 2258 60 PUSH1 0x24 225A 82 DUP3 225B 01 ADD 225C 52 MSTORE 225D 7F PUSH32 0x537472696e67733a20686578206c656e67746820696e73756666696369656e74 227E 60 PUSH1 0x44 2280 82 DUP3 2281 01 ADD 2282 52 MSTORE 2283 60 PUSH1 0x64 2285 01 ADD 2286 61 PUSH2 0x0ddc 2289 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @224E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2257 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @225C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @2282 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x537472696e67733a20686578206c656e67746820696e73756666696369656e74 // @2285 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0ddc label_228A: // Incoming call from 0x1F50, returns to 0x13C0 // Inputs[4] // { // @228D stack[-1] // @2292 stack[-2] // @229A memory[0x00:0x40] // @229B storage[keccak256(memory[0x00:0x40])] // } 228A 5B JUMPDEST 228B 60 PUSH1 0x00 228D 81 DUP2 228E 81 DUP2 228F 52 MSTORE 2290 60 PUSH1 0x01 2292 83 DUP4 2293 01 ADD 2294 60 PUSH1 0x20 2296 52 MSTORE 2297 60 PUSH1 0x40 2299 81 DUP2 229A 20 SHA3 229B 54 SLOAD 229C 80 DUP1 229D 15 ISZERO 229E 61 PUSH2 0x2373 22A1 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @228B stack[0] = 0x00 // @228F memory[0x00:0x20] = stack[-1] // @2296 memory[0x20:0x40] = stack[-2] + 0x01 // @229B stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x2373, if !storage[keccak256(memory[0x00:0x40])] label_22A2: // Incoming jump from 0x22A1, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @22A9 stack[-1] } 22A2 60 PUSH1 0x00 22A4 61 PUSH2 0x22ae 22A7 60 PUSH1 0x01 22A9 83 DUP4 22AA 61 PUSH2 0x29c4 22AD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @22A2 stack[0] = 0x00 // @22A4 stack[1] = 0x22ae // @22A7 stack[2] = 0x01 // @22A9 stack[3] = stack[-1] // } // Block ends with call to 0x29c4, returns to 0x22AE label_22AE: // Incoming return from call to 0x29C4 at 0x22AD // Inputs[4] // { // @22AF stack[-6] // @22B0 storage[stack[-6]] // @22B1 stack[-1] // @22B2 stack[-2] // } 22AE 5B JUMPDEST 22AF 85 DUP6 22B0 54 SLOAD 22B1 90 SWAP1 22B2 91 SWAP2 22B3 50 POP 22B4 60 PUSH1 0x00 22B6 90 SWAP1 22B7 61 PUSH2 0x22c2 22BA 90 SWAP1 22BB 60 PUSH1 0x01 22BD 90 SWAP1 22BE 61 PUSH2 0x29c4 22C1 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @22B2 stack[-2] = stack[-1] // @22B6 stack[-1] = 0x00 // @22BA stack[0] = 0x22c2 // @22BD stack[1] = 0x01 // @22BD stack[2] = storage[stack[-6]] // } // Block ends with call to 0x29c4, returns to 0x22C2 label_22C2: // Incoming return from call to 0x29C4 at 0x22C1 // Inputs[3] // { // @22C3 stack[-1] // @22C3 stack[-2] // @22C5 stack[-3] // } 22C2 5B JUMPDEST 22C3 90 SWAP1 22C4 50 POP 22C5 81 DUP2 22C6 81 DUP2 22C7 14 EQ 22C8 61 PUSH2 0x2327 22CB 57 *JUMPI // Stack delta = -1 // Outputs[1] { @22C3 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x2327, if stack[-1] == stack[-3] label_22CC: // Incoming jump from 0x22CB, if not stack[-1] == stack[-3] // Inputs[3] // { // @22CE stack[-6] // @22D2 stack[-1] // @22D4 storage[0x00 + stack[-6]] // } 22CC 60 PUSH1 0x00 22CE 86 DUP7 22CF 60 PUSH1 0x00 22D1 01 ADD 22D2 82 DUP3 22D3 81 DUP2 22D4 54 SLOAD 22D5 81 DUP2 22D6 10 LT 22D7 61 PUSH2 0x22e2 22DA 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @22CC stack[0] = 0x00 // @22D1 stack[1] = 0x00 + stack[-6] // @22D2 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x22e2, if stack[-1] < storage[0x00 + stack[-6]] label_22DB: // Incoming jump from 0x22DA, if not stack[-1] < storage[0x00 + stack[-6]] 22DB 61 PUSH2 0x22e2 22DE 61 PUSH2 0x2997 22E1 56 *JUMP // Stack delta = +1 // Outputs[1] { @22DB stack[0] = 0x22e2 } // Block ends with unconditional jump to 0x2997 label_22E2: // Incoming jump from 0x22DA, if stack[-1] < storage[0x00 + stack[-6]] // Inputs[8] // { // @22E3 stack[-2] // @22E3 stack[-1] // @22EB memory[0x00:0x20] // @22ED storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @22EE stack[-3] // @22F1 stack[-9] // @22F5 stack[-5] // @22F7 storage[0x00 + stack[-9]] // } 22E2 5B JUMPDEST 22E3 90 SWAP1 22E4 60 PUSH1 0x00 22E6 52 MSTORE 22E7 60 PUSH1 0x20 22E9 60 PUSH1 0x00 22EB 20 SHA3 22EC 01 ADD 22ED 54 SLOAD 22EE 90 SWAP1 22EF 50 POP 22F0 80 DUP1 22F1 87 DUP8 22F2 60 PUSH1 0x00 22F4 01 ADD 22F5 84 DUP5 22F6 81 DUP2 22F7 54 SLOAD 22F8 81 DUP2 22F9 10 LT 22FA 61 PUSH2 0x2305 22FD 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @22E6 memory[0x00:0x20] = stack[-2] // @22EE stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @22F0 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @22F4 stack[-1] = 0x00 + stack[-9] // @22F5 stack[0] = stack[-5] // } // Block ends with conditional jump to 0x2305, if stack[-5] < storage[0x00 + stack[-9]] label_22FE: // Incoming jump from 0x22FD, if not stack[-5] < storage[0x00 + stack[-9]] 22FE 61 PUSH2 0x2305 2301 61 PUSH2 0x2997 2304 56 *JUMP // Stack delta = +1 // Outputs[1] { @22FE stack[0] = 0x2305 } // Block ends with unconditional jump to 0x2997 label_2305: // Incoming jump from 0x22FD, if stack[-5] < storage[0x00 + stack[-9]] // Inputs[8] // { // @2308 stack[-2] // @230F memory[0x00:0x20] // @2311 stack[-1] // @2313 stack[-3] // @2317 stack[-4] // @231C stack[-10] // @2323 memory[0x00:0x40] // @2324 stack[-7] // } 2305 5B JUMPDEST 2306 60 PUSH1 0x00 2308 91 SWAP2 2309 82 DUP3 230A 52 MSTORE 230B 60 PUSH1 0x20 230D 80 DUP1 230E 83 DUP4 230F 20 SHA3 2310 90 SWAP1 2311 91 SWAP2 2312 01 ADD 2313 92 SWAP3 2314 90 SWAP1 2315 92 SWAP3 2316 55 SSTORE 2317 91 SWAP2 2318 82 DUP3 2319 52 MSTORE 231A 60 PUSH1 0x01 231C 88 DUP9 231D 01 ADD 231E 90 SWAP1 231F 52 MSTORE 2320 60 PUSH1 0x40 2322 90 SWAP1 2323 20 SHA3 2324 83 DUP4 2325 90 SWAP1 2326 55 SSTORE // Stack delta = -4 // Outputs[5] // { // @230A memory[0x00:0x20] = stack[-2] // @2316 storage[stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // @2319 memory[0x00:0x20] = stack[-4] // @231F memory[0x20:0x40] = stack[-10] + 0x01 // @2326 storage[keccak256(memory[0x00:0x40])] = stack[-7] // } // Block continues label_2327: // Incoming jump from 0x22CB, if stack[-1] == stack[-3] // Incoming jump from 0x2326 // Inputs[2] // { // @2328 stack[-6] // @2329 storage[stack[-6]] // } 2327 5B JUMPDEST 2328 85 DUP6 2329 54 SLOAD 232A 86 DUP7 232B 90 SWAP1 232C 80 DUP1 232D 61 PUSH2 0x2338 2330 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @232B stack[0] = stack[-6] // @232B stack[1] = storage[stack[-6]] // } // Block ends with conditional jump to 0x2338, if storage[stack[-6]] label_2331: // Incoming jump from 0x2330, if not storage[stack[-6]] 2331 61 PUSH2 0x2338 2334 61 PUSH2 0x29d7 2337 56 *JUMP // Stack delta = +1 // Outputs[1] { @2331 stack[0] = 0x2338 } // Block ends with unconditional jump to 0x29d7 label_2338: // Incoming jump from 0x2330, if storage[stack[-6]] // Inputs[7] // { // @233B stack[-1] // @233D stack[-2] // @2347 memory[0x00:0x20] // @234F stack[-8] // @2355 stack[-7] // @2363 memory[0x00:0x40] // @236A stack[-6] // } 2338 5B JUMPDEST 2339 60 PUSH1 0x01 233B 90 SWAP1 233C 03 SUB 233D 81 DUP2 233E 81 DUP2 233F 90 SWAP1 2340 60 PUSH1 0x00 2342 52 MSTORE 2343 60 PUSH1 0x20 2345 60 PUSH1 0x00 2347 20 SHA3 2348 01 ADD 2349 60 PUSH1 0x00 234B 90 SWAP1 234C 55 SSTORE 234D 90 SWAP1 234E 55 SSTORE 234F 85 DUP6 2350 60 PUSH1 0x01 2352 01 ADD 2353 60 PUSH1 0x00 2355 86 DUP7 2356 81 DUP2 2357 52 MSTORE 2358 60 PUSH1 0x20 235A 01 ADD 235B 90 SWAP1 235C 81 DUP2 235D 52 MSTORE 235E 60 PUSH1 0x20 2360 01 ADD 2361 60 PUSH1 0x00 2363 20 SHA3 2364 60 PUSH1 0x00 2366 90 SWAP1 2367 55 SSTORE 2368 60 PUSH1 0x01 236A 93 SWAP4 236B 50 POP 236C 50 POP 236D 50 POP 236E 50 POP 236F 61 PUSH2 0x09b4 2372 56 *JUMP // Stack delta = -5 // Outputs[7] // { // @2342 memory[0x00:0x20] = stack[-2] // @234C storage[keccak256(memory[0x00:0x20]) + (stack[-1] - 0x01)] = 0x00 // @234E storage[stack[-2]] = stack[-1] - 0x01 // @2357 memory[0x00:0x20] = stack[-7] // @235D memory[0x20:0x40] = 0x01 + stack[-8] // @2367 storage[keccak256(memory[0x00:0x40])] = 0x00 // @236A stack[-6] = 0x01 // } // Block ends with unconditional jump to 0x09b4 label_2373: // Incoming jump from 0x22A1, if !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @2376 stack[-2] } 2373 5B JUMPDEST 2374 60 PUSH1 0x00 2376 91 SWAP2 2377 50 POP 2378 50 POP 2379 61 PUSH2 0x09b4 237C 56 *JUMP // Stack delta = -1 // Outputs[1] { @2376 stack[-2] = 0x00 } // Block ends with unconditional jump to 0x09b4 label_237D: // Incoming call from 0x20D6, returns to 0x13C0 // Inputs[4] // { // @2380 stack[-1] // @2385 stack[-2] // @238D memory[0x00:0x40] // @238E storage[keccak256(memory[0x00:0x40])] // } 237D 5B JUMPDEST 237E 60 PUSH1 0x00 2380 81 DUP2 2381 81 DUP2 2382 52 MSTORE 2383 60 PUSH1 0x01 2385 83 DUP4 2386 01 ADD 2387 60 PUSH1 0x20 2389 52 MSTORE 238A 60 PUSH1 0x40 238C 81 DUP2 238D 20 SHA3 238E 54 SLOAD 238F 61 PUSH2 0x23c4 2392 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @237E stack[0] = 0x00 // @2382 memory[0x00:0x20] = stack[-1] // @2389 memory[0x20:0x40] = stack[-2] + 0x01 // } // Block ends with conditional jump to 0x23c4, if storage[keccak256(memory[0x00:0x40])] label_2393: // Incoming jump from 0x2392, if not storage[keccak256(memory[0x00:0x40])] // Inputs[6] // { // @2394 stack[-3] // @2395 storage[stack[-3]] // @23A6 memory[0x00:0x20] // @23AA stack[-2] // @23AE storage[stack[-3]] // @23BB memory[0x00:0x40] // } 2393 50 POP 2394 81 DUP2 2395 54 SLOAD 2396 60 PUSH1 0x01 2398 81 DUP2 2399 81 DUP2 239A 01 ADD 239B 84 DUP5 239C 55 SSTORE 239D 60 PUSH1 0x00 239F 84 DUP5 23A0 81 DUP2 23A1 52 MSTORE 23A2 60 PUSH1 0x20 23A4 80 DUP1 23A5 82 DUP3 23A6 20 SHA3 23A7 90 SWAP1 23A8 93 SWAP4 23A9 01 ADD 23AA 84 DUP5 23AB 90 SWAP1 23AC 55 SSTORE 23AD 84 DUP5 23AE 54 SLOAD 23AF 84 DUP5 23B0 82 DUP3 23B1 52 MSTORE 23B2 82 DUP3 23B3 86 DUP7 23B4 01 ADD 23B5 90 SWAP1 23B6 93 SWAP4 23B7 52 MSTORE 23B8 60 PUSH1 0x40 23BA 90 SWAP1 23BB 20 SHA3 23BC 91 SWAP2 23BD 90 SWAP1 23BE 91 SWAP2 23BF 55 SSTORE 23C0 61 PUSH2 0x09b4 23C3 56 *JUMP // Stack delta = +0 // Outputs[7] // { // @239C storage[stack[-3]] = 0x01 + storage[stack[-3]] // @23A1 memory[0x00:0x20] = stack[-3] // @23AC storage[storage[stack[-3]] + keccak256(memory[0x00:0x20])] = stack[-2] // @23B1 memory[0x00:0x20] = stack[-2] // @23B7 memory[0x20:0x40] = stack[-3] + 0x01 // @23BE stack[-1] = 0x01 // @23BF storage[keccak256(memory[0x00:0x40])] = storage[stack[-3]] // } // Block ends with unconditional jump to 0x09b4 label_23C4: // Incoming jump from 0x2392, if storage[keccak256(memory[0x00:0x40])] 23C4 5B JUMPDEST 23C5 50 POP 23C6 60 PUSH1 0x00 23C8 61 PUSH2 0x09b4 23CB 56 *JUMP // Stack delta = +0 // Outputs[1] { @23C6 stack[-1] = 0x00 } // Block ends with unconditional jump to 0x09b4 label_23CC: // Incoming call from 0x02EE, returns to 0x02EF // Inputs[3] // { // @23D0 stack[-1] // @23D2 stack[-2] // @23D3 memory[stack[-2]:stack[-2] + 0x20] // } 23CC 5B JUMPDEST 23CD 60 PUSH1 0x20 23CF 80 DUP1 23D0 82 DUP3 23D1 52 MSTORE 23D2 82 DUP3 23D3 51 MLOAD 23D4 82 DUP3 23D5 82 DUP3 23D6 01 ADD 23D7 81 DUP2 23D8 90 SWAP1 23D9 52 MSTORE 23DA 60 PUSH1 0x00 23DC 91 SWAP2 23DD 90 SWAP1 23DE 84 DUP5 23DF 82 DUP3 23E0 01 ADD 23E1 90 SWAP1 23E2 60 PUSH1 0x40 23E4 85 DUP6 23E5 01 ADD 23E6 90 SWAP1 23E7 84 DUP5 23E8 5B JUMPDEST 23E9 81 DUP2 23EA 81 DUP2 23EB 10 LT 23EC 15 ISZERO 23ED 61 PUSH2 0x240d 23F0 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @23D1 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @23D9 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @23DC stack[0] = 0x00 // @23DD stack[1] = 0x20 // @23E1 stack[2] = 0x20 + stack[-2] // @23E6 stack[3] = stack[-1] + 0x40 // @23E6 stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @23E7 stack[5] = 0x00 // } // Block ends with conditional jump to 0x240d, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_23F1: // Incoming jump from 0x23F0, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x23F0, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[5] // { // @23F1 stack[-4] // @23F2 memory[stack[-4]:stack[-4] + 0x20] // @23FC stack[-3] // @23FE stack[-1] // @23FF stack[-5] // } 23F1 83 DUP4 23F2 51 MLOAD 23F3 60 PUSH1 0x01 23F5 60 PUSH1 0x01 23F7 60 PUSH1 0xa0 23F9 1B SHL 23FA 03 SUB 23FB 16 AND 23FC 83 DUP4 23FD 52 MSTORE 23FE 92 SWAP3 23FF 84 DUP5 2400 01 ADD 2401 92 SWAP3 2402 91 SWAP2 2403 84 DUP5 2404 01 ADD 2405 91 SWAP2 2406 60 PUSH1 0x01 2408 01 ADD 2409 61 PUSH2 0x23e8 240C 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @23FD memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[stack[-4]:stack[-4] + 0x20] // @2401 stack[-4] = stack[-5] + stack[-4] // @2405 stack[-3] = stack[-5] + stack[-3] // @2408 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x23e8 label_240D: // Incoming jump from 0x23F0, if !(stack[-1] < stack[-2]) // Incoming jump from 0x23F0, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @240F stack[-3] // @240F stack[-2] // @2410 stack[-9] // @2411 stack[-8] // } 240D 5B JUMPDEST 240E 50 POP 240F 90 SWAP1 2410 96 SWAP7 2411 95 SWAP6 2412 50 POP 2413 50 POP 2414 50 POP 2415 50 POP 2416 50 POP 2417 50 POP 2418 56 *JUMP // Stack delta = -8 // Outputs[1] { @2410 stack[-9] = stack[-3] } // Block ends with unconditional jump to stack[-9] label_2419: // Incoming call from 0x244A, returns to 0x13C0 // Incoming call from 0x26EB, returns to 0x26EC // Incoming call from 0x2797, returns to 0x24B8 // Incoming call from 0x258A, returns to 0x258B // Incoming call from 0x2787, returns to 0x2788 // Incoming call from 0x263B, returns to 0x263C // Incoming call from 0x26DB, returns to 0x26DC // Incoming call from 0x249B, returns to 0x249C // Incoming call from 0x259A, returns to 0x259B // Incoming call from 0x255C, returns to 0x255D // Incoming call from 0x25F2, returns to 0x24B8 // Inputs[1] { @2422 stack[-1] } 2419 5B JUMPDEST 241A 60 PUSH1 0x01 241C 60 PUSH1 0x01 241E 60 PUSH1 0xa0 2420 1B SHL 2421 03 SUB 2422 81 DUP2 2423 16 AND 2424 81 DUP2 2425 14 EQ 2426 61 PUSH2 0x0ad0 2429 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ad0, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 label_242A: // Incoming jump from 0x2429, if not stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @242D memory[0x00:0x00] } 242A 60 PUSH1 0x00 242C 80 DUP1 242D FD *REVERT // Stack delta = +0 // Outputs[1] { @242D revert(memory[0x00:0x00]); } // Block terminates label_242E: // Incoming call from 0x06F8, returns to 0x06F9 // Incoming call from 0x0384, returns to 0x0385 // Incoming call from 0x0312, returns to 0x0313 // Incoming call from 0x093C, returns to 0x093D // Incoming call from 0x072D, returns to 0x072E // Incoming call from 0x0976, returns to 0x0977 // Incoming call from 0x0342, returns to 0x0343 // Incoming call from 0x0848, returns to 0x0849 // Inputs[2] // { // @2433 stack[-1] // @2434 stack[-2] // } 242E 5B JUMPDEST 242F 60 PUSH1 0x00 2431 60 PUSH1 0x20 2433 82 DUP3 2434 84 DUP5 2435 03 SUB 2436 12 SLT 2437 15 ISZERO 2438 61 PUSH2 0x2440 243B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @242F stack[0] = 0x00 } // Block ends with conditional jump to 0x2440, if !(stack[-2] - stack[-1] i< 0x20) label_243C: // Incoming jump from 0x243B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @243F memory[0x00:0x00] } 243C 60 PUSH1 0x00 243E 80 DUP1 243F FD *REVERT // Stack delta = +0 // Outputs[1] { @243F revert(memory[0x00:0x00]); } // Block terminates label_2440: // Incoming jump from 0x243B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2441 stack[-2] // @2442 msg.data[stack[-2]:stack[-2] + 0x20] // } 2440 5B JUMPDEST 2441 81 DUP2 2442 35 CALLDATALOAD 2443 61 PUSH2 0x13c0 2446 81 DUP2 2447 61 PUSH2 0x2419 244A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2442 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2443 stack[1] = 0x13c0 // @2446 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2419, returns to 0x13C0 label_244B: // Incoming call from 0x247D, returns to 0x13C0 // Inputs[1] { @2455 stack[-1] } 244B 5B JUMPDEST 244C 60 PUSH1 0x01 244E 60 PUSH1 0x01 2450 60 PUSH1 0xe0 2452 1B SHL 2453 03 SUB 2454 19 NOT 2455 81 DUP2 2456 16 AND 2457 81 DUP2 2458 14 EQ 2459 61 PUSH2 0x0ad0 245C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ad0, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_245D: // Incoming jump from 0x245C, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2460 memory[0x00:0x00] } 245D 60 PUSH1 0x00 245F 80 DUP1 2460 FD *REVERT // Stack delta = +0 // Outputs[1] { @2460 revert(memory[0x00:0x00]); } // Block terminates label_2461: // Incoming call from 0x0364, returns to 0x0365 // Inputs[2] // { // @2466 stack[-1] // @2467 stack[-2] // } 2461 5B JUMPDEST 2462 60 PUSH1 0x00 2464 60 PUSH1 0x20 2466 82 DUP3 2467 84 DUP5 2468 03 SUB 2469 12 SLT 246A 15 ISZERO 246B 61 PUSH2 0x2473 246E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2462 stack[0] = 0x00 } // Block ends with conditional jump to 0x2473, if !(stack[-2] - stack[-1] i< 0x20) label_246F: // Incoming jump from 0x246E, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2472 memory[0x00:0x00] } 246F 60 PUSH1 0x00 2471 80 DUP1 2472 FD *REVERT // Stack delta = +0 // Outputs[1] { @2472 revert(memory[0x00:0x00]); } // Block terminates label_2473: // Incoming jump from 0x246E, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2474 stack[-2] // @2475 msg.data[stack[-2]:stack[-2] + 0x20] // } 2473 5B JUMPDEST 2474 81 DUP2 2475 35 CALLDATALOAD 2476 61 PUSH2 0x13c0 2479 81 DUP2 247A 61 PUSH2 0x244b 247D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2475 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2476 stack[1] = 0x13c0 // @2479 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x244b, returns to 0x13C0 label_247E: // Incoming call from 0x03A4, returns to 0x03A5 // Inputs[2] // { // @2484 stack[-1] // @2485 stack[-2] // } 247E 5B JUMPDEST 247F 60 PUSH1 0x00 2481 80 DUP1 2482 60 PUSH1 0x40 2484 83 DUP4 2485 85 DUP6 2486 03 SUB 2487 12 SLT 2488 15 ISZERO 2489 61 PUSH2 0x2491 248C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @247F stack[0] = 0x00 // @2481 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2491, if !(stack[-2] - stack[-1] i< 0x40) label_248D: // Incoming jump from 0x248C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2490 memory[0x00:0x00] } 248D 60 PUSH1 0x00 248F 80 DUP1 2490 FD *REVERT // Stack delta = +0 // Outputs[1] { @2490 revert(memory[0x00:0x00]); } // Block terminates label_2491: // Incoming jump from 0x248C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2492 stack[-3] // @2493 msg.data[stack[-3]:stack[-3] + 0x20] // } 2491 5B JUMPDEST 2492 82 DUP3 2493 35 CALLDATALOAD 2494 61 PUSH2 0x249c 2497 81 DUP2 2498 61 PUSH2 0x2419 249B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2493 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @2494 stack[1] = 0x249c // @2497 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x2419, returns to 0x249C label_249C: // Incoming return from call to 0x2419 at 0x249B // Inputs[4] // { // @249D stack[-1] // @249D stack[-3] // @24A1 stack[-4] // @24A3 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 249C 5B JUMPDEST 249D 91 SWAP2 249E 50 POP 249F 60 PUSH1 0x20 24A1 83 DUP4 24A2 01 ADD 24A3 35 CALLDATALOAD 24A4 60 PUSH1 0x01 24A6 60 PUSH1 0x01 24A8 60 PUSH1 0x60 24AA 1B SHL 24AB 03 SUB 24AC 81 DUP2 24AD 16 AND 24AE 81 DUP2 24AF 14 EQ 24B0 61 PUSH2 0x24b8 24B3 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @249D stack[-3] = stack[-1] // @24A3 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x24b8, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] & (0x01 << 0x60) - 0x01 label_24B4: // Incoming jump from 0x24B3, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] & (0x01 << 0x60) - 0x01 // Inputs[1] { @24B7 memory[0x00:0x00] } 24B4 60 PUSH1 0x00 24B6 80 DUP1 24B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @24B7 revert(memory[0x00:0x00]); } // Block terminates label_24B8: // Incoming return from call to 0x2419 at 0x25F2 // Incoming return from call to 0x25F3 at 0x264B // Incoming return from call to 0x2419 at 0x2797 // Incoming jump from 0x24B3, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] & (0x01 << 0x60) - 0x01 // Inputs[6] // { // @24B9 stack[-1] // @24BA stack[-2] // @24BD stack[-5] // @24BF stack[-3] // @24BF stack[-6] // @24C0 stack[-4] // } 24B8 5B JUMPDEST 24B9 80 DUP1 24BA 91 SWAP2 24BB 50 POP 24BC 50 POP 24BD 92 SWAP3 24BE 50 POP 24BF 92 SWAP3 24C0 90 SWAP1 24C1 50 POP 24C2 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @24BD stack[-5] = stack[-1] // @24BF stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_24C3: // Incoming call from 0x24FE, returns to 0x24FF // Incoming call from 0x28AB, returns to 0x28AC // Inputs[1] { @24C7 stack[-3] } 24C3 5B JUMPDEST 24C4 60 PUSH1 0x00 24C6 5B JUMPDEST 24C7 83 DUP4 24C8 81 DUP2 24C9 10 LT 24CA 15 ISZERO 24CB 61 PUSH2 0x24de 24CE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24C4 stack[0] = 0x00 } // Block ends with conditional jump to 0x24de, if !(0x00 < stack[-3]) label_24CF: // Incoming jump from 0x24CE, if not !(0x00 < stack[-3]) // Incoming jump from 0x24CE, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @24CF stack[-2] // @24D0 stack[-1] // @24D2 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @24D3 stack[-3] // } 24CF 81 DUP2 24D0 81 DUP2 24D1 01 ADD 24D2 51 MLOAD 24D3 83 DUP4 24D4 82 DUP3 24D5 01 ADD 24D6 52 MSTORE 24D7 60 PUSH1 0x20 24D9 01 ADD 24DA 61 PUSH2 0x24c6 24DD 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @24D6 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @24D9 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x24c6 label_24DE: // Incoming jump from 0x24CE, if !(0x00 < stack[-3]) // Incoming jump from 0x24CE, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @24E3 stack[-4] // @24E4 stack[-3] // @24E6 stack[-5] // } 24DE 5B JUMPDEST 24DF 50 POP 24E0 50 POP 24E1 60 PUSH1 0x00 24E3 91 SWAP2 24E4 01 ADD 24E5 52 MSTORE 24E6 56 *JUMP // Stack delta = -5 // Outputs[1] { @24E5 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_24E7: // Incoming call from 0x2525, returns to 0x13C0 // Inputs[3] // { // @24EA stack[-1] // @24EB memory[stack[-1]:stack[-1] + 0x20] // @24ED stack[-2] // } 24E7 5B JUMPDEST 24E8 60 PUSH1 0x00 24EA 81 DUP2 24EB 51 MLOAD 24EC 80 DUP1 24ED 84 DUP5 24EE 52 MSTORE 24EF 61 PUSH2 0x24ff 24F2 81 DUP2 24F3 60 PUSH1 0x20 24F5 86 DUP7 24F6 01 ADD 24F7 60 PUSH1 0x20 24F9 86 DUP7 24FA 01 ADD 24FB 61 PUSH2 0x24c3 24FE 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @24E8 stack[0] = 0x00 // @24EB stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @24EE memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @24EF stack[2] = 0x24ff // @24F2 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @24F6 stack[4] = stack[-2] + 0x20 // @24FA stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x24c3, returns to 0x24FF label_24FF: // Incoming return from call to 0x24C3 at 0x24FE // Inputs[4] // { // @2502 stack[-1] // @2507 stack[-4] // @2508 stack[-2] // @250E stack[-5] // } 24FF 5B JUMPDEST 2500 60 PUSH1 0x1f 2502 01 ADD 2503 60 PUSH1 0x1f 2505 19 NOT 2506 16 AND 2507 92 SWAP3 2508 90 SWAP1 2509 92 SWAP3 250A 01 ADD 250B 60 PUSH1 0x20 250D 01 ADD 250E 92 SWAP3 250F 91 SWAP2 2510 50 POP 2511 50 POP 2512 56 *JUMP // Stack delta = -4 // Outputs[1] { @250E stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_2513: // Incoming call from 0x03CB, returns to 0x02EF // Inputs[2] // { // @2516 stack[-1] // @2521 stack[-2] // } 2513 5B JUMPDEST 2514 60 PUSH1 0x20 2516 81 DUP2 2517 52 MSTORE 2518 60 PUSH1 0x00 251A 61 PUSH2 0x13c0 251D 60 PUSH1 0x20 251F 83 DUP4 2520 01 ADD 2521 84 DUP5 2522 61 PUSH2 0x24e7 2525 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2517 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2518 stack[0] = 0x00 // @251A stack[1] = 0x13c0 // @2520 stack[2] = stack[-1] + 0x20 // @2521 stack[3] = stack[-2] // } // Block ends with call to 0x24e7, returns to 0x13C0 label_2526: // Incoming call from 0x0888, returns to 0x0889 // Incoming call from 0x03E6, returns to 0x03E7 // Incoming call from 0x0468, returns to 0x0469 // Incoming call from 0x04C2, returns to 0x04C3 // Incoming call from 0x0690, returns to 0x0691 // Incoming call from 0x07C0, returns to 0x07C1 // Inputs[2] // { // @252B stack[-1] // @252C stack[-2] // } 2526 5B JUMPDEST 2527 60 PUSH1 0x00 2529 60 PUSH1 0x20 252B 82 DUP3 252C 84 DUP5 252D 03 SUB 252E 12 SLT 252F 15 ISZERO 2530 61 PUSH2 0x2538 2533 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2527 stack[0] = 0x00 } // Block ends with conditional jump to 0x2538, if !(stack[-2] - stack[-1] i< 0x20) label_2534: // Incoming jump from 0x2533, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2537 memory[0x00:0x00] } 2534 60 PUSH1 0x00 2536 80 DUP1 2537 FD *REVERT // Stack delta = +0 // Outputs[1] { @2537 revert(memory[0x00:0x00]); } // Block terminates label_2538: // Incoming jump from 0x2533, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @253A msg.data[stack[-2]:stack[-2] + 0x20] // @253A stack[-2] // @253B stack[-4] // @253C stack[-3] // } 2538 5B JUMPDEST 2539 50 POP 253A 35 CALLDATALOAD 253B 91 SWAP2 253C 90 SWAP1 253D 50 POP 253E 56 *JUMP // Stack delta = -3 // Outputs[1] { @253B stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_253F: // Incoming call from 0x074D, returns to 0x074E // Incoming call from 0x08FC, returns to 0x08FD // Incoming call from 0x0868, returns to 0x0869 // Incoming call from 0x0411, returns to 0x0412 // Inputs[2] // { // @2545 stack[-1] // @2546 stack[-2] // } 253F 5B JUMPDEST 2540 60 PUSH1 0x00 2542 80 DUP1 2543 60 PUSH1 0x40 2545 83 DUP4 2546 85 DUP6 2547 03 SUB 2548 12 SLT 2549 15 ISZERO 254A 61 PUSH2 0x2552 254D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2540 stack[0] = 0x00 // @2542 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2552, if !(stack[-2] - stack[-1] i< 0x40) label_254E: // Incoming jump from 0x254D, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2551 memory[0x00:0x00] } 254E 60 PUSH1 0x00 2550 80 DUP1 2551 FD *REVERT // Stack delta = +0 // Outputs[1] { @2551 revert(memory[0x00:0x00]); } // Block terminates label_2552: // Incoming jump from 0x254D, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2553 stack[-3] // @2554 msg.data[stack[-3]:stack[-3] + 0x20] // } 2552 5B JUMPDEST 2553 82 DUP3 2554 35 CALLDATALOAD 2555 61 PUSH2 0x255d 2558 81 DUP2 2559 61 PUSH2 0x2419 255C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2554 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @2555 stack[1] = 0x255d // @2558 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x2419, returns to 0x255D label_255D: // Incoming return from call to 0x2419 at 0x255C // Inputs[5] // { // @255E stack[-6] // @255E stack[-1] // @2561 stack[-4] // @2565 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @2566 stack[-5] // } 255D 5B JUMPDEST 255E 94 SWAP5 255F 60 PUSH1 0x20 2561 93 SWAP4 2562 90 SWAP1 2563 93 SWAP4 2564 01 ADD 2565 35 CALLDATALOAD 2566 93 SWAP4 2567 50 POP 2568 50 POP 2569 50 POP 256A 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @255E stack[-6] = stack[-1] // @2566 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_256B: // Incoming call from 0x05FC, returns to 0x05FD // Incoming call from 0x04A2, returns to 0x04A3 // Inputs[2] // { // @2573 stack[-1] // @2574 stack[-2] // } 256B 5B JUMPDEST 256C 60 PUSH1 0x00 256E 80 DUP1 256F 60 PUSH1 0x00 2571 60 PUSH1 0x60 2573 84 DUP5 2574 86 DUP7 2575 03 SUB 2576 12 SLT 2577 15 ISZERO 2578 61 PUSH2 0x2580 257B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @256C stack[0] = 0x00 // @256E stack[1] = 0x00 // @256F stack[2] = 0x00 // } // Block ends with conditional jump to 0x2580, if !(stack[-2] - stack[-1] i< 0x60) label_257C: // Incoming jump from 0x257B, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @257F memory[0x00:0x00] } 257C 60 PUSH1 0x00 257E 80 DUP1 257F FD *REVERT // Stack delta = +0 // Outputs[1] { @257F revert(memory[0x00:0x00]); } // Block terminates label_2580: // Incoming jump from 0x257B, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @2581 stack[-4] // @2582 msg.data[stack[-4]:stack[-4] + 0x20] // } 2580 5B JUMPDEST 2581 83 DUP4 2582 35 CALLDATALOAD 2583 61 PUSH2 0x258b 2586 81 DUP2 2587 61 PUSH2 0x2419 258A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2582 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @2583 stack[1] = 0x258b // @2586 stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x2419, returns to 0x258B label_258B: // Incoming return from call to 0x2419 at 0x258A // Inputs[4] // { // @258C stack[-4] // @258C stack[-1] // @2590 stack[-5] // @2592 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 258B 5B JUMPDEST 258C 92 SWAP3 258D 50 POP 258E 60 PUSH1 0x20 2590 84 DUP5 2591 01 ADD 2592 35 CALLDATALOAD 2593 61 PUSH2 0x259b 2596 81 DUP2 2597 61 PUSH2 0x2419 259A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @258C stack[-4] = stack[-1] // @2592 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2593 stack[0] = 0x259b // @2596 stack[1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x2419, returns to 0x259B label_259B: // Incoming return from call to 0x2419 at 0x259A // Inputs[6] // { // @259C stack[-1] // @259C stack[-4] // @259D stack[-7] // @259F stack[-6] // @25A5 stack[-5] // @25A9 msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } 259B 5B JUMPDEST 259C 92 SWAP3 259D 95 SWAP6 259E 92 SWAP3 259F 94 SWAP5 25A0 50 POP 25A1 50 POP 25A2 50 POP 25A3 60 PUSH1 0x40 25A5 91 SWAP2 25A6 90 SWAP1 25A7 91 SWAP2 25A8 01 ADD 25A9 35 CALLDATALOAD 25AA 90 SWAP1 25AB 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @259D stack[-7] = stack[-4] // @259F stack[-6] = stack[-1] // @25AA stack[-5] = msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } // Block ends with unconditional jump to stack[-7] label_25AC: // Incoming call from 0x04F2, returns to 0x04F3 // Incoming call from 0x0670, returns to 0x0671 // Inputs[2] // { // @25B2 stack[-1] // @25B3 stack[-2] // } 25AC 5B JUMPDEST 25AD 60 PUSH1 0x00 25AF 80 DUP1 25B0 60 PUSH1 0x40 25B2 83 DUP4 25B3 85 DUP6 25B4 03 SUB 25B5 12 SLT 25B6 15 ISZERO 25B7 61 PUSH2 0x25bf 25BA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @25AD stack[0] = 0x00 // @25AF stack[1] = 0x00 // } // Block ends with conditional jump to 0x25bf, if !(stack[-2] - stack[-1] i< 0x40) label_25BB: // Incoming jump from 0x25BA, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @25BE memory[0x00:0x00] } 25BB 60 PUSH1 0x00 25BD 80 DUP1 25BE FD *REVERT // Stack delta = +0 // Outputs[1] { @25BE revert(memory[0x00:0x00]); } // Block terminates label_25BF: // Incoming jump from 0x25BA, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[5] // { // @25C2 stack[-3] // @25C3 msg.data[stack[-3]:stack[-3] + 0x20] // @25C4 stack[-5] // @25CA msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @25CB stack[-4] // } 25BF 5B JUMPDEST 25C0 50 POP 25C1 50 POP 25C2 80 DUP1 25C3 35 CALLDATALOAD 25C4 92 SWAP3 25C5 60 PUSH1 0x20 25C7 90 SWAP1 25C8 91 SWAP2 25C9 01 ADD 25CA 35 CALLDATALOAD 25CB 91 SWAP2 25CC 50 POP 25CD 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @25C4 stack[-5] = msg.data[stack[-3]:stack[-3] + 0x20] // @25CB stack[-4] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with unconditional jump to stack[-5] label_25CE: // Incoming call from 0x078B, returns to 0x078C // Incoming call from 0x05AC, returns to 0x05AD // Incoming call from 0x08A8, returns to 0x08A9 // Incoming call from 0x0531, returns to 0x0532 // Inputs[2] // { // @25D4 stack[-1] // @25D5 stack[-2] // } 25CE 5B JUMPDEST 25CF 60 PUSH1 0x00 25D1 80 DUP1 25D2 60 PUSH1 0x40 25D4 83 DUP4 25D5 85 DUP6 25D6 03 SUB 25D7 12 SLT 25D8 15 ISZERO 25D9 61 PUSH2 0x25e1 25DC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @25CF stack[0] = 0x00 // @25D1 stack[1] = 0x00 // } // Block ends with conditional jump to 0x25e1, if !(stack[-2] - stack[-1] i< 0x40) label_25DD: // Incoming jump from 0x25DC, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @25E0 memory[0x00:0x00] } 25DD 60 PUSH1 0x00 25DF 80 DUP1 25E0 FD *REVERT // Stack delta = +0 // Outputs[1] { @25E0 revert(memory[0x00:0x00]); } // Block terminates label_25E1: // Incoming jump from 0x25DC, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @25E2 stack[-3] // @25E3 msg.data[stack[-3]:stack[-3] + 0x20] // @25E4 stack[-2] // @25EA msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 25E1 5B JUMPDEST 25E2 82 DUP3 25E3 35 CALLDATALOAD 25E4 91 SWAP2 25E5 50 POP 25E6 60 PUSH1 0x20 25E8 83 DUP4 25E9 01 ADD 25EA 35 CALLDATALOAD 25EB 61 PUSH2 0x24b8 25EE 81 DUP2 25EF 61 PUSH2 0x2419 25F2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @25E4 stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @25EA stack[0] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @25EB stack[1] = 0x24b8 // @25EE stack[2] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with call to 0x2419, returns to 0x24B8 label_25F3: // Incoming call from 0x264B, returns to 0x24B8 // Incoming call from 0x261D, returns to 0x13C0 // Incoming call from 0x283D, returns to 0x13C0 // Inputs[1] { @25F4 stack[-1] } 25F3 5B JUMPDEST 25F4 80 DUP1 25F5 15 ISZERO 25F6 15 ISZERO 25F7 81 DUP2 25F8 14 EQ 25F9 61 PUSH2 0x0ad0 25FC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ad0, if stack[-1] == !!stack[-1] label_25FD: // Incoming jump from 0x25FC, if not stack[-1] == !!stack[-1] // Inputs[1] { @2600 memory[0x00:0x00] } 25FD 60 PUSH1 0x00 25FF 80 DUP1 2600 FD *REVERT // Stack delta = +0 // Outputs[1] { @2600 revert(memory[0x00:0x00]); } // Block terminates label_2601: // Incoming call from 0x0815, returns to 0x0816 // Incoming call from 0x06B0, returns to 0x06B1 // Incoming call from 0x0650, returns to 0x0651 // Inputs[2] // { // @2606 stack[-1] // @2607 stack[-2] // } 2601 5B JUMPDEST 2602 60 PUSH1 0x00 2604 60 PUSH1 0x20 2606 82 DUP3 2607 84 DUP5 2608 03 SUB 2609 12 SLT 260A 15 ISZERO 260B 61 PUSH2 0x2613 260E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2602 stack[0] = 0x00 } // Block ends with conditional jump to 0x2613, if !(stack[-2] - stack[-1] i< 0x20) label_260F: // Incoming jump from 0x260E, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2612 memory[0x00:0x00] } 260F 60 PUSH1 0x00 2611 80 DUP1 2612 FD *REVERT // Stack delta = +0 // Outputs[1] { @2612 revert(memory[0x00:0x00]); } // Block terminates label_2613: // Incoming jump from 0x260E, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2614 stack[-2] // @2615 msg.data[stack[-2]:stack[-2] + 0x20] // } 2613 5B JUMPDEST 2614 81 DUP2 2615 35 CALLDATALOAD 2616 61 PUSH2 0x13c0 2619 81 DUP2 261A 61 PUSH2 0x25f3 261D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2615 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2616 stack[1] = 0x13c0 // @2619 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x25f3, returns to 0x13C0 label_261E: // Incoming jump from 0x07F5 // Inputs[2] // { // @2624 stack[-1] // @2625 stack[-2] // } 261E 5B JUMPDEST 261F 60 PUSH1 0x00 2621 80 DUP1 2622 60 PUSH1 0x40 2624 83 DUP4 2625 85 DUP6 2626 03 SUB 2627 12 SLT 2628 15 ISZERO 2629 61 PUSH2 0x2631 262C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @261F stack[0] = 0x00 // @2621 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2631, if !(stack[-2] - stack[-1] i< 0x40) label_262D: // Incoming jump from 0x262C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2630 memory[0x00:0x00] } 262D 60 PUSH1 0x00 262F 80 DUP1 2630 FD *REVERT // Stack delta = +0 // Outputs[1] { @2630 revert(memory[0x00:0x00]); } // Block terminates label_2631: // Incoming jump from 0x262C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2632 stack[-3] // @2633 msg.data[stack[-3]:stack[-3] + 0x20] // } 2631 5B JUMPDEST 2632 82 DUP3 2633 35 CALLDATALOAD 2634 61 PUSH2 0x263c 2637 81 DUP2 2638 61 PUSH2 0x2419 263B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2633 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @2634 stack[1] = 0x263c // @2637 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x2419, returns to 0x263C label_263C: // Incoming return from call to 0x2419 at 0x263B // Inputs[4] // { // @263D stack[-1] // @263D stack[-3] // @2641 stack[-4] // @2643 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 263C 5B JUMPDEST 263D 91 SWAP2 263E 50 POP 263F 60 PUSH1 0x20 2641 83 DUP4 2642 01 ADD 2643 35 CALLDATALOAD 2644 61 PUSH2 0x24b8 2647 81 DUP2 2648 61 PUSH2 0x25f3 264B 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @263D stack[-3] = stack[-1] // @2643 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @2644 stack[0] = 0x24b8 // @2647 stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x25f3, returns to 0x24B8 label_264C: // Incoming jump from 0x268A // Incoming jump from 0x211F // Incoming jump from 0x26AC // Inputs[1] { @2661 memory[0x00:0x24] } 264C 5B JUMPDEST 264D 63 PUSH4 0x4e487b71 2652 60 PUSH1 0xe0 2654 1B SHL 2655 60 PUSH1 0x00 2657 52 MSTORE 2658 60 PUSH1 0x41 265A 60 PUSH1 0x04 265C 52 MSTORE 265D 60 PUSH1 0x24 265F 60 PUSH1 0x00 2661 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2657 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @265C memory[0x04:0x24] = 0x41 // @2661 revert(memory[0x00:0x24]); // } // Block terminates label_2662: // Incoming jump from 0x2732 // Inputs[2] // { // @2665 memory[0x40:0x60] // @2668 stack[-1] // } 2662 5B JUMPDEST 2663 60 PUSH1 0x40 2665 51 MLOAD 2666 60 PUSH1 0x1f 2668 82 DUP3 2669 01 ADD 266A 60 PUSH1 0x1f 266C 19 NOT 266D 16 AND 266E 81 DUP2 266F 01 ADD 2670 67 PUSH8 0xffffffffffffffff 2679 81 DUP2 267A 11 GT 267B 82 DUP3 267C 82 DUP3 267D 10 LT 267E 17 OR 267F 15 ISZERO 2680 61 PUSH2 0x268b 2683 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2665 stack[0] = memory[0x40:0x60] // @266F stack[1] = memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) // } // Block ends with conditional jump to 0x268b, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) label_2684: // Incoming jump from 0x2683, if not !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) 2684 61 PUSH2 0x268b 2687 61 PUSH2 0x264c 268A 56 *JUMP // Stack delta = +1 // Outputs[1] { @2684 stack[0] = 0x268b } // Block ends with unconditional jump to 0x264c label_268B: // Incoming jump from 0x2683, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) // Inputs[4] // { // @268E stack[-1] // @268F stack[-4] // @268F stack[-2] // @2690 stack[-3] // } 268B 5B JUMPDEST 268C 60 PUSH1 0x40 268E 52 MSTORE 268F 91 SWAP2 2690 90 SWAP1 2691 50 POP 2692 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @268E memory[0x40:0x60] = stack[-1] // @268F stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_2693: // Incoming call from 0x272D, returns to 0x272E // Incoming call from 0x2885, returns to 0x272E // Inputs[1] { @269F stack[-1] } 2693 5B JUMPDEST 2694 60 PUSH1 0x00 2696 67 PUSH8 0xffffffffffffffff 269F 82 DUP3 26A0 11 GT 26A1 15 ISZERO 26A2 61 PUSH2 0x26ad 26A5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2694 stack[0] = 0x00 } // Block ends with conditional jump to 0x26ad, if !(stack[-1] > 0xffffffffffffffff) label_26A6: // Incoming jump from 0x26A5, if not !(stack[-1] > 0xffffffffffffffff) 26A6 61 PUSH2 0x26ad 26A9 61 PUSH2 0x264c 26AC 56 *JUMP // Stack delta = +1 // Outputs[1] { @26A6 stack[0] = 0x26ad } // Block ends with unconditional jump to 0x264c label_26AD: // Incoming jump from 0x26A5, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @26B1 stack[-2] // @26B9 stack[-3] // } 26AD 5B JUMPDEST 26AE 50 POP 26AF 60 PUSH1 0x1f 26B1 01 ADD 26B2 60 PUSH1 0x1f 26B4 19 NOT 26B5 16 AND 26B6 60 PUSH1 0x20 26B8 01 ADD 26B9 90 SWAP1 26BA 56 *JUMP // Stack delta = -2 // Outputs[1] { @26B9 stack[-3] = 0x20 + (~0x1f & 0x1f + stack[-2]) } // Block ends with unconditional jump to stack[-3] label_26BB: // Incoming call from 0x0828, returns to 0x0829 // Inputs[2] // { // @26C4 stack[-1] // @26C5 stack[-2] // } 26BB 5B JUMPDEST 26BC 60 PUSH1 0x00 26BE 80 DUP1 26BF 60 PUSH1 0x00 26C1 80 DUP1 26C2 60 PUSH1 0x80 26C4 85 DUP6 26C5 87 DUP8 26C6 03 SUB 26C7 12 SLT 26C8 15 ISZERO 26C9 61 PUSH2 0x26d1 26CC 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @26BC stack[0] = 0x00 // @26BE stack[1] = 0x00 // @26BF stack[2] = 0x00 // @26C1 stack[3] = 0x00 // } // Block ends with conditional jump to 0x26d1, if !(stack[-2] - stack[-1] i< 0x80) label_26CD: // Incoming jump from 0x26CC, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @26D0 memory[0x00:0x00] } 26CD 60 PUSH1 0x00 26CF 80 DUP1 26D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @26D0 revert(memory[0x00:0x00]); } // Block terminates label_26D1: // Incoming jump from 0x26CC, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @26D2 stack[-5] // @26D3 msg.data[stack[-5]:stack[-5] + 0x20] // } 26D1 5B JUMPDEST 26D2 84 DUP5 26D3 35 CALLDATALOAD 26D4 61 PUSH2 0x26dc 26D7 81 DUP2 26D8 61 PUSH2 0x2419 26DB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @26D3 stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @26D4 stack[1] = 0x26dc // @26D7 stack[2] = msg.data[stack[-5]:stack[-5] + 0x20] // } // Block ends with call to 0x2419, returns to 0x26DC label_26DC: // Incoming return from call to 0x2419 at 0x26DB // Inputs[4] // { // @26DD stack[-5] // @26DD stack[-1] // @26E1 stack[-6] // @26E3 msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } 26DC 5B JUMPDEST 26DD 93 SWAP4 26DE 50 POP 26DF 60 PUSH1 0x20 26E1 85 DUP6 26E2 01 ADD 26E3 35 CALLDATALOAD 26E4 61 PUSH2 0x26ec 26E7 81 DUP2 26E8 61 PUSH2 0x2419 26EB 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @26DD stack[-5] = stack[-1] // @26E3 stack[-1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @26E4 stack[0] = 0x26ec // @26E7 stack[1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with call to 0x2419, returns to 0x26EC label_26EC: // Incoming return from call to 0x2419 at 0x26EB // Inputs[6] // { // @26ED stack[-1] // @26ED stack[-4] // @26F1 stack[-6] // @26F3 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @26F4 stack[-3] // @26FA msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 26EC 5B JUMPDEST 26ED 92 SWAP3 26EE 50 POP 26EF 60 PUSH1 0x40 26F1 85 DUP6 26F2 01 ADD 26F3 35 CALLDATALOAD 26F4 91 SWAP2 26F5 50 POP 26F6 60 PUSH1 0x60 26F8 85 DUP6 26F9 01 ADD 26FA 35 CALLDATALOAD 26FB 67 PUSH8 0xffffffffffffffff 2704 81 DUP2 2705 11 GT 2706 15 ISZERO 2707 61 PUSH2 0x270f 270A 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @26ED stack[-4] = stack[-1] // @26F4 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @26FA stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x270f, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_270B: // Incoming jump from 0x270A, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @270E memory[0x00:0x00] } 270B 60 PUSH1 0x00 270D 80 DUP1 270E FD *REVERT // Stack delta = +0 // Outputs[1] { @270E revert(memory[0x00:0x00]); } // Block terminates label_270F: // Incoming jump from 0x270A, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2710 stack[-6] // @2711 stack[-1] // @2716 stack[-7] // } 270F 5B JUMPDEST 2710 85 DUP6 2711 01 ADD 2712 60 PUSH1 0x1f 2714 81 DUP2 2715 01 ADD 2716 87 DUP8 2717 13 SGT 2718 61 PUSH2 0x2720 271B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2711 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x2720, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_271C: // Incoming jump from 0x271B, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @271F memory[0x00:0x00] } 271C 60 PUSH1 0x00 271E 80 DUP1 271F FD *REVERT // Stack delta = +0 // Outputs[1] { @271F revert(memory[0x00:0x00]); } // Block terminates label_2720: // Incoming jump from 0x271B, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[2] // { // @2721 stack[-1] // @2722 msg.data[stack[-1]:stack[-1] + 0x20] // } 2720 5B JUMPDEST 2721 80 DUP1 2722 35 CALLDATALOAD 2723 61 PUSH2 0x2733 2726 61 PUSH2 0x272e 2729 82 DUP3 272A 61 PUSH2 0x2693 272D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2722 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @2723 stack[1] = 0x2733 // @2726 stack[2] = 0x272e // @2729 stack[3] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2693, returns to 0x272E label_272E: // Incoming return from call to 0x2693 at 0x272D // Incoming return from call to 0x2693 at 0x2885 272E 5B JUMPDEST 272F 61 PUSH2 0x2662 2732 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2662 label_2733: // Incoming return from call to 0x272E at 0x272D // Inputs[4] // { // @2734 stack[-2] // @2735 stack[-1] // @2737 stack[-9] // @273B stack[-3] // } 2733 5B JUMPDEST 2734 81 DUP2 2735 81 DUP2 2736 52 MSTORE 2737 88 DUP9 2738 60 PUSH1 0x20 273A 83 DUP4 273B 85 DUP6 273C 01 ADD 273D 01 ADD 273E 11 GT 273F 15 ISZERO 2740 61 PUSH2 0x2748 2743 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2736 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] } // Block ends with conditional jump to 0x2748, if !(stack[-3] + stack[-2] + 0x20 > stack[-9]) label_2744: // Incoming jump from 0x2743, if not !(stack[-3] + stack[-2] + 0x20 > stack[-9]) // Inputs[1] { @2747 memory[0x00:0x00] } 2744 60 PUSH1 0x00 2746 80 DUP1 2747 FD *REVERT // Stack delta = +0 // Outputs[1] { @2747 revert(memory[0x00:0x00]); } // Block terminates label_2748: // Incoming jump from 0x2743, if !(stack[-3] + stack[-2] + 0x20 > stack[-9]) // Inputs[11] // { // @2749 stack[-2] // @274C stack[-3] // @2750 stack[-1] // @2752 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + stack[-2]] // @275D stack[-4] // @2762 stack[-7] // @2763 stack[-10] // @2764 stack[-6] // @2765 stack[-9] // @2767 stack[-8] // @2767 stack[-5] // } 2748 5B JUMPDEST 2749 81 DUP2 274A 60 PUSH1 0x20 274C 84 DUP5 274D 01 ADD 274E 60 PUSH1 0x20 2750 83 DUP4 2751 01 ADD 2752 37 CALLDATACOPY 2753 60 PUSH1 0x00 2755 60 PUSH1 0x20 2757 83 DUP4 2758 83 DUP4 2759 01 ADD 275A 01 ADD 275B 52 MSTORE 275C 80 DUP1 275D 93 SWAP4 275E 50 POP 275F 50 POP 2760 50 POP 2761 50 POP 2762 92 SWAP3 2763 95 SWAP6 2764 91 SWAP2 2765 94 SWAP5 2766 50 POP 2767 92 SWAP3 2768 50 POP 2769 56 *JUMP // Stack delta = -6 // Outputs[6] // { // @2752 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-2]] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + stack[-2]] // @275B memory[stack[-1] + stack[-2] + 0x20:stack[-1] + stack[-2] + 0x20 + 0x20] = 0x00 // @2762 stack[-7] = stack[-1] // @2763 stack[-10] = stack[-7] // @2765 stack[-9] = stack[-6] // @2767 stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-10] label_276A: // Incoming jump from 0x091C // Inputs[2] // { // @2770 stack[-1] // @2771 stack[-2] // } 276A 5B JUMPDEST 276B 60 PUSH1 0x00 276D 80 DUP1 276E 60 PUSH1 0x40 2770 83 DUP4 2771 85 DUP6 2772 03 SUB 2773 12 SLT 2774 15 ISZERO 2775 61 PUSH2 0x277d 2778 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @276B stack[0] = 0x00 // @276D stack[1] = 0x00 // } // Block ends with conditional jump to 0x277d, if !(stack[-2] - stack[-1] i< 0x40) label_2779: // Incoming jump from 0x2778, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @277C memory[0x00:0x00] } 2779 60 PUSH1 0x00 277B 80 DUP1 277C FD *REVERT // Stack delta = +0 // Outputs[1] { @277C revert(memory[0x00:0x00]); } // Block terminates label_277D: // Incoming jump from 0x2778, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @277E stack[-3] // @277F msg.data[stack[-3]:stack[-3] + 0x20] // } 277D 5B JUMPDEST 277E 82 DUP3 277F 35 CALLDATALOAD 2780 61 PUSH2 0x2788 2783 81 DUP2 2784 61 PUSH2 0x2419 2787 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @277F stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @2780 stack[1] = 0x2788 // @2783 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x2419, returns to 0x2788 label_2788: // Incoming return from call to 0x2419 at 0x2787 // Inputs[4] // { // @2789 stack[-3] // @2789 stack[-1] // @278D stack[-4] // @278F msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 2788 5B JUMPDEST 2789 91 SWAP2 278A 50 POP 278B 60 PUSH1 0x20 278D 83 DUP4 278E 01 ADD 278F 35 CALLDATALOAD 2790 61 PUSH2 0x24b8 2793 81 DUP2 2794 61 PUSH2 0x2419 2797 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2789 stack[-3] = stack[-1] // @278F stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @2790 stack[0] = 0x24b8 // @2793 stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x2419, returns to 0x24B8 label_2798: // Incoming call from 0x0B17, returns to 0x0B18 // Incoming call from 0x1015, returns to 0x0B18 // Incoming call from 0x0B43, returns to 0x0B44 // Inputs[1] { @279B stack[-1] } 2798 5B JUMPDEST 2799 60 PUSH1 0x01 279B 81 DUP2 279C 81 DUP2 279D 1C SHR 279E 90 SWAP1 279F 82 DUP3 27A0 16 AND 27A1 80 DUP1 27A2 61 PUSH2 0x27ac 27A5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @279E stack[0] = stack[-1] >> 0x01 // @27A0 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x27ac, if stack[-1] & 0x01 label_27A6: // Incoming jump from 0x27A5, if not stack[-1] & 0x01 // Inputs[2] // { // @27A8 stack[-2] // @27B1 stack[-1] // } 27A6 60 PUSH1 0x7f 27A8 82 DUP3 27A9 16 AND 27AA 91 SWAP2 27AB 50 POP 27AC 5B JUMPDEST 27AD 60 PUSH1 0x20 27AF 82 DUP3 27B0 10 LT 27B1 81 DUP2 27B2 03 SUB 27B3 61 PUSH2 0x27cc 27B6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @27AA stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x27cc, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_27B7: // Incoming jump from 0x27B6, if not stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x27B6, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[1] { @27CB memory[0x00:0x24] } 27B7 63 PUSH4 0x4e487b71 27BC 60 PUSH1 0xe0 27BE 1B SHL 27BF 60 PUSH1 0x00 27C1 52 MSTORE 27C2 60 PUSH1 0x22 27C4 60 PUSH1 0x04 27C6 52 MSTORE 27C7 60 PUSH1 0x24 27C9 60 PUSH1 0x00 27CB FD *REVERT // Stack delta = +0 // Outputs[3] // { // @27C1 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @27C6 memory[0x04:0x24] = 0x22 // @27CB revert(memory[0x00:0x24]); // } // Block terminates label_27CC: // Incoming jump from 0x27B6, if stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x27B6, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[3] // { // @27CE stack[-4] // @27CE stack[-2] // @27CF stack[-3] // } 27CC 5B JUMPDEST 27CD 50 POP 27CE 91 SWAP2 27CF 90 SWAP1 27D0 50 POP 27D1 56 *JUMP // Stack delta = -3 // Outputs[1] { @27CE stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_27D2: // Incoming jump from 0x27FE // Incoming jump from 0x29BB // Incoming jump from 0x2921 // Incoming jump from 0x29D6 // Inputs[1] { @27E7 memory[0x00:0x24] } 27D2 5B JUMPDEST 27D3 63 PUSH4 0x4e487b71 27D8 60 PUSH1 0xe0 27DA 1B SHL 27DB 60 PUSH1 0x00 27DD 52 MSTORE 27DE 60 PUSH1 0x11 27E0 60 PUSH1 0x04 27E2 52 MSTORE 27E3 60 PUSH1 0x24 27E5 60 PUSH1 0x00 27E7 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @27DD memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @27E2 memory[0x04:0x24] = 0x11 // @27E7 revert(memory[0x00:0x24]); // } // Block terminates label_27E8: // Incoming call from 0x20FC, returns to 0x20FD // Incoming call from 0x21B7, returns to 0x21B8 // Incoming call from 0x0D2D, returns to 0x0D2E // Inputs[2] // { // @27E9 stack[-1] // @27EA stack[-2] // } 27E8 5B JUMPDEST 27E9 80 DUP1 27EA 82 DUP3 27EB 02 MUL 27EC 81 DUP2 27ED 15 ISZERO 27EE 82 DUP3 27EF 82 DUP3 27F0 04 DIV 27F1 84 DUP5 27F2 14 EQ 27F3 17 OR 27F4 61 PUSH2 0x09b4 27F7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @27EB stack[0] = stack[-2] * stack[-1] } // Block ends with conditional jump to 0x09b4, if (stack[-2] == (stack[-2] * stack[-1]) / stack[-1]) | !stack[-1] label_27F8: // Incoming jump from 0x27F7, if not (stack[-2] == (stack[-2] * stack[-1]) / stack[-1]) | !stack[-1] 27F8 61 PUSH2 0x09b4 27FB 61 PUSH2 0x27d2 27FE 56 *JUMP // Stack delta = +1 // Outputs[1] { @27F8 stack[0] = 0x09b4 } // Block ends with unconditional jump to 0x27d2 label_27FF: // Incoming call from 0x0D37, returns to 0x0D38 // Inputs[1] { @2802 stack[-2] } 27FF 5B JUMPDEST 2800 60 PUSH1 0x00 2802 82 DUP3 2803 61 PUSH2 0x281c 2806 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2800 stack[0] = 0x00 } // Block ends with conditional jump to 0x281c, if stack[-2] label_2807: // Incoming jump from 0x2806, if not stack[-2] // Inputs[1] { @281B memory[0x00:0x24] } 2807 63 PUSH4 0x4e487b71 280C 60 PUSH1 0xe0 280E 1B SHL 280F 60 PUSH1 0x00 2811 52 MSTORE 2812 60 PUSH1 0x12 2814 60 PUSH1 0x04 2816 52 MSTORE 2817 60 PUSH1 0x24 2819 60 PUSH1 0x00 281B FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2811 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2816 memory[0x04:0x24] = 0x12 // @281B revert(memory[0x00:0x24]); // } // Block terminates label_281C: // Incoming jump from 0x2806, if stack[-2] // Inputs[3] // { // @281E stack[-3] // @281E stack[-2] // @281F stack[-4] // } 281C 5B JUMPDEST 281D 50 POP 281E 04 DIV 281F 90 SWAP1 2820 56 *JUMP // Stack delta = -3 // Outputs[1] { @281F stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_2821: // Incoming call from 0x126D, returns to 0x09B4 // Inputs[2] // { // @2826 stack[-1] // @2827 stack[-2] // } 2821 5B JUMPDEST 2822 60 PUSH1 0x00 2824 60 PUSH1 0x20 2826 82 DUP3 2827 84 DUP5 2828 03 SUB 2829 12 SLT 282A 15 ISZERO 282B 61 PUSH2 0x2833 282E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2822 stack[0] = 0x00 } // Block ends with conditional jump to 0x2833, if !(stack[-2] - stack[-1] i< 0x20) label_282F: // Incoming jump from 0x282E, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2832 memory[0x00:0x00] } 282F 60 PUSH1 0x00 2831 80 DUP1 2832 FD *REVERT // Stack delta = +0 // Outputs[1] { @2832 revert(memory[0x00:0x00]); } // Block terminates label_2833: // Incoming jump from 0x282E, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2834 stack[-2] // @2835 memory[stack[-2]:stack[-2] + 0x20] // } 2833 5B JUMPDEST 2834 81 DUP2 2835 51 MLOAD 2836 61 PUSH2 0x13c0 2839 81 DUP2 283A 61 PUSH2 0x25f3 283D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2835 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2836 stack[1] = 0x13c0 // @2839 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x25f3, returns to 0x13C0 label_283E: // Incoming call from 0x1323, returns to 0x09B4 // Inputs[2] // { // @2843 stack[-1] // @2844 stack[-2] // } 283E 5B JUMPDEST 283F 60 PUSH1 0x00 2841 60 PUSH1 0x20 2843 82 DUP3 2844 84 DUP5 2845 03 SUB 2846 12 SLT 2847 15 ISZERO 2848 61 PUSH2 0x2850 284B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @283F stack[0] = 0x00 } // Block ends with conditional jump to 0x2850, if !(stack[-2] - stack[-1] i< 0x20) label_284C: // Incoming jump from 0x284B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @284F memory[0x00:0x00] } 284C 60 PUSH1 0x00 284E 80 DUP1 284F FD *REVERT // Stack delta = +0 // Outputs[1] { @284F revert(memory[0x00:0x00]); } // Block terminates label_2850: // Incoming jump from 0x284B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2851 stack[-2] // @2852 memory[stack[-2]:stack[-2] + 0x20] // } 2850 5B JUMPDEST 2851 81 DUP2 2852 51 MLOAD 2853 67 PUSH8 0xffffffffffffffff 285C 81 DUP2 285D 11 GT 285E 15 ISZERO 285F 61 PUSH2 0x2867 2862 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2852 stack[0] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2867, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_2863: // Incoming jump from 0x2862, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2866 memory[0x00:0x00] } 2863 60 PUSH1 0x00 2865 80 DUP1 2866 FD *REVERT // Stack delta = +0 // Outputs[1] { @2866 revert(memory[0x00:0x00]); } // Block terminates label_2867: // Incoming jump from 0x2862, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2868 stack[-3] // @2869 stack[-1] // @286E stack[-4] // } 2867 5B JUMPDEST 2868 82 DUP3 2869 01 ADD 286A 60 PUSH1 0x1f 286C 81 DUP2 286D 01 ADD 286E 84 DUP5 286F 13 SGT 2870 61 PUSH2 0x2878 2873 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2869 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x2878, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_2874: // Incoming jump from 0x2873, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @2877 memory[0x00:0x00] } 2874 60 PUSH1 0x00 2876 80 DUP1 2877 FD *REVERT // Stack delta = +0 // Outputs[1] { @2877 revert(memory[0x00:0x00]); } // Block terminates label_2878: // Incoming jump from 0x2873, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[2] // { // @2879 stack[-1] // @287A memory[stack[-1]:stack[-1] + 0x20] // } 2878 5B JUMPDEST 2879 80 DUP1 287A 51 MLOAD 287B 61 PUSH2 0x2886 287E 61 PUSH2 0x272e 2881 82 DUP3 2882 61 PUSH2 0x2693 2885 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @287A stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @287B stack[1] = 0x2886 // @287E stack[2] = 0x272e // @2881 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2693, returns to 0x272E label_2886: // Incoming return from call to 0x272E at 0x2885 // Inputs[4] // { // @2887 stack[-2] // @2888 stack[-1] // @288A stack[-6] // @288E stack[-3] // } 2886 5B JUMPDEST 2887 81 DUP2 2888 81 DUP2 2889 52 MSTORE 288A 85 DUP6 288B 60 PUSH1 0x20 288D 83 DUP4 288E 85 DUP6 288F 01 ADD 2890 01 ADD 2891 11 GT 2892 15 ISZERO 2893 61 PUSH2 0x289b 2896 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2889 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] } // Block ends with conditional jump to 0x289b, if !(stack[-3] + stack[-2] + 0x20 > stack[-6]) label_2897: // Incoming jump from 0x2896, if not !(stack[-3] + stack[-2] + 0x20 > stack[-6]) // Inputs[1] { @289A memory[0x00:0x00] } 2897 60 PUSH1 0x00 2899 80 DUP1 289A FD *REVERT // Stack delta = +0 // Outputs[1] { @289A revert(memory[0x00:0x00]); } // Block terminates label_289B: // Incoming jump from 0x2896, if !(stack[-3] + stack[-2] + 0x20 > stack[-6]) // Inputs[3] // { // @289F stack[-2] // @28A2 stack[-1] // @28A6 stack[-3] // } 289B 5B JUMPDEST 289C 61 PUSH2 0x28ac 289F 82 DUP3 28A0 60 PUSH1 0x20 28A2 83 DUP4 28A3 01 ADD 28A4 60 PUSH1 0x20 28A6 86 DUP7 28A7 01 ADD 28A8 61 PUSH2 0x24c3 28AB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @289C stack[0] = 0x28ac // @289F stack[1] = stack[-2] // @28A3 stack[2] = stack[-1] + 0x20 // @28A7 stack[3] = stack[-3] + 0x20 // } // Block ends with call to 0x24c3, returns to 0x28AC label_28AC: // Incoming return from call to 0x24C3 at 0x28AB // Inputs[3] // { // @28AD stack[-7] // @28AD stack[-1] // @28AE stack[-6] // } 28AC 5B JUMPDEST 28AD 95 SWAP6 28AE 94 SWAP5 28AF 50 POP 28B0 50 POP 28B1 50 POP 28B2 50 POP 28B3 50 POP 28B4 56 *JUMP // Stack delta = -6 // Outputs[1] { @28AD stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] 28B5 5B JUMPDEST 28B6 60 PUSH1 0x01 28B8 60 PUSH1 0x01 28BA 60 PUSH1 0xa0 28BC 1B SHL 28BD 03 SUB 28BE 85 DUP6 28BF 81 DUP2 28C0 16 AND 28C1 82 DUP3 28C2 52 MSTORE 28C3 84 DUP5 28C4 16 AND 28C5 60 PUSH1 0x20 28C7 82 DUP3 28C8 01 ADD 28C9 52 MSTORE 28CA 60 PUSH1 0x40 28CC 81 DUP2 28CD 01 ADD 28CE 83 DUP4 28CF 90 SWAP1 28D0 52 MSTORE 28D1 60 PUSH1 0x80 28D3 60 PUSH1 0x60 28D5 82 DUP3 28D6 01 ADD 28D7 81 DUP2 28D8 90 SWAP1 28D9 52 MSTORE 28DA 60 PUSH1 0x00 28DC 90 SWAP1 28DD 61 PUSH2 0x28e8 28E0 90 SWAP1 28E1 83 DUP4 28E2 01 ADD 28E3 84 DUP5 28E4 61 PUSH2 0x24e7 28E7 56 *JUMP 28E8 5B JUMPDEST 28E9 96 SWAP7 28EA 95 SWAP6 28EB 50 POP 28EC 50 POP 28ED 50 POP 28EE 50 POP 28EF 50 POP 28F0 50 POP 28F1 56 *JUMP 28F2 5B JUMPDEST 28F3 60 PUSH1 0x00 28F5 60 PUSH1 0x20 28F7 82 DUP3 28F8 84 DUP5 28F9 03 SUB 28FA 12 SLT 28FB 15 ISZERO 28FC 61 PUSH2 0x2904 28FF 57 *JUMPI 2900 60 PUSH1 0x00 2902 80 DUP1 2903 FD *REVERT 2904 5B JUMPDEST 2905 81 DUP2 2906 51 MLOAD 2907 61 PUSH2 0x13c0 290A 81 DUP2 290B 61 PUSH2 0x244b 290E 56 *JUMP label_290F: // Incoming call from 0x2107, returns to 0x2108 // Incoming call from 0x21C2, returns to 0x21C3 // Incoming call from 0x1DB1, returns to 0x1DB2 // Inputs[2] // { // @2910 stack[-1] // @2911 stack[-2] // } 290F 5B JUMPDEST 2910 80 DUP1 2911 82 DUP3 2912 01 ADD 2913 80 DUP1 2914 82 DUP3 2915 11 GT 2916 15 ISZERO 2917 61 PUSH2 0x09b4 291A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2912 stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x09b4, if !(stack[-1] > stack[-2] + stack[-1]) label_291B: // Incoming jump from 0x291A, if not !(stack[-1] > stack[-2] + stack[-1]) 291B 61 PUSH2 0x09b4 291E 61 PUSH2 0x27d2 2921 56 *JUMP // Stack delta = +1 // Outputs[1] { @291B stack[0] = 0x09b4 } // Block ends with unconditional jump to 0x27d2 2922 5B JUMPDEST 2923 7F PUSH32 0x416363657373436f6e74726f6c3a206163636f756e7420000000000000000000 2944 81 DUP2 2945 52 MSTORE 2946 60 PUSH1 0x00 2948 83 DUP4 2949 51 MLOAD 294A 61 PUSH2 0x295a 294D 81 DUP2 294E 60 PUSH1 0x17 2950 85 DUP6 2951 01 ADD 2952 60 PUSH1 0x20 2954 88 DUP9 2955 01 ADD 2956 61 PUSH2 0x24c3 2959 56 *JUMP 295A 5B JUMPDEST 295B 70 PUSH17 0x01034b99036b4b9b9b4b733903937b6329 296D 60 PUSH1 0x7d 296F 1B SHL 2970 60 PUSH1 0x17 2972 91 SWAP2 2973 84 DUP5 2974 01 ADD 2975 91 SWAP2 2976 82 DUP3 2977 01 ADD 2978 52 MSTORE 2979 83 DUP4 297A 51 MLOAD 297B 61 PUSH2 0x298b 297E 81 DUP2 297F 60 PUSH1 0x28 2981 84 DUP5 2982 01 ADD 2983 60 PUSH1 0x20 2985 88 DUP9 2986 01 ADD 2987 61 PUSH2 0x24c3 298A 56 *JUMP 298B 5B JUMPDEST 298C 01 ADD 298D 60 PUSH1 0x28 298F 01 ADD 2990 94 SWAP5 2991 93 SWAP4 2992 50 POP 2993 50 POP 2994 50 POP 2995 50 POP 2996 56 *JUMP label_2997: // Incoming jump from 0x220C // Incoming jump from 0x22E1 // Incoming jump from 0x21F6 // Incoming jump from 0x2304 // Incoming jump from 0x2164 // Incoming jump from 0x2193 // Inputs[1] { @29AC memory[0x00:0x24] } 2997 5B JUMPDEST 2998 63 PUSH4 0x4e487b71 299D 60 PUSH1 0xe0 299F 1B SHL 29A0 60 PUSH1 0x00 29A2 52 MSTORE 29A3 60 PUSH1 0x32 29A5 60 PUSH1 0x04 29A7 52 MSTORE 29A8 60 PUSH1 0x24 29AA 60 PUSH1 0x00 29AC FD *REVERT // Stack delta = +0 // Outputs[3] // { // @29A2 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @29A7 memory[0x04:0x24] = 0x32 // @29AC revert(memory[0x00:0x24]); // } // Block terminates label_29AD: // Incoming call from 0x2233, returns to 0x2234 // Inputs[1] { @29B0 stack[-1] } 29AD 5B JUMPDEST 29AE 60 PUSH1 0x00 29B0 81 DUP2 29B1 61 PUSH2 0x29bc 29B4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @29AE stack[0] = 0x00 } // Block ends with conditional jump to 0x29bc, if stack[-1] label_29B5: // Incoming jump from 0x29B4, if not stack[-1] 29B5 61 PUSH2 0x29bc 29B8 61 PUSH2 0x27d2 29BB 56 *JUMP // Stack delta = +1 // Outputs[1] { @29B5 stack[0] = 0x29bc } // Block ends with unconditional jump to 0x27d2 label_29BC: // Incoming jump from 0x29B4, if stack[-1] // Inputs[2] // { // @29C1 stack[-2] // @29C2 stack[-3] // } 29BC 5B JUMPDEST 29BD 50 POP 29BE 60 PUSH1 0x00 29C0 19 NOT 29C1 01 ADD 29C2 90 SWAP1 29C3 56 *JUMP // Stack delta = -2 // Outputs[1] { @29C2 stack[-3] = ~0x00 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_29C4: // Incoming call from 0x22AD, returns to 0x22AE // Incoming call from 0x22C1, returns to 0x22C2 // Inputs[2] // { // @29C5 stack[-2] // @29C6 stack[-1] // } 29C4 5B JUMPDEST 29C5 81 DUP2 29C6 81 DUP2 29C7 03 SUB 29C8 81 DUP2 29C9 81 DUP2 29CA 11 GT 29CB 15 ISZERO 29CC 61 PUSH2 0x09b4 29CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @29C7 stack[0] = stack[-1] - stack[-2] } // Block ends with conditional jump to 0x09b4, if !(stack[-1] - stack[-2] > stack[-1]) label_29D0: // Incoming jump from 0x29CF, if not !(stack[-1] - stack[-2] > stack[-1]) 29D0 61 PUSH2 0x09b4 29D3 61 PUSH2 0x27d2 29D6 56 *JUMP // Stack delta = +1 // Outputs[1] { @29D0 stack[0] = 0x09b4 } // Block ends with unconditional jump to 0x27d2 label_29D7: // Incoming jump from 0x2337 // Inputs[1] { @29EC memory[0x00:0x24] } 29D7 5B JUMPDEST 29D8 63 PUSH4 0x4e487b71 29DD 60 PUSH1 0xe0 29DF 1B SHL 29E0 60 PUSH1 0x00 29E2 52 MSTORE 29E3 60 PUSH1 0x31 29E5 60 PUSH1 0x04 29E7 52 MSTORE 29E8 60 PUSH1 0x24 29EA 60 PUSH1 0x00 29EC FD *REVERT // Stack delta = +0 // Outputs[3] // { // @29E2 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @29E7 memory[0x04:0x24] = 0x31 // @29EC revert(memory[0x00:0x24]); // } // Block terminates 29ED FE *ASSERT 29EE 71 PUSH18 0x82bc540a919506f5dbc9f55afae7cdd4ca47 2A01 64 PUSH5 0x99f0017cee 2A07 40 BLOCKHASH 2A08 BD BD 2A09 C9 C9 2A0A 9F SWAP16 2A0B 34 CALLVALUE 2A0C A6 A6 2A0D 1E 1E 2A0E A2 LOG2 2A0F 64 PUSH5 0x6970667358 2A15 22 22 2A16 12 SLT 2A17 20 SHA3 2A18 38 CODESIZE 2A19 B4 B4 2A1A 3F EXTCODEHASH 2A1B C0 C0 2A1C F1 CALL 2A1D 3B EXTCODESIZE 2A1E 47 SELFBALANCE 2A1F 9A SWAP11 2A20 E5 E5 2A21 62 PUSH3 0x99e396 2A25 BC BC 2A26 B8 B8 2A27 9F SWAP16 2A28 8D DUP14 2A29 BB BB 2A2A 57 *JUMPI 2A2B 09 MULMOD 2A2C C3 C3 2A2D BF BF 2A2E 3C EXTCODECOPY 2A2F FD *REVERT 2A30 46 CHAINID 2A31 24 24 2A32 53 MSTORE8 2A33 CB CB 2A34 C1 C1 2A35 42 TIMESTAMP 2A36 C4 C4 2A37 62 PUSH3 0x64736f 2A3B 6C PUSH13 0x63430008130033