Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x016b 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x016b, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x715018a6 0026 11 GT 0027 61 PUSH2 0x00cd 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00cd, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xd5abeb01 0031 11 GT 0032 61 PUSH2 0x0081 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0081, if 0xd5abeb01 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xd5abeb01 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xe985e9c5 003C 11 GT 003D 61 PUSH2 0x0066 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0066, if 0xe985e9c5 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xe985e9c5 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xe985e9c5 0047 14 EQ 0048 61 PUSH2 0x02b4 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b4, if 0xe985e9c5 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xf242432a 0052 14 EQ 0053 61 PUSH2 0x02c7 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c7, if 0xf242432a == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xf242432a == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf2fde38b 005D 14 EQ 005E 61 PUSH2 0x02da 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02da, if 0xf2fde38b == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0065 memory[0x00:0x00] } 0062 60 PUSH1 0x00 0064 80 DUP1 0065 FD *REVERT // Stack delta = +0 // Outputs[1] { @0065 revert(memory[0x00:0x00]); } // Block terminates label_0066: // Incoming jump from 0x0040, if 0xe985e9c5 > stack[-1] // Inputs[1] { @0067 stack[-1] } 0066 5B JUMPDEST 0067 80 DUP1 0068 63 PUSH4 0xd5abeb01 006D 14 EQ 006E 61 PUSH2 0x0298 0071 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0298, if 0xd5abeb01 == stack[-1] label_0072: // Incoming jump from 0x0071, if not 0xd5abeb01 == stack[-1] // Inputs[1] { @0072 stack[-1] } 0072 80 DUP1 0073 63 PUSH4 0xe43082f7 0078 14 EQ 0079 61 PUSH2 0x02a1 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a1, if 0xe43082f7 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xe43082f7 == stack[-1] // Inputs[1] { @0080 memory[0x00:0x00] } 007D 60 PUSH1 0x00 007F 80 DUP1 0080 FD *REVERT // Stack delta = +0 // Outputs[1] { @0080 revert(memory[0x00:0x00]); } // Block terminates label_0081: // Incoming jump from 0x0035, if 0xd5abeb01 > stack[-1] // Inputs[1] { @0082 stack[-1] } 0081 5B JUMPDEST 0082 80 DUP1 0083 63 PUSH4 0x8da5cb5b 0088 11 GT 0089 61 PUSH2 0x00b2 008C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b2, if 0x8da5cb5b > stack[-1] label_008D: // Incoming jump from 0x008C, if not 0x8da5cb5b > stack[-1] // Inputs[1] { @008D stack[-1] } 008D 80 DUP1 008E 63 PUSH4 0x8da5cb5b 0093 14 EQ 0094 61 PUSH2 0x0255 0097 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0255, if 0x8da5cb5b == stack[-1] label_0098: // Incoming jump from 0x0097, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0098 stack[-1] } 0098 80 DUP1 0099 63 PUSH4 0x95d89b41 009E 14 EQ 009F 61 PUSH2 0x027d 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027d, if 0x95d89b41 == stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0xa22cb465 00A9 14 EQ 00AA 61 PUSH2 0x0285 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0285, if 0xa22cb465 == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00B1 memory[0x00:0x00] } 00AE 60 PUSH1 0x00 00B0 80 DUP1 00B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @00B1 revert(memory[0x00:0x00]); } // Block terminates label_00B2: // Incoming jump from 0x008C, if 0x8da5cb5b > stack[-1] // Inputs[1] { @00B3 stack[-1] } 00B2 5B JUMPDEST 00B3 80 DUP1 00B4 63 PUSH4 0x715018a6 00B9 14 EQ 00BA 61 PUSH2 0x024d 00BD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024d, if 0x715018a6 == stack[-1] label_00BE: // Incoming jump from 0x00BD, if not 0x715018a6 == stack[-1] // Inputs[1] { @00BE stack[-1] } 00BE 80 DUP1 00BF 63 PUSH4 0x83c4c00d 00C4 14 EQ 00C5 61 PUSH2 0x01f6 00C8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f6, if 0x83c4c00d == stack[-1] label_00C9: // Incoming jump from 0x00C8, if not 0x83c4c00d == stack[-1] // Inputs[1] { @00CC memory[0x00:0x00] } 00C9 60 PUSH1 0x00 00CB 80 DUP1 00CC FD *REVERT // Stack delta = +0 // Outputs[1] { @00CC revert(memory[0x00:0x00]); } // Block terminates label_00CD: // Incoming jump from 0x002A, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00CE stack[-1] } 00CD 5B JUMPDEST 00CE 80 DUP1 00CF 63 PUSH4 0x18160ddd 00D4 11 GT 00D5 61 PUSH2 0x0124 00D8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0124, if 0x18160ddd > stack[-1] label_00D9: // Incoming jump from 0x00D8, if not 0x18160ddd > stack[-1] // Inputs[1] { @00D9 stack[-1] } 00D9 80 DUP1 00DA 63 PUSH4 0x4e1273f4 00DF 11 GT 00E0 61 PUSH2 0x0109 00E3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0109, if 0x4e1273f4 > stack[-1] label_00E4: // Incoming jump from 0x00E3, if not 0x4e1273f4 > stack[-1] // Inputs[1] { @00E4 stack[-1] } 00E4 80 DUP1 00E5 63 PUSH4 0x4e1273f4 00EA 14 EQ 00EB 61 PUSH2 0x0211 00EE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0211, if 0x4e1273f4 == stack[-1] label_00EF: // Incoming jump from 0x00EE, if not 0x4e1273f4 == stack[-1] // Inputs[1] { @00EF stack[-1] } 00EF 80 DUP1 00F0 63 PUSH4 0x55f804b3 00F5 14 EQ 00F6 61 PUSH2 0x0231 00F9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0231, if 0x55f804b3 == stack[-1] label_00FA: // Incoming jump from 0x00F9, if not 0x55f804b3 == stack[-1] // Inputs[1] { @00FA stack[-1] } 00FA 80 DUP1 00FB 63 PUSH4 0x61bc221a 0100 14 EQ 0101 61 PUSH2 0x0244 0104 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0244, if 0x61bc221a == stack[-1] label_0105: // Incoming jump from 0x0104, if not 0x61bc221a == stack[-1] // Inputs[1] { @0108 memory[0x00:0x00] } 0105 60 PUSH1 0x00 0107 80 DUP1 0108 FD *REVERT // Stack delta = +0 // Outputs[1] { @0108 revert(memory[0x00:0x00]); } // Block terminates label_0109: // Incoming jump from 0x00E3, if 0x4e1273f4 > stack[-1] // Inputs[1] { @010A stack[-1] } 0109 5B JUMPDEST 010A 80 DUP1 010B 63 PUSH4 0x18160ddd 0110 14 EQ 0111 61 PUSH2 0x01f6 0114 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f6, if 0x18160ddd == stack[-1] label_0115: // Incoming jump from 0x0114, if not 0x18160ddd == stack[-1] // Inputs[1] { @0115 stack[-1] } 0115 80 DUP1 0116 63 PUSH4 0x2eb2c2d6 011B 14 EQ 011C 61 PUSH2 0x01fe 011F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fe, if 0x2eb2c2d6 == stack[-1] label_0120: // Incoming jump from 0x011F, if not 0x2eb2c2d6 == stack[-1] // Inputs[1] { @0123 memory[0x00:0x00] } 0120 60 PUSH1 0x00 0122 80 DUP1 0123 FD *REVERT // Stack delta = +0 // Outputs[1] { @0123 revert(memory[0x00:0x00]); } // Block terminates label_0124: // Incoming jump from 0x00D8, if 0x18160ddd > stack[-1] // Inputs[1] { @0125 stack[-1] } 0124 5B JUMPDEST 0125 80 DUP1 0126 63 PUSH4 0x06fdde03 012B 11 GT 012C 61 PUSH2 0x0155 012F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0155, if 0x06fdde03 > stack[-1] label_0130: // Incoming jump from 0x012F, if not 0x06fdde03 > stack[-1] // Inputs[1] { @0130 stack[-1] } 0130 80 DUP1 0131 63 PUSH4 0x06fdde03 0136 14 EQ 0137 61 PUSH2 0x01b9 013A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b9, if 0x06fdde03 == stack[-1] label_013B: // Incoming jump from 0x013A, if not 0x06fdde03 == stack[-1] // Inputs[1] { @013B stack[-1] } 013B 80 DUP1 013C 63 PUSH4 0x0e89341c 0141 14 EQ 0142 61 PUSH2 0x01ce 0145 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ce, if 0x0e89341c == stack[-1] label_0146: // Incoming jump from 0x0145, if not 0x0e89341c == stack[-1] // Inputs[1] { @0146 stack[-1] } 0146 80 DUP1 0147 63 PUSH4 0x11fecb4e 014C 14 EQ 014D 61 PUSH2 0x01e1 0150 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e1, if 0x11fecb4e == stack[-1] label_0151: // Incoming jump from 0x0150, if not 0x11fecb4e == stack[-1] // Inputs[1] { @0154 memory[0x00:0x00] } 0151 60 PUSH1 0x00 0153 80 DUP1 0154 FD *REVERT // Stack delta = +0 // Outputs[1] { @0154 revert(memory[0x00:0x00]); } // Block terminates label_0155: // Incoming jump from 0x012F, if 0x06fdde03 > stack[-1] // Inputs[1] { @0156 stack[-1] } 0155 5B JUMPDEST 0156 80 DUP1 0157 62 PUSH3 0xfdd58e 015B 14 EQ 015C 61 PUSH2 0x0170 015F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0170, if 0xfdd58e == stack[-1] label_0160: // Incoming jump from 0x015F, if not 0xfdd58e == stack[-1] // Inputs[1] { @0160 stack[-1] } 0160 80 DUP1 0161 63 PUSH4 0x01ffc9a7 0166 14 EQ 0167 61 PUSH2 0x0196 016A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0196, if 0x01ffc9a7 == stack[-1] label_016B: // Incoming jump from 0x016A, if not 0x01ffc9a7 == stack[-1] // Incoming jump from 0x0019, if msg.data.length < 0x04 // Inputs[1] { @016F memory[0x00:0x00] } 016B 5B JUMPDEST 016C 60 PUSH1 0x00 016E 80 DUP1 016F FD *REVERT // Stack delta = +0 // Outputs[1] { @016F revert(memory[0x00:0x00]); } // Block terminates label_0170: // Incoming jump from 0x015F, if 0xfdd58e == stack[-1] // Inputs[1] { @0177 msg.data.length } 0170 5B JUMPDEST 0171 61 PUSH2 0x0183 0174 61 PUSH2 0x017e 0177 36 CALLDATASIZE 0178 60 PUSH1 0x04 017A 61 PUSH2 0x22d2 017D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0171 stack[0] = 0x0183 // @0174 stack[1] = 0x017e // @0177 stack[2] = msg.data.length // @0178 stack[3] = 0x04 // } // Block ends with call to 0x22d2, returns to 0x017E label_017E: // Incoming return from call to 0x22D2 at 0x017D 017E 5B JUMPDEST 017F 61 PUSH2 0x02ed 0182 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02ed label_0183: // Incoming return from call to 0x017E at 0x017D // Incoming jump from 0x02A0 // Incoming jump from 0x024C // Incoming jump from 0x01FD // Inputs[2] // { // @0186 memory[0x40:0x60] // @0187 stack[-1] // } 0183 5B JUMPDEST 0184 60 PUSH1 0x40 0186 51 MLOAD 0187 90 SWAP1 0188 81 DUP2 0189 52 MSTORE 018A 60 PUSH1 0x20 018C 01 ADD // Stack delta = +0 // Outputs[2] // { // @0189 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @018C stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_018D: // Incoming jump from 0x027C // Incoming jump from 0x01B8 // Incoming jump from 0x018C // Inputs[3] // { // @0190 memory[0x40:0x60] // @0192 stack[-1] // @0195 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 018D 5B JUMPDEST 018E 60 PUSH1 0x40 0190 51 MLOAD 0191 80 DUP1 0192 91 SWAP2 0193 03 SUB 0194 90 SWAP1 0195 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0195 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0196: // Incoming jump from 0x016A, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @019D msg.data.length } 0196 5B JUMPDEST 0197 61 PUSH2 0x01a9 019A 61 PUSH2 0x01a4 019D 36 CALLDATASIZE 019E 60 PUSH1 0x04 01A0 61 PUSH2 0x23c2 01A3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0197 stack[0] = 0x01a9 // @019A stack[1] = 0x01a4 // @019D stack[2] = msg.data.length // @019E stack[3] = 0x04 // } // Block ends with call to 0x23c2, returns to 0x01A4 label_01A4: // Incoming return from call to 0x23C2 at 0x01A3 01A4 5B JUMPDEST 01A5 61 PUSH2 0x03cd 01A8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03cd label_01A9: // Incoming return from call to 0x01A4 at 0x01A3 // Incoming return from call to 0x02C2 at 0x02C1 // Incoming return from call to 0x02C2 at 0x02C1 // Inputs[2] // { // @01AC memory[0x40:0x60] // @01AD stack[-1] // } 01A9 5B JUMPDEST 01AA 60 PUSH1 0x40 01AC 51 MLOAD 01AD 90 SWAP1 01AE 15 ISZERO 01AF 15 ISZERO 01B0 81 DUP2 01B1 52 MSTORE 01B2 60 PUSH1 0x20 01B4 01 ADD 01B5 61 PUSH2 0x018d 01B8 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01B1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @01B4 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x018d label_01B9: // Incoming jump from 0x013A, if 0x06fdde03 == stack[-1] 01B9 5B JUMPDEST 01BA 61 PUSH2 0x01c1 01BD 61 PUSH2 0x04b0 01C0 56 *JUMP // Stack delta = +1 // Outputs[1] { @01BA stack[0] = 0x01c1 } // Block ends with call to 0x04b0, returns to 0x01C1 label_01C1: // Incoming return from call to 0x04B0 at 0x01C0 // Incoming return from call to 0x0B0B at 0x0284 // Incoming return from call to 0x01DC at 0x01DB // Inputs[2] // { // @01C4 memory[0x40:0x60] // @01C8 stack[-1] // } 01C1 5B JUMPDEST 01C2 60 PUSH1 0x40 01C4 51 MLOAD 01C5 61 PUSH2 0x018d 01C8 91 SWAP2 01C9 90 SWAP1 01CA 61 PUSH2 0x2623 01CD 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01C8 stack[-1] = 0x018d // @01C9 stack[1] = memory[0x40:0x60] // @01C9 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2623 label_01CE: // Incoming jump from 0x0145, if 0x0e89341c == stack[-1] // Inputs[1] { @01D5 msg.data.length } 01CE 5B JUMPDEST 01CF 61 PUSH2 0x01c1 01D2 61 PUSH2 0x01dc 01D5 36 CALLDATASIZE 01D6 60 PUSH1 0x04 01D8 61 PUSH2 0x245c 01DB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01CF stack[0] = 0x01c1 // @01D2 stack[1] = 0x01dc // @01D5 stack[2] = msg.data.length // @01D6 stack[3] = 0x04 // } // Block ends with call to 0x245c, returns to 0x01DC label_01DC: // Incoming return from call to 0x245C at 0x01DB 01DC 5B JUMPDEST 01DD 61 PUSH2 0x053e 01E0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x053e label_01E1: // Incoming jump from 0x0150, if 0x11fecb4e == stack[-1] // Inputs[1] { @01E8 msg.data.length } 01E1 5B JUMPDEST 01E2 61 PUSH2 0x01f4 01E5 61 PUSH2 0x01ef 01E8 36 CALLDATASIZE 01E9 60 PUSH1 0x04 01EB 61 PUSH2 0x235e 01EE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01E2 stack[0] = 0x01f4 // @01E5 stack[1] = 0x01ef // @01E8 stack[2] = msg.data.length // @01E9 stack[3] = 0x04 // } // Block ends with call to 0x235e, returns to 0x01EF label_01EF: // Incoming return from call to 0x235E at 0x01EE 01EF 5B JUMPDEST 01F0 61 PUSH2 0x057f 01F3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x057f label_01F4: // Incoming return from call to 0x01EF at 0x01EE // Incoming return from call to 0x02AF at 0x02AE // Incoming return from call to 0x0293 at 0x0292 // Incoming return from call to 0x0A7E at 0x0254 01F4 5B JUMPDEST 01F5 00 *STOP // Stack delta = +0 // Outputs[1] { @01F5 stop(); } // Block terminates label_01F6: // Incoming jump from 0x00C8, if 0x83c4c00d == stack[-1] // Incoming jump from 0x0114, if 0x18160ddd == stack[-1] // Inputs[1] { @01F9 storage[0x06] } 01F6 5B JUMPDEST 01F7 60 PUSH1 0x06 01F9 54 SLOAD 01FA 61 PUSH2 0x0183 01FD 56 *JUMP // Stack delta = +1 // Outputs[1] { @01F9 stack[0] = storage[0x06] } // Block ends with unconditional jump to 0x0183 label_01FE: // Incoming jump from 0x011F, if 0x2eb2c2d6 == stack[-1] // Inputs[1] { @0205 msg.data.length } 01FE 5B JUMPDEST 01FF 61 PUSH2 0x01f4 0202 61 PUSH2 0x020c 0205 36 CALLDATASIZE 0206 60 PUSH1 0x04 0208 61 PUSH2 0x218d 020B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01FF stack[0] = 0x01f4 // @0202 stack[1] = 0x020c // @0205 stack[2] = msg.data.length // @0206 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x218d 020C 5B JUMPDEST 020D 61 PUSH2 0x0734 0210 56 *JUMP label_0211: // Incoming jump from 0x00EE, if 0x4e1273f4 == stack[-1] // Inputs[1] { @0218 msg.data.length } 0211 5B JUMPDEST 0212 61 PUSH2 0x0224 0215 61 PUSH2 0x021f 0218 36 CALLDATASIZE 0219 60 PUSH1 0x04 021B 61 PUSH2 0x22fd 021E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0212 stack[0] = 0x0224 // @0215 stack[1] = 0x021f // @0218 stack[2] = msg.data.length // @0219 stack[3] = 0x04 // } // Block ends with call to 0x22fd, returns to 0x021F label_021F: // Incoming return from call to 0x22FD at 0x021E 021F 5B JUMPDEST 0220 61 PUSH2 0x07fd 0223 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07fd label_0224: // Incoming return from call to 0x021F at 0x021E // Inputs[2] // { // @0227 memory[0x40:0x60] // @022B stack[-1] // } 0224 5B JUMPDEST 0225 60 PUSH1 0x40 0227 51 MLOAD 0228 61 PUSH2 0x018d 022B 91 SWAP2 022C 90 SWAP1 022D 61 PUSH2 0x25e2 0230 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @022B stack[-1] = 0x018d // @022C stack[1] = memory[0x40:0x60] // @022C stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x25e2 label_0231: // Incoming jump from 0x00F9, if 0x55f804b3 == stack[-1] // Inputs[1] { @0238 msg.data.length } 0231 5B JUMPDEST 0232 61 PUSH2 0x01f4 0235 61 PUSH2 0x023f 0238 36 CALLDATASIZE 0239 60 PUSH1 0x04 023B 61 PUSH2 0x2416 023E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0232 stack[0] = 0x01f4 // @0235 stack[1] = 0x023f // @0238 stack[2] = msg.data.length // @0239 stack[3] = 0x04 // } // Block ends with call to 0x2416, returns to 0x023F label_023F: // Incoming return from call to 0x2416 at 0x023E 023F 5B JUMPDEST 0240 61 PUSH2 0x09f1 0243 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09f1 label_0244: // Incoming jump from 0x0104, if 0x61bc221a == stack[-1] // Inputs[1] { @024A storage[0x06] } 0244 5B JUMPDEST 0245 61 PUSH2 0x0183 0248 60 PUSH1 0x06 024A 54 SLOAD 024B 81 DUP2 024C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0245 stack[0] = 0x0183 // @024A stack[1] = storage[0x06] // } // Block ends with unconditional jump to 0x0183 label_024D: // Incoming jump from 0x00BD, if 0x715018a6 == stack[-1] 024D 5B JUMPDEST 024E 61 PUSH2 0x01f4 0251 61 PUSH2 0x0a7e 0254 56 *JUMP // Stack delta = +1 // Outputs[1] { @024E stack[0] = 0x01f4 } // Block ends with call to 0x0a7e, returns to 0x01F4 label_0255: // Incoming jump from 0x0097, if 0x8da5cb5b == stack[-1] // Inputs[2] // { // @0258 storage[0x03] // @025B memory[0x40:0x60] // } 0255 5B JUMPDEST 0256 60 PUSH1 0x03 0258 54 SLOAD 0259 60 PUSH1 0x40 025B 51 MLOAD 025C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0271 90 SWAP1 0272 91 SWAP2 0273 16 AND 0274 81 DUP2 0275 52 MSTORE 0276 60 PUSH1 0x20 0278 01 ADD 0279 61 PUSH2 0x018d 027C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0275 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x03] & 0xffffffffffffffffffffffffffffffffffffffff // @0278 stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x018d label_027D: // Incoming jump from 0x00A2, if 0x95d89b41 == stack[-1] 027D 5B JUMPDEST 027E 61 PUSH2 0x01c1 0281 61 PUSH2 0x0b0b 0284 56 *JUMP // Stack delta = +1 // Outputs[1] { @027E stack[0] = 0x01c1 } // Block ends with call to 0x0b0b, returns to 0x01C1 label_0285: // Incoming jump from 0x00AD, if 0xa22cb465 == stack[-1] // Inputs[1] { @028C msg.data.length } 0285 5B JUMPDEST 0286 61 PUSH2 0x01f4 0289 61 PUSH2 0x0293 028C 36 CALLDATASIZE 028D 60 PUSH1 0x04 028F 61 PUSH2 0x229e 0292 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0286 stack[0] = 0x01f4 // @0289 stack[1] = 0x0293 // @028C stack[2] = msg.data.length // @028D stack[3] = 0x04 // } // Block ends with call to 0x229e, returns to 0x0293 label_0293: // Incoming return from call to 0x229E at 0x0292 0293 5B JUMPDEST 0294 61 PUSH2 0x0b18 0297 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b18 label_0298: // Incoming jump from 0x0071, if 0xd5abeb01 == stack[-1] // Inputs[1] { @029E storage[0x05] } 0298 5B JUMPDEST 0299 61 PUSH2 0x0183 029C 60 PUSH1 0x05 029E 54 SLOAD 029F 81 DUP2 02A0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0299 stack[0] = 0x0183 // @029E stack[1] = storage[0x05] // } // Block ends with unconditional jump to 0x0183 label_02A1: // Incoming jump from 0x007C, if 0xe43082f7 == stack[-1] // Inputs[1] { @02A8 msg.data.length } 02A1 5B JUMPDEST 02A2 61 PUSH2 0x01f4 02A5 61 PUSH2 0x02af 02A8 36 CALLDATASIZE 02A9 60 PUSH1 0x04 02AB 61 PUSH2 0x23a8 02AE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02A2 stack[0] = 0x01f4 // @02A5 stack[1] = 0x02af // @02A8 stack[2] = msg.data.length // @02A9 stack[3] = 0x04 // } // Block ends with call to 0x23a8, returns to 0x02AF label_02AF: // Incoming return from call to 0x23A8 at 0x02AE 02AF 5B JUMPDEST 02B0 61 PUSH2 0x0b27 02B3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b27 label_02B4: // Incoming jump from 0x004B, if 0xe985e9c5 == stack[-1] // Inputs[1] { @02BB msg.data.length } 02B4 5B JUMPDEST 02B5 61 PUSH2 0x01a9 02B8 61 PUSH2 0x02c2 02BB 36 CALLDATASIZE 02BC 60 PUSH1 0x04 02BE 61 PUSH2 0x2155 02C1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02B5 stack[0] = 0x01a9 // @02B8 stack[1] = 0x02c2 // @02BB stack[2] = msg.data.length // @02BC stack[3] = 0x04 // } // Block ends with call to 0x2155, returns to 0x02C2 label_02C2: // Incoming return from call to 0x2155 at 0x02C1 02C2 5B JUMPDEST 02C3 61 PUSH2 0x0bf2 02C6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bf2 label_02C7: // Incoming jump from 0x0056, if 0xf242432a == stack[-1] // Inputs[1] { @02CE msg.data.length } 02C7 5B JUMPDEST 02C8 61 PUSH2 0x01f4 02CB 61 PUSH2 0x02d5 02CE 36 CALLDATASIZE 02CF 60 PUSH1 0x04 02D1 61 PUSH2 0x2237 02D4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02C8 stack[0] = 0x01f4 // @02CB stack[1] = 0x02d5 // @02CE stack[2] = msg.data.length // @02CF stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2237 02D5 5B JUMPDEST 02D6 61 PUSH2 0x0d3c 02D9 56 *JUMP label_02DA: // Incoming jump from 0x0061, if 0xf2fde38b == stack[-1] // Inputs[1] { @02E1 msg.data.length } 02DA 5B JUMPDEST 02DB 61 PUSH2 0x01f4 02DE 61 PUSH2 0x02e8 02E1 36 CALLDATASIZE 02E2 60 PUSH1 0x04 02E4 61 PUSH2 0x2139 02E7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02DB stack[0] = 0x01f4 // @02DE stack[1] = 0x02e8 // @02E1 stack[2] = msg.data.length // @02E2 stack[3] = 0x04 // } // Block ends with call to 0x2139, returns to 0x02E8 label_02E8: // Incoming return from call to 0x2139 at 0x02E7 02E8 5B JUMPDEST 02E9 61 PUSH2 0x0dfe 02EC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dfe label_02ED: // Incoming jump from 0x0182 // Incoming jump from 0x0994 // Inputs[1] { @0305 stack[-2] } 02ED 5B JUMPDEST 02EE 60 PUSH1 0x00 02F0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0305 83 DUP4 0306 16 AND 0307 61 PUSH2 0x0397 030A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02EE stack[0] = 0x00 } // Block ends with conditional jump to 0x0397, if stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff label_030B: // Incoming jump from 0x030A, if not stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @030D memory[0x40:0x60] } 030B 60 PUSH1 0x40 030D 51 MLOAD 030E 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 032F 81 DUP2 0330 52 MSTORE 0331 60 PUSH1 0x20 0333 60 PUSH1 0x04 0335 82 DUP3 0336 01 ADD 0337 52 MSTORE 0338 60 PUSH1 0x2b 033A 60 PUSH1 0x24 033C 82 DUP3 033D 01 ADD 033E 52 MSTORE 033F 7F PUSH32 0x455243313135353a2062616c616e636520717565727920666f7220746865207a 0360 60 PUSH1 0x44 0362 82 DUP3 0363 01 ADD 0364 52 MSTORE 0365 7F PUSH32 0x65726f2061646472657373000000000000000000000000000000000000000000 0386 60 PUSH1 0x64 0388 82 DUP3 0389 01 ADD 038A 52 MSTORE 038B 60 PUSH1 0x84 038D 01 ADD // Stack delta = +1 // Outputs[6] // { // @0330 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0337 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @033E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @0364 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2062616c616e636520717565727920666f7220746865207a // @038A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x65726f2061646472657373000000000000000000000000000000000000000000 // @038D stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_038E: // Incoming jump from 0x038D // Incoming jump from 0x0BA7 // Incoming jump from 0x1773 // Incoming jump from 0x0A71 // Incoming jump from 0x11E1 // Incoming jump from 0x0F21 // Incoming jump from 0x1C77 // Incoming jump from 0x05FF // Incoming jump from 0x1C77 // Incoming jump from 0x088F // Incoming jump from 0x069F // Incoming jump from 0x0AFE // Incoming jump from 0x1D48 // Incoming jump from 0x0E7E // Inputs[3] // { // @0391 memory[0x40:0x60] // @0393 stack[-1] // @0396 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 038E 5B JUMPDEST 038F 60 PUSH1 0x40 0391 51 MLOAD 0392 80 DUP1 0393 91 SWAP2 0394 03 SUB 0395 90 SWAP1 0396 FD *REVERT // Stack delta = -1 // Outputs[1] { @0396 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0397: // Incoming jump from 0x030A, if stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[6] // { // @039B stack[-2] // @03A7 memory[0x00:0x40] // @03BD stack[-3] // @03C5 memory[0x00:0x40] // @03C6 storage[keccak256(memory[0x00:0x40])] // @03C8 stack[-4] // } 0397 5B JUMPDEST 0398 50 POP 0399 60 PUSH1 0x00 039B 81 DUP2 039C 81 DUP2 039D 52 MSTORE 039E 60 PUSH1 0x20 03A0 81 DUP2 03A1 81 DUP2 03A2 52 MSTORE 03A3 60 PUSH1 0x40 03A5 80 DUP1 03A6 83 DUP4 03A7 20 SHA3 03A8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03BD 86 DUP7 03BE 16 AND 03BF 84 DUP5 03C0 52 MSTORE 03C1 90 SWAP1 03C2 91 SWAP2 03C3 52 MSTORE 03C4 90 SWAP1 03C5 20 SHA3 03C6 54 SLOAD 03C7 5B JUMPDEST 03C8 92 SWAP3 03C9 91 SWAP2 03CA 50 POP 03CB 50 POP 03CC 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @039D memory[0x00:0x20] = stack[-2] // @03A2 memory[0x20:0x40] = 0x00 // @03C0 memory[0x00:0x20] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @03C3 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @03C8 stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_03CD: // Incoming jump from 0x01A8 // Inputs[1] { @03F1 stack[-1] } 03CD 5B JUMPDEST 03CE 60 PUSH1 0x00 03D0 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 03F1 82 DUP3 03F2 16 AND 03F3 7F PUSH32 0xd9b67a2600000000000000000000000000000000000000000000000000000000 0414 14 EQ 0415 80 DUP1 0416 61 PUSH2 0x0460 0419 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @03CE stack[0] = 0x00 // @0414 stack[1] = 0xd9b67a2600000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x0460, if 0xd9b67a2600000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_041A: // Incoming jump from 0x0419, if not 0xd9b67a2600000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @043C stack[-3] } 041A 50 POP 041B 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 043C 82 DUP3 043D 16 AND 043E 7F PUSH32 0x0e89341c00000000000000000000000000000000000000000000000000000000 045F 14 EQ 0460 5B JUMPDEST 0461 80 DUP1 0462 61 PUSH2 0x03c7 0465 57 *JUMPI // Stack delta = +0 // Outputs[1] { @045F stack[-1] = 0x0e89341c00000000000000000000000000000000000000000000000000000000 == stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x03c7, if 0x0e89341c00000000000000000000000000000000000000000000000000000000 == stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_0466: // Incoming jump from 0x0465, if not 0x0e89341c00000000000000000000000000000000000000000000000000000000 == stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x0465, if not stack[-1] // Inputs[1] { @04A9 stack[-3] } 0466 50 POP 0467 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 0488 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 04A9 83 DUP4 04AA 16 AND 04AB 14 EQ 04AC 61 PUSH2 0x03c7 04AF 56 *JUMP // Stack delta = +0 // Outputs[1] { @04AB stack[-1] = stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to 0x03c7 label_04B0: // Incoming call from 0x01C0, returns to 0x01C1 // Inputs[1] { @04B4 storage[0x07] } 04B0 5B JUMPDEST 04B1 60 PUSH1 0x07 04B3 80 DUP1 04B4 54 SLOAD 04B5 61 PUSH2 0x04bd 04B8 90 SWAP1 04B9 61 PUSH2 0x26cd 04BC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @04B1 stack[0] = 0x07 // @04B8 stack[1] = 0x04bd // @04B8 stack[2] = storage[0x07] // } // Block ends with call to 0x26cd, returns to 0x04BD label_04BD: // Incoming return from call to 0x26CD at 0x04BC // Incoming return from call to 0x26CD at 0x0B17 // Inputs[4] // { // @04BE stack[-1] // @04CD memory[0x40:0x60] // @04D5 stack[-2] // @04E0 storage[stack[-2]] // } 04BD 5B JUMPDEST 04BE 80 DUP1 04BF 60 PUSH1 0x1f 04C1 01 ADD 04C2 60 PUSH1 0x20 04C4 80 DUP1 04C5 91 SWAP2 04C6 04 DIV 04C7 02 MUL 04C8 60 PUSH1 0x20 04CA 01 ADD 04CB 60 PUSH1 0x40 04CD 51 MLOAD 04CE 90 SWAP1 04CF 81 DUP2 04D0 01 ADD 04D1 60 PUSH1 0x40 04D3 52 MSTORE 04D4 80 DUP1 04D5 92 SWAP3 04D6 91 SWAP2 04D7 90 SWAP1 04D8 81 DUP2 04D9 81 DUP2 04DA 52 MSTORE 04DB 60 PUSH1 0x20 04DD 01 ADD 04DE 82 DUP3 04DF 80 DUP1 04E0 54 SLOAD 04E1 61 PUSH2 0x04e9 04E4 90 SWAP1 04E5 61 PUSH2 0x26cd 04E8 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @04D3 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @04D5 stack[-2] = memory[0x40:0x60] // @04D6 stack[-1] = stack[-2] // @04D7 stack[0] = stack[-1] // @04DA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @04DD stack[1] = 0x20 + memory[0x40:0x60] // @04DE stack[2] = stack[-2] // @04E4 stack[4] = storage[stack[-2]] // @04E4 stack[3] = 0x04e9 // } // Block ends with call to 0x26cd, returns to 0x04E9 label_04E9: // Incoming return from call to 0x26CD at 0x04E8 // Inputs[1] { @04EA stack[-1] } 04E9 5B JUMPDEST 04EA 80 DUP1 04EB 15 ISZERO 04EC 61 PUSH2 0x0536 04EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0536, if !stack[-1] label_04F0: // Incoming jump from 0x04EF, if not !stack[-1] // Inputs[1] { @04F0 stack[-1] } 04F0 80 DUP1 04F1 60 PUSH1 0x1f 04F3 10 LT 04F4 61 PUSH2 0x050b 04F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x050b, if 0x1f < stack[-1] label_04F8: // Incoming jump from 0x04F7, if not 0x1f < stack[-1] // Inputs[4] // { // @04FC stack[-2] // @04FD storage[stack[-2]] // @0500 stack[-3] // @0502 stack[-1] // } 04F8 61 PUSH2 0x0100 04FB 80 DUP1 04FC 83 DUP4 04FD 54 SLOAD 04FE 04 DIV 04FF 02 MUL 0500 83 DUP4 0501 52 MSTORE 0502 91 SWAP2 0503 60 PUSH1 0x20 0505 01 ADD 0506 91 SWAP2 0507 61 PUSH2 0x0536 050A 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0501 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0506 stack[-1] = stack[-1] // @0506 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0536 label_050B: // Incoming jump from 0x04F7, if 0x1f < stack[-1] // Inputs[5] // { // @050C stack[-3] // @050D stack[-1] // @050F stack[-2] // @0517 memory[0x00:0x20] // @051B storage[keccak256(memory[0x00:0x20])] // } 050B 5B JUMPDEST 050C 82 DUP3 050D 01 ADD 050E 91 SWAP2 050F 90 SWAP1 0510 60 PUSH1 0x00 0512 52 MSTORE 0513 60 PUSH1 0x20 0515 60 PUSH1 0x00 0517 20 SHA3 0518 90 SWAP1 0519 5B JUMPDEST 051A 81 DUP2 051B 54 SLOAD 051C 81 DUP2 051D 52 MSTORE 051E 90 SWAP1 051F 60 PUSH1 0x01 0521 01 ADD 0522 90 SWAP1 0523 60 PUSH1 0x20 0525 01 ADD 0526 80 DUP1 0527 83 DUP4 0528 11 GT 0529 61 PUSH2 0x0519 052C 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @050E stack[-3] = stack[-3] + stack[-1] // @0512 memory[0x00:0x20] = stack[-2] // @051D memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0522 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0525 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0519, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_052D: // Incoming jump from 0x052C, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x052C, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @052D stack[-3] // @052E stack[-1] // } 052D 82 DUP3 052E 90 SWAP1 052F 03 SUB 0530 60 PUSH1 0x1f 0532 16 AND 0533 82 DUP3 0534 01 ADD 0535 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0535 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0535 stack[-1] = stack[-3] // } // Block continues label_0536: // Incoming jump from 0x050A // Incoming jump from 0x04EF, if !stack[-1] // Incoming jump from 0x0535 // Inputs[1] { @053C stack[-7] } 0536 5B JUMPDEST 0537 50 POP 0538 50 POP 0539 50 POP 053A 50 POP 053B 50 POP 053C 81 DUP2 053D 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_053E: // Incoming jump from 0x01E0 // Inputs[1] { @0546 stack[-1] } 053E 5B JUMPDEST 053F 60 PUSH1 0x60 0541 60 PUSH1 0x00 0543 61 PUSH2 0x054b 0546 83 DUP4 0547 61 PUSH2 0x0f2b 054A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @053F stack[0] = 0x60 // @0541 stack[1] = 0x00 // @0543 stack[2] = 0x054b // @0546 stack[3] = stack[-1] // } // Block ends with call to 0x0f2b, returns to 0x054B label_054B: // Incoming return from call to 0x0F2B at 0x054A // Inputs[3] // { // @054C stack[-2] // @054C stack[-1] // @0552 stack[-4] // } 054B 5B JUMPDEST 054C 90 SWAP1 054D 50 POP 054E 80 DUP1 054F 61 PUSH2 0x0557 0552 84 DUP5 0553 61 PUSH2 0x0fbf 0556 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @054C stack[-2] = stack[-1] // @054E stack[-1] = stack[-1] // @054F stack[0] = 0x0557 // @0552 stack[1] = stack[-4] // } // Block ends with call to 0x0fbf, returns to 0x0557 label_0557: // Incoming return from call to 0x0FBF at 0x0556 // Inputs[3] // { // @055A memory[0x40:0x60] // @0561 stack[-2] // @0562 stack[-1] // } 0557 5B JUMPDEST 0558 60 PUSH1 0x40 055A 51 MLOAD 055B 60 PUSH1 0x20 055D 01 ADD 055E 61 PUSH2 0x0568 0561 92 SWAP3 0562 91 SWAP2 0563 90 SWAP1 0564 61 PUSH2 0x24f8 0567 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0561 stack[-2] = 0x0568 // @0562 stack[-1] = stack[-2] // @0563 stack[1] = 0x20 + memory[0x40:0x60] // @0563 stack[0] = stack[-1] // } // Block ends with call to 0x24f8, returns to 0x0568 label_0568: // Incoming return from call to 0x24F8 at 0x0567 // Inputs[5] // { // @056B memory[0x40:0x60] // @056F stack[-1] // @0578 stack[-3] // @057B stack[-5] // @057C stack[-4] // } 0568 5B JUMPDEST 0569 60 PUSH1 0x40 056B 51 MLOAD 056C 60 PUSH1 0x20 056E 81 DUP2 056F 83 DUP4 0570 03 SUB 0571 03 SUB 0572 81 DUP2 0573 52 MSTORE 0574 90 SWAP1 0575 60 PUSH1 0x40 0577 52 MSTORE 0578 91 SWAP2 0579 50 POP 057A 50 POP 057B 91 SWAP2 057C 90 SWAP1 057D 50 POP 057E 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @0573 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @0577 memory[0x40:0x60] = stack[-1] // @057B stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-5] label_057F: // Incoming jump from 0x01F3 // Inputs[2] // { // @0582 storage[0x03] // @0599 msg.sender // } 057F 5B JUMPDEST 0580 60 PUSH1 0x03 0582 54 SLOAD 0583 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0598 16 AND 0599 33 CALLER 059A 14 EQ 059B 61 PUSH2 0x0600 059E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0600, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] label_059F: // Incoming jump from 0x059E, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] // Inputs[1] { @05A1 memory[0x40:0x60] } 059F 60 PUSH1 0x40 05A1 51 MLOAD 05A2 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 05C3 81 DUP2 05C4 52 MSTORE 05C5 60 PUSH1 0x20 05C7 60 PUSH1 0x04 05C9 82 DUP3 05CA 01 ADD 05CB 81 DUP2 05CC 90 SWAP1 05CD 52 MSTORE 05CE 60 PUSH1 0x24 05D0 82 DUP3 05D1 01 ADD 05D2 52 MSTORE 05D3 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 05F4 60 PUSH1 0x44 05F6 82 DUP3 05F7 01 ADD 05F8 52 MSTORE 05F9 60 PUSH1 0x64 05FB 01 ADD 05FC 61 PUSH2 0x038e 05FF 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @05C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @05CD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @05D2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @05F8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @05FB stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x038e label_0600: // Incoming jump from 0x059E, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] // Inputs[4] // { // @0603 storage[0x05] // @0604 stack[-2] // @0605 memory[stack[-2]:stack[-2] + 0x20] // @0608 storage[0x06] // } 0600 5B JUMPDEST 0601 60 PUSH1 0x05 0603 54 SLOAD 0604 82 DUP3 0605 51 MLOAD 0606 60 PUSH1 0x06 0608 54 SLOAD 0609 61 PUSH2 0x0612 060C 91 SWAP2 060D 90 SWAP1 060E 61 PUSH2 0x265a 0611 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0603 stack[0] = storage[0x05] // @060C stack[1] = 0x0612 // @060D stack[2] = memory[stack[-2]:stack[-2] + 0x20] // @060D stack[3] = storage[0x06] // } // Block ends with call to 0x265a, returns to 0x0612 label_0612: // Incoming return from call to 0x265A at 0x0611 // Inputs[2] // { // @0613 stack[-1] // @0613 stack[-2] // } 0612 5B JUMPDEST 0613 11 GT 0614 15 ISZERO 0615 61 PUSH2 0x06a0 0618 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x06a0, if !(stack[-1] > stack[-2]) label_0619: // Incoming jump from 0x0618, if not !(stack[-1] > stack[-2]) // Inputs[1] { @061B memory[0x40:0x60] } 0619 60 PUSH1 0x40 061B 51 MLOAD 061C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 063D 81 DUP2 063E 52 MSTORE 063F 60 PUSH1 0x20 0641 60 PUSH1 0x04 0643 82 DUP3 0644 01 ADD 0645 52 MSTORE 0646 60 PUSH1 0x29 0648 60 PUSH1 0x24 064A 82 DUP3 064B 01 ADD 064C 52 MSTORE 064D 7F PUSH32 0x436f756e74206578636565647320746865206d6178696d756d20616c6c6f7765 066E 60 PUSH1 0x44 0670 82 DUP3 0671 01 ADD 0672 52 MSTORE 0673 7F PUSH32 0x6420737570706c792e0000000000000000000000000000000000000000000000 0694 60 PUSH1 0x64 0696 82 DUP3 0697 01 ADD 0698 52 MSTORE 0699 60 PUSH1 0x84 069B 01 ADD 069C 61 PUSH2 0x038e 069F 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @063E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0645 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @064C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0672 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x436f756e74206578636565647320746865206d6178696d756d20616c6c6f7765 // @0698 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6420737570706c792e0000000000000000000000000000000000000000000000 // @069B stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x038e label_06A0: // Incoming jump from 0x0618, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @06A4 stack[-2] // @06A5 memory[stack[-2]:stack[-2] + 0x20] // } 06A0 5B JUMPDEST 06A1 60 PUSH1 0x00 06A3 5B JUMPDEST 06A4 82 DUP3 06A5 51 MLOAD 06A6 81 DUP2 06A7 10 LT 06A8 15 ISZERO 06A9 61 PUSH2 0x071d 06AC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06A1 stack[0] = 0x00 } // Block ends with conditional jump to 0x071d, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_06AD: // Incoming jump from 0x06AC, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @06B0 stack[-3] // @06B1 stack[-1] // @06B3 memory[stack[-3]:stack[-3] + 0x20] // } 06AD 61 PUSH2 0x070b 06B0 83 DUP4 06B1 82 DUP3 06B2 81 DUP2 06B3 51 MLOAD 06B4 81 DUP2 06B5 10 LT 06B6 61 PUSH2 0x06e8 06B9 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @06AD stack[0] = 0x070b // @06B0 stack[1] = stack[-3] // @06B1 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x06e8, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_06BA: // Incoming jump from 0x06B9, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[1] { @06E7 memory[0x00:0x24] } 06BA 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 06DB 60 PUSH1 0x00 06DD 52 MSTORE 06DE 60 PUSH1 0x32 06E0 60 PUSH1 0x04 06E2 52 MSTORE 06E3 60 PUSH1 0x24 06E5 60 PUSH1 0x00 06E7 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @06DD memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @06E2 memory[0x04:0x24] = 0x32 // @06E7 revert(memory[0x00:0x24]); // } // Block terminates label_06E8: // Incoming jump from 0x06B9, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[5] // { // @06EB stack[-1] // @06EF stack[-2] // @06F0 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @06F1 stack[-5] // @06F9 memory[0x40:0x60] // } 06E8 5B JUMPDEST 06E9 60 PUSH1 0x20 06EB 02 MUL 06EC 60 PUSH1 0x20 06EE 01 ADD 06EF 01 ADD 06F0 51 MLOAD 06F1 83 DUP4 06F2 60 PUSH1 0xff 06F4 16 AND 06F5 60 PUSH1 0x01 06F7 60 PUSH1 0x40 06F9 51 MLOAD 06FA 80 DUP1 06FB 60 PUSH1 0x20 06FD 01 ADD 06FE 60 PUSH1 0x40 0700 52 MSTORE 0701 80 DUP1 0702 60 PUSH1 0x00 0704 81 DUP2 0705 52 MSTORE 0706 50 POP 0707 61 PUSH2 0x113f 070A 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @06F0 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @06F4 stack[-1] = 0xff & stack[-5] // @06F5 stack[0] = 0x01 // @06F9 stack[1] = memory[0x40:0x60] // @0700 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0705 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x113f 070B 5B JUMPDEST 070C 80 DUP1 070D 61 PUSH2 0x0715 0710 81 DUP2 0711 61 PUSH2 0x276c 0714 56 *JUMP 0715 5B JUMPDEST 0716 91 SWAP2 0717 50 POP 0718 50 POP 0719 61 PUSH2 0x06a3 071C 56 *JUMP label_071D: // Incoming jump from 0x06AC, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @071F stack[-3] // @0720 memory[stack[-3]:stack[-3] + 0x20] // @0723 storage[0x06] // } 071D 5B JUMPDEST 071E 50 POP 071F 81 DUP2 0720 51 MLOAD 0721 60 PUSH1 0x06 0723 54 SLOAD 0724 61 PUSH2 0x072d 0727 91 SWAP2 0728 90 SWAP1 0729 61 PUSH2 0x265a 072C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0727 stack[-1] = 0x072d // @0728 stack[1] = storage[0x06] // @0728 stack[0] = memory[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x265a, returns to 0x072D label_072D: // Incoming return from call to 0x265A at 0x072C // Inputs[2] // { // @0730 stack[-1] // @0733 stack[-4] // } 072D 5B JUMPDEST 072E 60 PUSH1 0x06 0730 55 SSTORE 0731 50 POP 0732 50 POP 0733 56 *JUMP // Stack delta = -4 // Outputs[1] { @0730 storage[0x06] = stack[-1] } // Block ends with unconditional jump to stack[-4] 0734 5B JUMPDEST 0735 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 074A 85 DUP6 074B 16 AND 074C 33 CALLER 074D 14 EQ 074E 80 DUP1 074F 61 PUSH2 0x075d 0752 57 *JUMPI 0753 50 POP 0754 61 PUSH2 0x075d 0757 85 DUP6 0758 33 CALLER 0759 61 PUSH2 0x0bf2 075C 56 *JUMP 075D 5B JUMPDEST 075E 61 PUSH2 0x07e9 0761 57 *JUMPI 0762 60 PUSH1 0x40 0764 51 MLOAD 0765 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0786 81 DUP2 0787 52 MSTORE 0788 60 PUSH1 0x20 078A 60 PUSH1 0x04 078C 82 DUP3 078D 01 ADD 078E 52 MSTORE 078F 60 PUSH1 0x32 0791 60 PUSH1 0x24 0793 82 DUP3 0794 01 ADD 0795 52 MSTORE 0796 7F PUSH32 0x455243313135353a207472616e736665722063616c6c6572206973206e6f7420 07B7 60 PUSH1 0x44 07B9 82 DUP3 07BA 01 ADD 07BB 52 MSTORE 07BC 7F PUSH32 0x6f776e6572206e6f7220617070726f7665640000000000000000000000000000 07DD 60 PUSH1 0x64 07DF 82 DUP3 07E0 01 ADD 07E1 52 MSTORE 07E2 60 PUSH1 0x84 07E4 01 ADD 07E5 61 PUSH2 0x038e 07E8 56 *JUMP 07E9 5B JUMPDEST 07EA 61 PUSH2 0x07f6 07ED 85 DUP6 07EE 85 DUP6 07EF 85 DUP6 07F0 85 DUP6 07F1 85 DUP6 07F2 61 PUSH2 0x12a6 07F5 56 *JUMP label_07F6: // Incoming return from call to 0x1AAF at 0x12A5 // Incoming return from call to 0x1A3D at 0x11FB // Inputs[1] { @07FC stack[-6] } 07F6 5B JUMPDEST 07F7 50 POP 07F8 50 POP 07F9 50 POP 07FA 50 POP 07FB 50 POP 07FC 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_07FD: // Incoming jump from 0x0223 // Inputs[4] // { // @0800 stack[-1] // @0801 memory[stack[-1]:stack[-1] + 0x20] // @0802 stack[-2] // @0803 memory[stack[-2]:stack[-2] + 0x20] // } 07FD 5B JUMPDEST 07FE 60 PUSH1 0x60 0800 81 DUP2 0801 51 MLOAD 0802 83 DUP4 0803 51 MLOAD 0804 14 EQ 0805 61 PUSH2 0x0890 0808 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07FE stack[0] = 0x60 } // Block ends with conditional jump to 0x0890, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] label_0809: // Incoming jump from 0x0808, if not memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @080B memory[0x40:0x60] } 0809 60 PUSH1 0x40 080B 51 MLOAD 080C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 082D 81 DUP2 082E 52 MSTORE 082F 60 PUSH1 0x20 0831 60 PUSH1 0x04 0833 82 DUP3 0834 01 ADD 0835 52 MSTORE 0836 60 PUSH1 0x29 0838 60 PUSH1 0x24 083A 82 DUP3 083B 01 ADD 083C 52 MSTORE 083D 7F PUSH32 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 085E 60 PUSH1 0x44 0860 82 DUP3 0861 01 ADD 0862 52 MSTORE 0863 7F PUSH32 0x206d69736d617463680000000000000000000000000000000000000000000000 0884 60 PUSH1 0x64 0886 82 DUP3 0887 01 ADD 0888 52 MSTORE 0889 60 PUSH1 0x84 088B 01 ADD 088C 61 PUSH2 0x038e 088F 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @082E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0835 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @083C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0862 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 // @0888 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x206d69736d617463680000000000000000000000000000000000000000000000 // @088B stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x038e label_0890: // Incoming jump from 0x0808, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[2] // { // @0893 stack[-3] // @0894 memory[stack[-3]:stack[-3] + 0x20] // } 0890 5B JUMPDEST 0891 60 PUSH1 0x00 0893 83 DUP4 0894 51 MLOAD 0895 67 PUSH8 0xffffffffffffffff 089E 81 DUP2 089F 11 GT 08A0 15 ISZERO 08A1 61 PUSH2 0x08d3 08A4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0891 stack[0] = 0x00 // @0894 stack[1] = memory[stack[-3]:stack[-3] + 0x20] // } // Block ends with conditional jump to 0x08d3, if !(memory[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_08A5: // Incoming jump from 0x08A4, if not !(memory[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @08D2 memory[0x00:0x24] } 08A5 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 08C6 60 PUSH1 0x00 08C8 52 MSTORE 08C9 60 PUSH1 0x41 08CB 60 PUSH1 0x04 08CD 52 MSTORE 08CE 60 PUSH1 0x24 08D0 60 PUSH1 0x00 08D2 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @08C8 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @08CD memory[0x04:0x24] = 0x41 // @08D2 revert(memory[0x00:0x24]); // } // Block terminates label_08D3: // Incoming jump from 0x08A4, if !(memory[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @08D6 memory[0x40:0x60] // @08D7 stack[-1] // } 08D3 5B JUMPDEST 08D4 60 PUSH1 0x40 08D6 51 MLOAD 08D7 90 SWAP1 08D8 80 DUP1 08D9 82 DUP3 08DA 52 MSTORE 08DB 80 DUP1 08DC 60 PUSH1 0x20 08DE 02 MUL 08DF 60 PUSH1 0x20 08E1 01 ADD 08E2 82 DUP3 08E3 01 ADD 08E4 60 PUSH1 0x40 08E6 52 MSTORE 08E7 80 DUP1 08E8 15 ISZERO 08E9 61 PUSH2 0x08fc 08EC 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @08D7 stack[-1] = memory[0x40:0x60] // @08D7 stack[0] = stack[-1] // @08DA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @08E6 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x08fc, if !stack[-1] label_08ED: // Incoming jump from 0x08EC, if not !stack[-1] // Inputs[7] // { // @08ED stack[-2] // @08F3 stack[-1] // @08F6 msg.data.length // @08F8 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @08FE stack[-3] // @0903 stack[-6] // @0904 memory[stack[-6]:stack[-6] + 0x20] // } 08ED 81 DUP2 08EE 60 PUSH1 0x20 08F0 01 ADD 08F1 60 PUSH1 0x20 08F3 82 DUP3 08F4 02 MUL 08F5 80 DUP1 08F6 36 CALLDATASIZE 08F7 83 DUP4 08F8 37 CALLDATACOPY 08F9 01 ADD 08FA 90 SWAP1 08FB 50 POP 08FC 5B JUMPDEST 08FD 50 POP 08FE 90 SWAP1 08FF 50 POP 0900 60 PUSH1 0x00 0902 5B JUMPDEST 0903 84 DUP5 0904 51 MLOAD 0905 81 DUP2 0906 10 LT 0907 15 ISZERO 0908 61 PUSH2 0x09e9 090B 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @08F8 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @08FE stack[-3] = stack[-2] // @0900 stack[-2] = 0x00 // } // Block ends with conditional jump to 0x09e9, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_090C: // Incoming jump from 0x090B, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x090B, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x090B, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[3] // { // @090F stack[-5] // @0910 stack[-1] // @0912 memory[stack[-5]:stack[-5] + 0x20] // } 090C 61 PUSH2 0x0995 090F 85 DUP6 0910 82 DUP3 0911 81 DUP2 0912 51 MLOAD 0913 81 DUP2 0914 10 LT 0915 61 PUSH2 0x0947 0918 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @090C stack[0] = 0x0995 // @090F stack[1] = stack[-5] // @0910 stack[2] = stack[-1] // } // Block ends with conditional call to 0x0947, returns to 0x0995, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_0919: // Incoming jump from 0x0918, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[1] { @0946 memory[0x00:0x24] } 0919 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 093A 60 PUSH1 0x00 093C 52 MSTORE 093D 60 PUSH1 0x32 093F 60 PUSH1 0x04 0941 52 MSTORE 0942 60 PUSH1 0x24 0944 60 PUSH1 0x00 0946 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @093C memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @0941 memory[0x04:0x24] = 0x32 // @0946 revert(memory[0x00:0x24]); // } // Block terminates label_0947: // Incoming call from 0x0918, returns to 0x0995, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[6] // { // @094A stack[-1] // @094E stack[-2] // @094F memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0950 stack[-7] // @0951 stack[-4] // @0953 memory[stack[-7]:stack[-7] + 0x20] // } 0947 5B JUMPDEST 0948 60 PUSH1 0x20 094A 02 MUL 094B 60 PUSH1 0x20 094D 01 ADD 094E 01 ADD 094F 51 MLOAD 0950 85 DUP6 0951 83 DUP4 0952 81 DUP2 0953 51 MLOAD 0954 81 DUP2 0955 10 LT 0956 61 PUSH2 0x0988 0959 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @094F stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0950 stack[-1] = stack[-7] // @0951 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x0988, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] label_095A: // Incoming jump from 0x0959, if not stack[-4] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[1] { @0987 memory[0x00:0x24] } 095A 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 097B 60 PUSH1 0x00 097D 52 MSTORE 097E 60 PUSH1 0x32 0980 60 PUSH1 0x04 0982 52 MSTORE 0983 60 PUSH1 0x24 0985 60 PUSH1 0x00 0987 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @097D memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @0982 memory[0x04:0x24] = 0x32 // @0987 revert(memory[0x00:0x24]); // } // Block terminates label_0988: // Incoming jump from 0x0959, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[3] // { // @098B stack[-1] // @098F stack[-2] // @0990 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 0988 5B JUMPDEST 0989 60 PUSH1 0x20 098B 02 MUL 098C 60 PUSH1 0x20 098E 01 ADD 098F 01 ADD 0990 51 MLOAD 0991 61 PUSH2 0x02ed 0994 56 *JUMP // Stack delta = -1 // Outputs[1] { @0990 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x02ed label_0995: // Incoming return from call to 0x0947 at 0x0918 // Inputs[3] // { // @0996 stack[-3] // @0997 stack[-2] // @0999 memory[stack[-3]:stack[-3] + 0x20] // } 0995 5B JUMPDEST 0996 82 DUP3 0997 82 DUP3 0998 81 DUP2 0999 51 MLOAD 099A 81 DUP2 099B 10 LT 099C 61 PUSH2 0x09ce 099F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0996 stack[0] = stack[-3] // @0997 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x09ce, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] label_09A0: // Incoming jump from 0x099F, if not stack[-2] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[1] { @09CD memory[0x00:0x24] } 09A0 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 09C1 60 PUSH1 0x00 09C3 52 MSTORE 09C4 60 PUSH1 0x32 09C6 60 PUSH1 0x04 09C8 52 MSTORE 09C9 60 PUSH1 0x24 09CB 60 PUSH1 0x00 09CD FD *REVERT // Stack delta = +0 // Outputs[3] // { // @09C3 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @09C8 memory[0x04:0x24] = 0x32 // @09CD revert(memory[0x00:0x24]); // } // Block terminates label_09CE: // Incoming jump from 0x099F, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @09D1 stack[-1] // @09D4 stack[-2] // @09D9 stack[-3] // @09DD stack[-4] // } 09CE 5B JUMPDEST 09CF 60 PUSH1 0x20 09D1 90 SWAP1 09D2 81 DUP2 09D3 02 MUL 09D4 91 SWAP2 09D5 90 SWAP1 09D6 91 SWAP2 09D7 01 ADD 09D8 01 ADD 09D9 52 MSTORE 09DA 61 PUSH2 0x09e2 09DD 81 DUP2 09DE 61 PUSH2 0x276c 09E1 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @09D9 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @09DA stack[-3] = 0x09e2 // @09DD stack[-2] = stack[-4] // } // Block ends with call to 0x276c, returns to 0x09E2 label_09E2: // Incoming return from call to 0x276C at 0x09E1 // Inputs[2] // { // @09E3 stack[-2] // @09E3 stack[-1] // } 09E2 5B JUMPDEST 09E3 90 SWAP1 09E4 50 POP 09E5 61 PUSH2 0x0902 09E8 56 *JUMP // Stack delta = -1 // Outputs[1] { @09E3 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x0902 label_09E9: // Incoming jump from 0x090B, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x090B, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x090B, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[3] // { // @09EB stack[-6] // @09EB stack[-2] // @09EC stack[-5] // } 09E9 5B JUMPDEST 09EA 50 POP 09EB 93 SWAP4 09EC 92 SWAP3 09ED 50 POP 09EE 50 POP 09EF 50 POP 09F0 56 *JUMP // Stack delta = -5 // Outputs[1] { @09EB stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_09F1: // Incoming jump from 0x0243 // Inputs[2] // { // @09F4 storage[0x03] // @0A0B msg.sender // } 09F1 5B JUMPDEST 09F2 60 PUSH1 0x03 09F4 54 SLOAD 09F5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A0A 16 AND 0A0B 33 CALLER 0A0C 14 EQ 0A0D 61 PUSH2 0x0a72 0A10 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a72, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] label_0A11: // Incoming jump from 0x0A10, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] // Inputs[1] { @0A13 memory[0x40:0x60] } 0A11 60 PUSH1 0x40 0A13 51 MLOAD 0A14 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0A35 81 DUP2 0A36 52 MSTORE 0A37 60 PUSH1 0x20 0A39 60 PUSH1 0x04 0A3B 82 DUP3 0A3C 01 ADD 0A3D 81 DUP2 0A3E 90 SWAP1 0A3F 52 MSTORE 0A40 60 PUSH1 0x24 0A42 82 DUP3 0A43 01 ADD 0A44 52 MSTORE 0A45 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0A66 60 PUSH1 0x44 0A68 82 DUP3 0A69 01 ADD 0A6A 52 MSTORE 0A6B 60 PUSH1 0x64 0A6D 01 ADD 0A6E 61 PUSH2 0x038e 0A71 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A36 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0A3F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A44 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0A6A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0A6D stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x038e label_0A72: // Incoming jump from 0x0A10, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] // Inputs[1] { @0A76 stack[-1] } 0A72 5B JUMPDEST 0A73 61 PUSH2 0x0a7b 0A76 81 DUP2 0A77 61 PUSH2 0x162e 0A7A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0A73 stack[0] = 0x0a7b // @0A76 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x162e label_0A7B: // Incoming return from call to 0x1641 at 0x0F2A // Incoming jump from 0x2923, if stack[-1] == stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Incoming jump from 0x2951, if stack[-1] == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0A7D stack[-2] } 0A7B 5B JUMPDEST 0A7C 50 POP 0A7D 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0A7E: // Incoming call from 0x0254, returns to 0x01F4 // Inputs[2] // { // @0A81 storage[0x03] // @0A98 msg.sender // } 0A7E 5B JUMPDEST 0A7F 60 PUSH1 0x03 0A81 54 SLOAD 0A82 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A97 16 AND 0A98 33 CALLER 0A99 14 EQ 0A9A 61 PUSH2 0x0aff 0A9D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0aff, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] label_0A9E: // Incoming jump from 0x0A9D, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] // Inputs[1] { @0AA0 memory[0x40:0x60] } 0A9E 60 PUSH1 0x40 0AA0 51 MLOAD 0AA1 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0AC2 81 DUP2 0AC3 52 MSTORE 0AC4 60 PUSH1 0x20 0AC6 60 PUSH1 0x04 0AC8 82 DUP3 0AC9 01 ADD 0ACA 81 DUP2 0ACB 90 SWAP1 0ACC 52 MSTORE 0ACD 60 PUSH1 0x24 0ACF 82 DUP3 0AD0 01 ADD 0AD1 52 MSTORE 0AD2 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0AF3 60 PUSH1 0x44 0AF5 82 DUP3 0AF6 01 ADD 0AF7 52 MSTORE 0AF8 60 PUSH1 0x64 0AFA 01 ADD 0AFB 61 PUSH2 0x038e 0AFE 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0AC3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0ACC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0AD1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0AF7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0AFA stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x038e label_0AFF: // Incoming jump from 0x0A9D, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] 0AFF 5B JUMPDEST 0B00 61 PUSH2 0x0b09 0B03 60 PUSH1 0x00 0B05 61 PUSH2 0x1641 0B08 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B00 stack[0] = 0x0b09 // @0B03 stack[1] = 0x00 // } // Block ends with call to 0x1641, returns to 0x0B09 label_0B09: // Incoming return from call to 0x1641 at 0x0B08 // Inputs[1] { @0B0A stack[-1] } 0B09 5B JUMPDEST 0B0A 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0B0B: // Incoming call from 0x0284, returns to 0x01C1 // Inputs[1] { @0B0F storage[0x08] } 0B0B 5B JUMPDEST 0B0C 60 PUSH1 0x08 0B0E 80 DUP1 0B0F 54 SLOAD 0B10 61 PUSH2 0x04bd 0B13 90 SWAP1 0B14 61 PUSH2 0x26cd 0B17 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B0C stack[0] = 0x08 // @0B13 stack[1] = 0x04bd // @0B13 stack[2] = storage[0x08] // } // Block ends with call to 0x26cd, returns to 0x04BD label_0B18: // Incoming jump from 0x0297 // Inputs[3] // { // @0B1C msg.sender // @0B1D stack[-2] // @0B1E stack[-1] // } 0B18 5B JUMPDEST 0B19 61 PUSH2 0x0b23 0B1C 33 CALLER 0B1D 83 DUP4 0B1E 83 DUP4 0B1F 61 PUSH2 0x16b8 0B22 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B19 stack[0] = 0x0b23 // @0B1C stack[1] = msg.sender // @0B1D stack[2] = stack[-2] // @0B1E stack[3] = stack[-1] // } // Block ends with call to 0x16b8, returns to 0x0B23 label_0B23: // Incoming return from call to 0x16B8 at 0x0B22 // Inputs[1] { @0B26 stack[-3] } 0B23 5B JUMPDEST 0B24 50 POP 0B25 50 POP 0B26 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0B27: // Incoming jump from 0x02B3 // Inputs[2] // { // @0B2A storage[0x03] // @0B41 msg.sender // } 0B27 5B JUMPDEST 0B28 60 PUSH1 0x03 0B2A 54 SLOAD 0B2B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B40 16 AND 0B41 33 CALLER 0B42 14 EQ 0B43 61 PUSH2 0x0ba8 0B46 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ba8, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] label_0B47: // Incoming jump from 0x0B46, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] // Inputs[1] { @0B49 memory[0x40:0x60] } 0B47 60 PUSH1 0x40 0B49 51 MLOAD 0B4A 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0B6B 81 DUP2 0B6C 52 MSTORE 0B6D 60 PUSH1 0x20 0B6F 60 PUSH1 0x04 0B71 82 DUP3 0B72 01 ADD 0B73 81 DUP2 0B74 90 SWAP1 0B75 52 MSTORE 0B76 60 PUSH1 0x24 0B78 82 DUP3 0B79 01 ADD 0B7A 52 MSTORE 0B7B 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0B9C 60 PUSH1 0x44 0B9E 82 DUP3 0B9F 01 ADD 0BA0 52 MSTORE 0BA1 60 PUSH1 0x64 0BA3 01 ADD 0BA4 61 PUSH2 0x038e 0BA7 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0B6C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0B75 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B7A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0BA0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0BA3 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x038e label_0BA8: // Incoming jump from 0x0B46, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] // Inputs[3] // { // @0BAC storage[0x04] // @0BAD stack[-1] // @0BF1 stack[-2] // } 0BA8 5B JUMPDEST 0BA9 60 PUSH1 0x04 0BAB 80 DUP1 0BAC 54 SLOAD 0BAD 91 SWAP2 0BAE 15 ISZERO 0BAF 15 ISZERO 0BB0 74 PUSH21 0x010000000000000000000000000000000000000000 0BC6 02 MUL 0BC7 7F PUSH32 0xffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff 0BE8 90 SWAP1 0BE9 92 SWAP3 0BEA 16 AND 0BEB 91 SWAP2 0BEC 90 SWAP1 0BED 91 SWAP2 0BEE 17 OR 0BEF 90 SWAP1 0BF0 55 SSTORE 0BF1 56 *JUMP // Stack delta = -2 // Outputs[1] { @0BF0 storage[0x04] = (storage[0x04] & 0xffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff) | 0x010000000000000000000000000000000000000000 * !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_0BF2: // Incoming jump from 0x02C6 // Inputs[1] { @0BF5 storage[0x04] } 0BF2 5B JUMPDEST 0BF3 60 PUSH1 0x04 0BF5 54 SLOAD 0BF6 60 PUSH1 0x00 0BF8 90 SWAP1 0BF9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C0E 81 DUP2 0C0F 16 AND 0C10 90 SWAP1 0C11 74 PUSH21 0x010000000000000000000000000000000000000000 0C27 90 SWAP1 0C28 04 DIV 0C29 60 PUSH1 0xff 0C2B 16 AND 0C2C 80 DUP1 0C2D 15 ISZERO 0C2E 61 PUSH2 0x0cee 0C31 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0BF8 stack[0] = 0x00 // @0C10 stack[1] = storage[0x04] & 0xffffffffffffffffffffffffffffffffffffffff // @0C2B stack[2] = 0xff & storage[0x04] / 0x010000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x0cee, if !(0xff & storage[0x04] / 0x010000000000000000000000000000000000000000) label_0C32: // Incoming jump from 0x0C31, if not !(0xff & storage[0x04] / 0x010000000000000000000000000000000000000000) // Inputs[6] // { // @0C35 memory[0x40:0x60] // @0C6E stack[-5] // @0C77 stack[-4] // @0C7B stack[-2] // @0C8B memory[0x40:0x60] // @0C92 address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 0C32 50 POP 0C33 60 PUSH1 0x40 0C35 51 MLOAD 0C36 7F PUSH32 0xc455279100000000000000000000000000000000000000000000000000000000 0C57 81 DUP2 0C58 52 MSTORE 0C59 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C6E 85 DUP6 0C6F 81 DUP2 0C70 16 AND 0C71 60 PUSH1 0x04 0C73 83 DUP4 0C74 01 ADD 0C75 52 MSTORE 0C76 80 DUP1 0C77 85 DUP6 0C78 16 AND 0C79 91 SWAP2 0C7A 90 SWAP1 0C7B 83 DUP4 0C7C 16 AND 0C7D 90 SWAP1 0C7E 63 PUSH4 0xc4552791 0C83 90 SWAP1 0C84 60 PUSH1 0x24 0C86 01 ADD 0C87 60 PUSH1 0x20 0C89 60 PUSH1 0x40 0C8B 51 MLOAD 0C8C 80 DUP1 0C8D 83 DUP4 0C8E 03 SUB 0C8F 81 DUP2 0C90 86 DUP7 0C91 80 DUP1 0C92 3B EXTCODESIZE 0C93 15 ISZERO 0C94 80 DUP1 0C95 15 ISZERO 0C96 61 PUSH2 0x0c9e 0C99 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @0C58 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xc455279100000000000000000000000000000000000000000000000000000000 // @0C75 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0C79 stack[-1] = stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // @0C7D stack[0] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @0C83 stack[1] = 0xc4552791 // @0C86 stack[2] = 0x24 + memory[0x40:0x60] // @0C87 stack[3] = 0x20 // @0C8B stack[4] = memory[0x40:0x60] // @0C8E stack[5] = (0x24 + memory[0x40:0x60]) - memory[0x40:0x60] // @0C8F stack[6] = memory[0x40:0x60] // @0C90 stack[7] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @0C93 stack[8] = !address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x0c9e, if !!address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_0C9A: // Incoming jump from 0x0C99, if not !!address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @0C9D memory[0x00:0x00] } 0C9A 60 PUSH1 0x00 0C9C 80 DUP1 0C9D FD *REVERT // Stack delta = +0 // Outputs[1] { @0C9D revert(memory[0x00:0x00]); } // Block terminates label_0C9E: // Incoming jump from 0x0C99, if !!address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[8] // { // @0CA0 msg.gas // @0CA1 memory[stack[-3]:stack[-3] + stack[-4]] // @0CA1 stack[-6] // @0CA1 stack[-3] // @0CA1 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0CA1 stack[-2] // @0CA1 stack[-5] // @0CA1 stack[-4] // } 0C9E 5B JUMPDEST 0C9F 50 POP 0CA0 5A GAS 0CA1 FA STATICCALL 0CA2 15 ISZERO 0CA3 80 DUP1 0CA4 15 ISZERO 0CA5 61 PUSH2 0x0cb2 0CA8 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0CA1 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0CA2 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0cb2, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0CA9: // Incoming jump from 0x0CA8, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0CA9 returndata.length // @0CAD returndata[0x00:0x00 + returndata.length] // @0CAE returndata.length // @0CB1 memory[0x00:0x00 + returndata.length] // } 0CA9 3D RETURNDATASIZE 0CAA 60 PUSH1 0x00 0CAC 80 DUP1 0CAD 3E RETURNDATACOPY 0CAE 3D RETURNDATASIZE 0CAF 60 PUSH1 0x00 0CB1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0CAD memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0CB1 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0CB2: // Incoming jump from 0x0CA8, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0CB9 memory[0x40:0x60] // @0CBA returndata.length // } 0CB2 5B JUMPDEST 0CB3 50 POP 0CB4 50 POP 0CB5 50 POP 0CB6 50 POP 0CB7 60 PUSH1 0x40 0CB9 51 MLOAD 0CBA 3D RETURNDATASIZE 0CBB 60 PUSH1 0x1f 0CBD 19 NOT 0CBE 60 PUSH1 0x1f 0CC0 82 DUP3 0CC1 01 ADD 0CC2 16 AND 0CC3 82 DUP3 0CC4 01 ADD 0CC5 80 DUP1 0CC6 60 PUSH1 0x40 0CC8 52 MSTORE 0CC9 50 POP 0CCA 81 DUP2 0CCB 01 ADD 0CCC 90 SWAP1 0CCD 61 PUSH2 0x0cd6 0CD0 91 SWAP2 0CD1 90 SWAP1 0CD2 61 PUSH2 0x23fa 0CD5 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0CC8 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0CD0 stack[-4] = 0x0cd6 // @0CD1 stack[-2] = memory[0x40:0x60] // @0CD1 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x23fa 0CD6 5B JUMPDEST 0CD7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CEC 16 AND 0CED 14 EQ label_0CEE: // Incoming jump from 0x0C31, if !(0xff & storage[0x04] / 0x010000000000000000000000000000000000000000) // Inputs[1] { @0CEF stack[-1] } 0CEE 5B JUMPDEST 0CEF 15 ISZERO 0CF0 61 PUSH2 0x0cfd 0CF3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0cfd, if !stack[-1] label_0CF4: // Incoming jump from 0x0CF3, if not !stack[-1] // Inputs[1] { @0CF6 stack[-2] } 0CF4 60 PUSH1 0x01 0CF6 91 SWAP2 0CF7 50 POP 0CF8 50 POP 0CF9 61 PUSH2 0x03c7 0CFC 56 *JUMP // Stack delta = -1 // Outputs[1] { @0CF6 stack[-2] = 0x01 } // Block ends with unconditional jump to 0x03c7 label_0CFD: // Incoming jump from 0x0CF3, if !stack[-1] // Inputs[5] // { // @0D14 stack[-4] // @0D26 memory[0x00:0x40] // @0D28 stack[-3] // @0D2F memory[0x00:0x40] // @0D30 storage[keccak256(memory[0x00:0x40])] // } 0CFD 5B JUMPDEST 0CFE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D13 80 DUP1 0D14 85 DUP6 0D15 16 AND 0D16 60 PUSH1 0x00 0D18 90 SWAP1 0D19 81 DUP2 0D1A 52 MSTORE 0D1B 60 PUSH1 0x01 0D1D 60 PUSH1 0x20 0D1F 90 SWAP1 0D20 81 DUP2 0D21 52 MSTORE 0D22 60 PUSH1 0x40 0D24 80 DUP1 0D25 83 DUP4 0D26 20 SHA3 0D27 93 SWAP4 0D28 87 DUP8 0D29 16 AND 0D2A 83 DUP4 0D2B 52 MSTORE 0D2C 92 SWAP3 0D2D 90 SWAP1 0D2E 52 MSTORE 0D2F 20 SHA3 0D30 54 SLOAD 0D31 60 PUSH1 0xff 0D33 16 AND // Stack delta = +1 // Outputs[5] // { // @0D1A memory[0x00:0x20] = stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // @0D21 memory[0x20:0x40] = 0x01 // @0D2B memory[0x00:0x20] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @0D2E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0D33 stack[0] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block continues label_0D34: // Incoming jump from 0x109F, if !stack[-7] // Incoming return from call to 0x1F9E at 0x245B // Incoming jump from 0x109F, if !stack[-5] // Incoming jump from 0x109F, if !stack[-7] // Incoming jump from 0x0D33 // Inputs[3] // { // @0D35 stack[-1] // @0D35 stack[-6] // @0D36 stack[-5] // } 0D34 5B JUMPDEST 0D35 94 SWAP5 0D36 93 SWAP4 0D37 50 POP 0D38 50 POP 0D39 50 POP 0D3A 50 POP 0D3B 56 *JUMP // Stack delta = -5 // Outputs[1] { @0D35 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] 0D3C 5B JUMPDEST 0D3D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D52 85 DUP6 0D53 16 AND 0D54 33 CALLER 0D55 14 EQ 0D56 80 DUP1 0D57 61 PUSH2 0x0d65 0D5A 57 *JUMPI 0D5B 50 POP 0D5C 61 PUSH2 0x0d65 0D5F 85 DUP6 0D60 33 CALLER 0D61 61 PUSH2 0x0bf2 0D64 56 *JUMP 0D65 5B JUMPDEST 0D66 61 PUSH2 0x0df1 0D69 57 *JUMPI 0D6A 60 PUSH1 0x40 0D6C 51 MLOAD 0D6D 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0D8E 81 DUP2 0D8F 52 MSTORE 0D90 60 PUSH1 0x20 0D92 60 PUSH1 0x04 0D94 82 DUP3 0D95 01 ADD 0D96 52 MSTORE 0D97 60 PUSH1 0x29 0D99 60 PUSH1 0x24 0D9B 82 DUP3 0D9C 01 ADD 0D9D 52 MSTORE 0D9E 7F PUSH32 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72 0DBF 60 PUSH1 0x44 0DC1 82 DUP3 0DC2 01 ADD 0DC3 52 MSTORE 0DC4 7F PUSH32 0x20617070726f7665640000000000000000000000000000000000000000000000 0DE5 60 PUSH1 0x64 0DE7 82 DUP3 0DE8 01 ADD 0DE9 52 MSTORE 0DEA 60 PUSH1 0x84 0DEC 01 ADD 0DED 61 PUSH2 0x038e 0DF0 56 *JUMP 0DF1 5B JUMPDEST 0DF2 61 PUSH2 0x07f6 0DF5 85 DUP6 0DF6 85 DUP6 0DF7 85 DUP6 0DF8 85 DUP6 0DF9 85 DUP6 0DFA 61 PUSH2 0x180c 0DFD 56 *JUMP label_0DFE: // Incoming jump from 0x02EC // Inputs[2] // { // @0E01 storage[0x03] // @0E18 msg.sender // } 0DFE 5B JUMPDEST 0DFF 60 PUSH1 0x03 0E01 54 SLOAD 0E02 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E17 16 AND 0E18 33 CALLER 0E19 14 EQ 0E1A 61 PUSH2 0x0e7f 0E1D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e7f, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] label_0E1E: // Incoming jump from 0x0E1D, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] // Inputs[1] { @0E20 memory[0x40:0x60] } 0E1E 60 PUSH1 0x40 0E20 51 MLOAD 0E21 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0E42 81 DUP2 0E43 52 MSTORE 0E44 60 PUSH1 0x20 0E46 60 PUSH1 0x04 0E48 82 DUP3 0E49 01 ADD 0E4A 81 DUP2 0E4B 90 SWAP1 0E4C 52 MSTORE 0E4D 60 PUSH1 0x24 0E4F 82 DUP3 0E50 01 ADD 0E51 52 MSTORE 0E52 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0E73 60 PUSH1 0x44 0E75 82 DUP3 0E76 01 ADD 0E77 52 MSTORE 0E78 60 PUSH1 0x64 0E7A 01 ADD 0E7B 61 PUSH2 0x038e 0E7E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0E43 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0E4C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E51 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0E77 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0E7A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x038e label_0E7F: // Incoming jump from 0x0E1D, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x03] // Inputs[1] { @0E95 stack[-1] } 0E7F 5B JUMPDEST 0E80 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E95 81 DUP2 0E96 16 AND 0E97 61 PUSH2 0x0f22 0E9A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f22, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff label_0E9B: // Incoming jump from 0x0E9A, if not stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @0E9D memory[0x40:0x60] } 0E9B 60 PUSH1 0x40 0E9D 51 MLOAD 0E9E 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0EBF 81 DUP2 0EC0 52 MSTORE 0EC1 60 PUSH1 0x20 0EC3 60 PUSH1 0x04 0EC5 82 DUP3 0EC6 01 ADD 0EC7 52 MSTORE 0EC8 60 PUSH1 0x26 0ECA 60 PUSH1 0x24 0ECC 82 DUP3 0ECD 01 ADD 0ECE 52 MSTORE 0ECF 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 0EF0 60 PUSH1 0x44 0EF2 82 DUP3 0EF3 01 ADD 0EF4 52 MSTORE 0EF5 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 0F16 60 PUSH1 0x64 0F18 82 DUP3 0F19 01 ADD 0F1A 52 MSTORE 0F1B 60 PUSH1 0x84 0F1D 01 ADD 0F1E 61 PUSH2 0x038e 0F21 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0EC0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0EC7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0ECE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0EF4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @0F1A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // @0F1D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x038e label_0F22: // Incoming jump from 0x0E9A, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @0F26 stack[-1] } 0F22 5B JUMPDEST 0F23 61 PUSH2 0x0a7b 0F26 81 DUP2 0F27 61 PUSH2 0x1641 0F2A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0F23 stack[0] = 0x0a7b // @0F26 stack[1] = stack[-1] // } // Block ends with call to 0x1641, returns to 0x0A7B label_0F2B: // Incoming call from 0x054A, returns to 0x054B // Inputs[1] { @0F31 storage[0x02] } 0F2B 5B JUMPDEST 0F2C 60 PUSH1 0x60 0F2E 60 PUSH1 0x02 0F30 80 DUP1 0F31 54 SLOAD 0F32 61 PUSH2 0x0f3a 0F35 90 SWAP1 0F36 61 PUSH2 0x26cd 0F39 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F2C stack[0] = 0x60 // @0F2E stack[1] = 0x02 // @0F35 stack[2] = 0x0f3a // @0F35 stack[3] = storage[0x02] // } // Block ends with call to 0x26cd, returns to 0x0F3A label_0F3A: // Incoming return from call to 0x26CD at 0x0F39 // Inputs[4] // { // @0F3B stack[-1] // @0F4A memory[0x40:0x60] // @0F52 stack[-2] // @0F5D storage[stack[-2]] // } 0F3A 5B JUMPDEST 0F3B 80 DUP1 0F3C 60 PUSH1 0x1f 0F3E 01 ADD 0F3F 60 PUSH1 0x20 0F41 80 DUP1 0F42 91 SWAP2 0F43 04 DIV 0F44 02 MUL 0F45 60 PUSH1 0x20 0F47 01 ADD 0F48 60 PUSH1 0x40 0F4A 51 MLOAD 0F4B 90 SWAP1 0F4C 81 DUP2 0F4D 01 ADD 0F4E 60 PUSH1 0x40 0F50 52 MSTORE 0F51 80 DUP1 0F52 92 SWAP3 0F53 91 SWAP2 0F54 90 SWAP1 0F55 81 DUP2 0F56 81 DUP2 0F57 52 MSTORE 0F58 60 PUSH1 0x20 0F5A 01 ADD 0F5B 82 DUP3 0F5C 80 DUP1 0F5D 54 SLOAD 0F5E 61 PUSH2 0x0f66 0F61 90 SWAP1 0F62 61 PUSH2 0x26cd 0F65 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0F50 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0F52 stack[-2] = memory[0x40:0x60] // @0F53 stack[-1] = stack[-2] // @0F54 stack[0] = stack[-1] // @0F57 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0F5A stack[1] = 0x20 + memory[0x40:0x60] // @0F5B stack[2] = stack[-2] // @0F61 stack[4] = storage[stack[-2]] // @0F61 stack[3] = 0x0f66 // } // Block ends with call to 0x26cd, returns to 0x0F66 label_0F66: // Incoming return from call to 0x26CD at 0x0F65 // Inputs[1] { @0F67 stack[-1] } 0F66 5B JUMPDEST 0F67 80 DUP1 0F68 15 ISZERO 0F69 61 PUSH2 0x0fb3 0F6C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fb3, if !stack[-1] label_0F6D: // Incoming jump from 0x0F6C, if not !stack[-1] // Inputs[1] { @0F6D stack[-1] } 0F6D 80 DUP1 0F6E 60 PUSH1 0x1f 0F70 10 LT 0F71 61 PUSH2 0x0f88 0F74 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f88, if 0x1f < stack[-1] label_0F75: // Incoming jump from 0x0F74, if not 0x1f < stack[-1] // Inputs[4] // { // @0F79 stack[-2] // @0F7A storage[stack[-2]] // @0F7D stack[-3] // @0F7F stack[-1] // } 0F75 61 PUSH2 0x0100 0F78 80 DUP1 0F79 83 DUP4 0F7A 54 SLOAD 0F7B 04 DIV 0F7C 02 MUL 0F7D 83 DUP4 0F7E 52 MSTORE 0F7F 91 SWAP2 0F80 60 PUSH1 0x20 0F82 01 ADD 0F83 91 SWAP2 0F84 61 PUSH2 0x0fb3 0F87 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0F7E memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0F83 stack[-1] = stack[-1] // @0F83 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0fb3 label_0F88: // Incoming jump from 0x0F74, if 0x1f < stack[-1] // Inputs[5] // { // @0F89 stack[-3] // @0F8A stack[-1] // @0F8C stack[-2] // @0F94 memory[0x00:0x20] // @0F98 storage[keccak256(memory[0x00:0x20])] // } 0F88 5B JUMPDEST 0F89 82 DUP3 0F8A 01 ADD 0F8B 91 SWAP2 0F8C 90 SWAP1 0F8D 60 PUSH1 0x00 0F8F 52 MSTORE 0F90 60 PUSH1 0x20 0F92 60 PUSH1 0x00 0F94 20 SHA3 0F95 90 SWAP1 0F96 5B JUMPDEST 0F97 81 DUP2 0F98 54 SLOAD 0F99 81 DUP2 0F9A 52 MSTORE 0F9B 90 SWAP1 0F9C 60 PUSH1 0x01 0F9E 01 ADD 0F9F 90 SWAP1 0FA0 60 PUSH1 0x20 0FA2 01 ADD 0FA3 80 DUP1 0FA4 83 DUP4 0FA5 11 GT 0FA6 61 PUSH2 0x0f96 0FA9 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0F8B stack[-3] = stack[-3] + stack[-1] // @0F8F memory[0x00:0x20] = stack[-2] // @0F9A memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0F9F stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0FA2 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0f96, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0FAA: // Incoming jump from 0x0FA9, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0FA9, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0FAA stack[-3] // @0FAB stack[-1] // } 0FAA 82 DUP3 0FAB 90 SWAP1 0FAC 03 SUB 0FAD 60 PUSH1 0x1f 0FAF 16 AND 0FB0 82 DUP3 0FB1 01 ADD 0FB2 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0FB2 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0FB2 stack[-1] = stack[-3] // } // Block continues label_0FB3: // Incoming jump from 0x0F6C, if !stack[-1] // Incoming jump from 0x0FB2 // Incoming jump from 0x0F87 // Inputs[4] // { // @0FB9 stack[-6] // @0FB9 stack[-7] // @0FBB stack[-9] // @0FBC stack[-8] // } 0FB3 5B JUMPDEST 0FB4 50 POP 0FB5 50 POP 0FB6 50 POP 0FB7 50 POP 0FB8 50 POP 0FB9 90 SWAP1 0FBA 50 POP 0FBB 91 SWAP2 0FBC 90 SWAP1 0FBD 50 POP 0FBE 56 *JUMP // Stack delta = -8 // Outputs[1] { @0FBB stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_0FBF: // Incoming call from 0x0556, returns to 0x0557 // Inputs[1] { @0FC2 stack[-1] } 0FBF 5B JUMPDEST 0FC0 60 PUSH1 0x60 0FC2 81 DUP2 0FC3 61 PUSH2 0x0fff 0FC6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0FC0 stack[0] = 0x60 } // Block ends with conditional jump to 0x0fff, if stack[-1] label_0FC7: // Incoming jump from 0x0FC6, if not stack[-1] // Inputs[2] // { // @0FCC memory[0x40:0x60] // @0FFD stack[-3] // } 0FC7 50 POP 0FC8 50 POP 0FC9 60 PUSH1 0x40 0FCB 80 DUP1 0FCC 51 MLOAD 0FCD 80 DUP1 0FCE 82 DUP3 0FCF 01 ADD 0FD0 90 SWAP1 0FD1 91 SWAP2 0FD2 52 MSTORE 0FD3 60 PUSH1 0x01 0FD5 81 DUP2 0FD6 52 MSTORE 0FD7 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 0FF8 60 PUSH1 0x20 0FFA 82 DUP3 0FFB 01 ADD 0FFC 52 MSTORE 0FFD 90 SWAP1 0FFE 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @0FD2 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0FD6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @0FFC memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x3000000000000000000000000000000000000000000000000000000000000000 // @0FFD stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_0FFF: // Incoming jump from 0x0FC6, if stack[-1] // Inputs[1] { @1000 stack[-2] } 0FFF 5B JUMPDEST 1000 81 DUP2 1001 60 PUSH1 0x00 1003 5B JUMPDEST 1004 81 DUP2 1005 15 ISZERO 1006 61 PUSH2 0x1029 1009 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1000 stack[0] = stack[-2] // @1001 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1029, if !stack[-2] label_100A: // Incoming jump from 0x1009, if not !stack[-2] // Incoming jump from 0x1009, if not !stack[-2] // Inputs[1] { @100A stack[-1] } 100A 80 DUP1 100B 61 PUSH2 0x1013 100E 81 DUP2 100F 61 PUSH2 0x276c 1012 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @100A stack[0] = stack[-1] // @100B stack[1] = 0x1013 // @100E stack[2] = stack[-1] // } // Block ends with call to 0x276c, returns to 0x1013 label_1013: // Incoming return from call to 0x276C at 0x1012 // Inputs[4] // { // @1014 stack[-3] // @1014 stack[-1] // @1019 stack[-2] // @101D stack[-4] // } 1013 5B JUMPDEST 1014 91 SWAP2 1015 50 POP 1016 61 PUSH2 0x1022 1019 90 SWAP1 101A 50 POP 101B 60 PUSH1 0x0a 101D 83 DUP4 101E 61 PUSH2 0x2672 1021 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1014 stack[-3] = stack[-1] // @1019 stack[-2] = 0x1022 // @101B stack[-1] = 0x0a // @101D stack[0] = stack[-4] // } // Block ends with call to 0x2672, returns to 0x1022 label_1022: // Incoming return from call to 0x2672 at 0x1021 // Inputs[2] // { // @1023 stack[-1] // @1023 stack[-3] // } 1022 5B JUMPDEST 1023 91 SWAP2 1024 50 POP 1025 61 PUSH2 0x1003 1028 56 *JUMP // Stack delta = -1 // Outputs[1] { @1023 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1003 label_1029: // Incoming jump from 0x1009, if !stack[-2] // Incoming jump from 0x1009, if !stack[-2] // Inputs[1] { @102C stack[-1] } 1029 5B JUMPDEST 102A 60 PUSH1 0x00 102C 81 DUP2 102D 67 PUSH8 0xffffffffffffffff 1036 81 DUP2 1037 11 GT 1038 15 ISZERO 1039 61 PUSH2 0x106b 103C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @102A stack[0] = 0x00 // @102C stack[1] = stack[-1] // } // Block ends with conditional jump to 0x106b, if !(stack[-1] > 0xffffffffffffffff) label_103D: // Incoming jump from 0x103C, if not !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @106A memory[0x00:0x24] } 103D 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 105E 60 PUSH1 0x00 1060 52 MSTORE 1061 60 PUSH1 0x41 1063 60 PUSH1 0x04 1065 52 MSTORE 1066 60 PUSH1 0x24 1068 60 PUSH1 0x00 106A FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1060 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @1065 memory[0x04:0x24] = 0x41 // @106A revert(memory[0x00:0x24]); // } // Block terminates label_106B: // Incoming jump from 0x103C, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @106E memory[0x40:0x60] // @106F stack[-1] // } 106B 5B JUMPDEST 106C 60 PUSH1 0x40 106E 51 MLOAD 106F 90 SWAP1 1070 80 DUP1 1071 82 DUP3 1072 52 MSTORE 1073 80 DUP1 1074 60 PUSH1 0x1f 1076 01 ADD 1077 60 PUSH1 0x1f 1079 19 NOT 107A 16 AND 107B 60 PUSH1 0x20 107D 01 ADD 107E 82 DUP3 107F 01 ADD 1080 60 PUSH1 0x40 1082 52 MSTORE 1083 80 DUP1 1084 15 ISZERO 1085 61 PUSH2 0x1095 1088 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @106F stack[-1] = memory[0x40:0x60] // @106F stack[0] = stack[-1] // @1072 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1082 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x1095, if !stack[-1] label_1089: // Incoming jump from 0x1088, if not !stack[-1] // Inputs[6] // { // @108B stack[-2] // @108D stack[-1] // @108F msg.data.length // @1091 msg.data[msg.data.length:msg.data.length + stack[-1]] // @1097 stack[-3] // @109A stack[-7] // } 1089 60 PUSH1 0x20 108B 82 DUP3 108C 01 ADD 108D 81 DUP2 108E 80 DUP1 108F 36 CALLDATASIZE 1090 83 DUP4 1091 37 CALLDATACOPY 1092 01 ADD 1093 90 SWAP1 1094 50 POP 1095 5B JUMPDEST 1096 50 POP 1097 90 SWAP1 1098 50 POP 1099 5B JUMPDEST 109A 84 DUP5 109B 15 ISZERO 109C 61 PUSH2 0x0d34 109F 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1091 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @1097 stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x0d34, if !stack[-7] label_10A0: // Incoming jump from 0x109F, if not !stack[-7] // Incoming jump from 0x109F, if not !stack[-5] // Incoming jump from 0x109F, if not !stack[-7] // Inputs[1] { @10A5 stack[-2] } 10A0 61 PUSH2 0x10aa 10A3 60 PUSH1 0x01 10A5 83 DUP4 10A6 61 PUSH2 0x2686 10A9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10A0 stack[0] = 0x10aa // @10A3 stack[1] = 0x01 // @10A5 stack[2] = stack[-2] // } // Block ends with call to 0x2686, returns to 0x10AA label_10AA: // Incoming return from call to 0x2686 at 0x10A9 // Inputs[3] // { // @10AB stack[-3] // @10AB stack[-1] // @10B2 stack[-6] // } 10AA 5B JUMPDEST 10AB 91 SWAP2 10AC 50 POP 10AD 61 PUSH2 0x10b7 10B0 60 PUSH1 0x0a 10B2 86 DUP7 10B3 61 PUSH2 0x27a5 10B6 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @10AB stack[-3] = stack[-1] // @10AD stack[-1] = 0x10b7 // @10B0 stack[0] = 0x0a // @10B2 stack[1] = stack[-6] // } // Block ends with call to 0x27a5, returns to 0x10B7 label_10B7: // Incoming return from call to 0x27A5 at 0x10B6 // Inputs[1] { @10BB stack[-1] } 10B7 5B JUMPDEST 10B8 61 PUSH2 0x10c2 10BB 90 SWAP1 10BC 60 PUSH1 0x30 10BE 61 PUSH2 0x265a 10C1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @10BB stack[0] = stack[-1] // @10BB stack[-1] = 0x10c2 // @10BC stack[1] = 0x30 // } // Block ends with call to 0x265a, returns to 0x10C2 label_10C2: // Incoming return from call to 0x265A at 0x10C1 // Inputs[4] // { // @10C5 stack[-1] // @10C6 stack[-2] // @10C7 stack[-3] // @10C9 memory[stack[-2]:stack[-2] + 0x20] // } 10C2 5B JUMPDEST 10C3 60 PUSH1 0xf8 10C5 1B SHL 10C6 81 DUP2 10C7 83 DUP4 10C8 81 DUP2 10C9 51 MLOAD 10CA 81 DUP2 10CB 10 LT 10CC 61 PUSH2 0x10fe 10CF 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @10C5 stack[-1] = stack[-1] << 0xf8 // @10C6 stack[0] = stack[-2] // @10C7 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x10fe, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_10D0: // Incoming jump from 0x10CF, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @10FD memory[0x00:0x24] } 10D0 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 10F1 60 PUSH1 0x00 10F3 52 MSTORE 10F4 60 PUSH1 0x32 10F6 60 PUSH1 0x04 10F8 52 MSTORE 10F9 60 PUSH1 0x24 10FB 60 PUSH1 0x00 10FD FD *REVERT // Stack delta = +0 // Outputs[3] // { // @10F3 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @10F8 memory[0x04:0x24] = 0x32 // @10FD revert(memory[0x00:0x24]); // } // Block terminates label_10FE: // Incoming jump from 0x10CF, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @1101 stack[-1] // @1102 stack[-2] // @1103 stack[-3] // @1133 stack[-8] // } 10FE 5B JUMPDEST 10FF 60 PUSH1 0x20 1101 01 ADD 1102 01 ADD 1103 90 SWAP1 1104 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1124 19 NOT 1125 16 AND 1126 90 SWAP1 1127 81 DUP2 1128 60 PUSH1 0x00 112A 1A BYTE 112B 90 SWAP1 112C 53 MSTORE8 112D 50 POP 112E 61 PUSH2 0x1138 1131 60 PUSH1 0x0a 1133 86 DUP7 1134 61 PUSH2 0x2672 1137 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @112C memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @112E stack[-3] = 0x1138 // @1131 stack[-2] = 0x0a // @1133 stack[-1] = stack[-8] // } // Block ends with call to 0x2672, returns to 0x1138 label_1138: // Incoming return from call to 0x2672 at 0x1137 // Inputs[2] // { // @1139 stack[-1] // @1139 stack[-6] // } 1138 5B JUMPDEST 1139 94 SWAP5 113A 50 POP 113B 61 PUSH2 0x1099 113E 56 *JUMP // Stack delta = -1 // Outputs[1] { @1139 stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x1099 label_113F: // Incoming jump from 0x070A // Inputs[1] { @1155 stack[-4] } 113F 5B JUMPDEST 1140 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1155 84 DUP5 1156 16 AND 1157 61 PUSH2 0x11e2 115A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11e2, if stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff label_115B: // Incoming jump from 0x115A, if not stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @115D memory[0x40:0x60] } 115B 60 PUSH1 0x40 115D 51 MLOAD 115E 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 117F 81 DUP2 1180 52 MSTORE 1181 60 PUSH1 0x20 1183 60 PUSH1 0x04 1185 82 DUP3 1186 01 ADD 1187 52 MSTORE 1188 60 PUSH1 0x21 118A 60 PUSH1 0x24 118C 82 DUP3 118D 01 ADD 118E 52 MSTORE 118F 7F PUSH32 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 11B0 60 PUSH1 0x44 11B2 82 DUP3 11B3 01 ADD 11B4 52 MSTORE 11B5 7F PUSH32 0x7300000000000000000000000000000000000000000000000000000000000000 11D6 60 PUSH1 0x64 11D8 82 DUP3 11D9 01 ADD 11DA 52 MSTORE 11DB 60 PUSH1 0x84 11DD 01 ADD 11DE 61 PUSH2 0x038e 11E1 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1180 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1187 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @118E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @11B4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 // @11DA memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7300000000000000000000000000000000000000000000000000000000000000 // @11DD stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x038e label_11E2: // Incoming jump from 0x115A, if stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[3] // { // @11E3 msg.sender // @11EA stack[-4] // @11EE stack[-3] // } 11E2 5B JUMPDEST 11E3 33 CALLER 11E4 61 PUSH2 0x11fc 11E7 81 DUP2 11E8 60 PUSH1 0x00 11EA 87 DUP8 11EB 61 PUSH2 0x11f3 11EE 88 DUP9 11EF 61 PUSH2 0x1a3d 11F2 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @11E3 stack[0] = msg.sender // @11E4 stack[1] = 0x11fc // @11E7 stack[2] = msg.sender // @11E8 stack[3] = 0x00 // @11EA stack[4] = stack[-4] // @11EB stack[5] = 0x11f3 // @11EE stack[6] = stack[-3] // } // Block ends with call to 0x1a3d, returns to 0x11F3 label_11F3: // Incoming return from call to 0x1A3D at 0x11F2 // Inputs[1] { @11F7 stack[-8] } 11F3 5B JUMPDEST 11F4 61 PUSH2 0x07f6 11F7 88 DUP9 11F8 61 PUSH2 0x1a3d 11FB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @11F4 stack[0] = 0x07f6 // @11F7 stack[1] = stack[-8] // } // Block ends with call to 0x1a3d, returns to 0x07F6 label_11FC: // Incoming return from call to 0x11F3 at 0x11F2 // Inputs[6] // { // @11FF stack[-4] // @120B memory[0x00:0x40] // @1221 stack[-5] // @1229 memory[0x00:0x40] // @122B storage[keccak256(memory[0x00:0x40])] // @122C stack[-3] // } 11FC 5B JUMPDEST 11FD 60 PUSH1 0x00 11FF 84 DUP5 1200 81 DUP2 1201 52 MSTORE 1202 60 PUSH1 0x20 1204 81 DUP2 1205 81 DUP2 1206 52 MSTORE 1207 60 PUSH1 0x40 1209 80 DUP1 120A 83 DUP4 120B 20 SHA3 120C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1221 89 DUP10 1222 16 AND 1223 84 DUP5 1224 52 MSTORE 1225 90 SWAP1 1226 91 SWAP2 1227 52 MSTORE 1228 81 DUP2 1229 20 SHA3 122A 80 DUP1 122B 54 SLOAD 122C 85 DUP6 122D 92 SWAP3 122E 90 SWAP1 122F 61 PUSH2 0x1239 1232 90 SWAP1 1233 84 DUP5 1234 90 SWAP1 1235 61 PUSH2 0x265a 1238 56 *JUMP // Stack delta = +6 // Outputs[10] // { // @1201 memory[0x00:0x20] = stack[-4] // @1206 memory[0x20:0x40] = 0x00 // @1224 memory[0x00:0x20] = stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff // @1227 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1229 stack[1] = keccak256(memory[0x00:0x40]) // @122D stack[0] = stack[-3] // @122E stack[2] = 0x00 // @1232 stack[3] = 0x1239 // @1234 stack[4] = stack[-3] // @1234 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x265a, returns to 0x1239 label_1239: // Incoming return from call to 0x265A at 0x1238 // Inputs[11] // { // @123A stack[-2] // @123A stack[-1] // @123B stack[-3] // @1242 memory[0x40:0x60] // @1243 stack[-8] // @124A stack[-7] // @1263 stack[-9] // @126A stack[-5] // @1292 memory[0x40:0x60] // @1297 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]] // @12A1 stack[-6] // } 1239 5B JUMPDEST 123A 90 SWAP1 123B 91 SWAP2 123C 55 SSTORE 123D 50 POP 123E 50 POP 123F 60 PUSH1 0x40 1241 80 DUP1 1242 51 MLOAD 1243 85 DUP6 1244 81 DUP2 1245 52 MSTORE 1246 60 PUSH1 0x20 1248 81 DUP2 1249 01 ADD 124A 85 DUP6 124B 90 SWAP1 124C 52 MSTORE 124D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1262 80 DUP1 1263 88 DUP9 1264 16 AND 1265 92 SWAP3 1266 60 PUSH1 0x00 1268 92 SWAP3 1269 91 SWAP2 126A 85 DUP6 126B 16 AND 126C 91 SWAP2 126D 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 128E 91 SWAP2 128F 01 ADD 1290 60 PUSH1 0x40 1292 51 MLOAD 1293 80 DUP1 1294 91 SWAP2 1295 03 SUB 1296 90 SWAP1 1297 A4 LOG4 1298 61 PUSH2 0x07f6 129B 81 DUP2 129C 60 PUSH1 0x00 129E 87 DUP8 129F 87 DUP8 12A0 87 DUP8 12A1 87 DUP8 12A2 61 PUSH2 0x1aaf 12A5 56 *JUMP // Stack delta = +3 // Outputs[11] // { // @123C storage[stack[-3]] = stack[-1] // @1245 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-8] // @124C memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-7] // @1297 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62, stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff, 0x00, stack[-9] & 0xffffffffffffffffffffffffffffffffffffffff]); // @1298 stack[-4] = 0x07f6 // @129B stack[-3] = stack[-5] // @129C stack[-2] = 0x00 // @129E stack[-1] = stack[-9] // @129F stack[0] = stack[-8] // @12A0 stack[1] = stack[-7] // @12A1 stack[2] = stack[-6] // } // Block ends with call to 0x1aaf, returns to 0x07F6 12A6 5B JUMPDEST 12A7 81 DUP2 12A8 51 MLOAD 12A9 83 DUP4 12AA 51 MLOAD 12AB 14 EQ 12AC 61 PUSH2 0x1337 12AF 57 *JUMPI 12B0 60 PUSH1 0x40 12B2 51 MLOAD 12B3 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 12D4 81 DUP2 12D5 52 MSTORE 12D6 60 PUSH1 0x20 12D8 60 PUSH1 0x04 12DA 82 DUP3 12DB 01 ADD 12DC 52 MSTORE 12DD 60 PUSH1 0x28 12DF 60 PUSH1 0x24 12E1 82 DUP3 12E2 01 ADD 12E3 52 MSTORE 12E4 7F PUSH32 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 1305 60 PUSH1 0x44 1307 82 DUP3 1308 01 ADD 1309 52 MSTORE 130A 7F PUSH32 0x6d69736d61746368000000000000000000000000000000000000000000000000 132B 60 PUSH1 0x64 132D 82 DUP3 132E 01 ADD 132F 52 MSTORE 1330 60 PUSH1 0x84 1332 01 ADD 1333 61 PUSH2 0x038e 1336 56 *JUMP 1337 5B JUMPDEST 1338 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 134D 84 DUP5 134E 16 AND 134F 61 PUSH2 0x13da 1352 57 *JUMPI 1353 60 PUSH1 0x40 1355 51 MLOAD 1356 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1377 81 DUP2 1378 52 MSTORE 1379 60 PUSH1 0x20 137B 60 PUSH1 0x04 137D 82 DUP3 137E 01 ADD 137F 52 MSTORE 1380 60 PUSH1 0x25 1382 60 PUSH1 0x24 1384 82 DUP3 1385 01 ADD 1386 52 MSTORE 1387 7F PUSH32 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 13A8 60 PUSH1 0x44 13AA 82 DUP3 13AB 01 ADD 13AC 52 MSTORE 13AD 7F PUSH32 0x6472657373000000000000000000000000000000000000000000000000000000 13CE 60 PUSH1 0x64 13D0 82 DUP3 13D1 01 ADD 13D2 52 MSTORE 13D3 60 PUSH1 0x84 13D5 01 ADD 13D6 61 PUSH2 0x038e 13D9 56 *JUMP 13DA 5B JUMPDEST 13DB 33 CALLER 13DC 60 PUSH1 0x00 13DE 5B JUMPDEST 13DF 84 DUP5 13E0 51 MLOAD 13E1 81 DUP2 13E2 10 LT 13E3 15 ISZERO 13E4 61 PUSH2 0x1599 13E7 57 *JUMPI 13E8 60 PUSH1 0x00 13EA 85 DUP6 13EB 82 DUP3 13EC 81 DUP2 13ED 51 MLOAD 13EE 81 DUP2 13EF 10 LT 13F0 61 PUSH2 0x1422 13F3 57 *JUMPI 13F4 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 1415 60 PUSH1 0x00 1417 52 MSTORE 1418 60 PUSH1 0x32 141A 60 PUSH1 0x04 141C 52 MSTORE 141D 60 PUSH1 0x24 141F 60 PUSH1 0x00 1421 FD *REVERT 1422 5B JUMPDEST 1423 60 PUSH1 0x20 1425 02 MUL 1426 60 PUSH1 0x20 1428 01 ADD 1429 01 ADD 142A 51 MLOAD 142B 90 SWAP1 142C 50 POP 142D 60 PUSH1 0x00 142F 85 DUP6 1430 83 DUP4 1431 81 DUP2 1432 51 MLOAD 1433 81 DUP2 1434 10 LT 1435 61 PUSH2 0x1467 1438 57 *JUMPI 1439 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 145A 60 PUSH1 0x00 145C 52 MSTORE 145D 60 PUSH1 0x32 145F 60 PUSH1 0x04 1461 52 MSTORE 1462 60 PUSH1 0x24 1464 60 PUSH1 0x00 1466 FD *REVERT 1467 5B JUMPDEST 1468 60 PUSH1 0x20 146A 90 SWAP1 146B 81 DUP2 146C 02 MUL 146D 91 SWAP2 146E 90 SWAP1 146F 91 SWAP2 1470 01 ADD 1471 81 DUP2 1472 01 ADD 1473 51 MLOAD 1474 60 PUSH1 0x00 1476 84 DUP5 1477 81 DUP2 1478 52 MSTORE 1479 80 DUP1 147A 83 DUP4 147B 52 MSTORE 147C 60 PUSH1 0x40 147E 80 DUP1 147F 82 DUP3 1480 20 SHA3 1481 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1496 8E DUP15 1497 16 AND 1498 83 DUP4 1499 52 MSTORE 149A 90 SWAP1 149B 93 SWAP4 149C 52 MSTORE 149D 91 SWAP2 149E 90 SWAP1 149F 91 SWAP2 14A0 20 SHA3 14A1 54 SLOAD 14A2 90 SWAP1 14A3 91 SWAP2 14A4 50 POP 14A5 81 DUP2 14A6 81 DUP2 14A7 10 LT 14A8 15 ISZERO 14A9 61 PUSH2 0x1534 14AC 57 *JUMPI 14AD 60 PUSH1 0x40 14AF 51 MLOAD 14B0 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 14D1 81 DUP2 14D2 52 MSTORE 14D3 60 PUSH1 0x20 14D5 60 PUSH1 0x04 14D7 82 DUP3 14D8 01 ADD 14D9 52 MSTORE 14DA 60 PUSH1 0x2a 14DC 60 PUSH1 0x24 14DE 82 DUP3 14DF 01 ADD 14E0 52 MSTORE 14E1 7F PUSH32 0x455243313135353a20696e73756666696369656e742062616c616e636520666f 1502 60 PUSH1 0x44 1504 82 DUP3 1505 01 ADD 1506 52 MSTORE 1507 7F PUSH32 0x72207472616e7366657200000000000000000000000000000000000000000000 1528 60 PUSH1 0x64 152A 82 DUP3 152B 01 ADD 152C 52 MSTORE 152D 60 PUSH1 0x84 152F 01 ADD 1530 61 PUSH2 0x038e 1533 56 *JUMP 1534 5B JUMPDEST 1535 60 PUSH1 0x00 1537 83 DUP4 1538 81 DUP2 1539 52 MSTORE 153A 60 PUSH1 0x20 153C 81 DUP2 153D 81 DUP2 153E 52 MSTORE 153F 60 PUSH1 0x40 1541 80 DUP1 1542 83 DUP4 1543 20 SHA3 1544 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1559 8E DUP15 155A 81 DUP2 155B 16 AND 155C 85 DUP6 155D 52 MSTORE 155E 92 SWAP3 155F 52 MSTORE 1560 80 DUP1 1561 83 DUP4 1562 20 SHA3 1563 85 DUP6 1564 85 DUP6 1565 03 SUB 1566 90 SWAP1 1567 55 SSTORE 1568 90 SWAP1 1569 8B DUP12 156A 16 AND 156B 82 DUP3 156C 52 MSTORE 156D 81 DUP2 156E 20 SHA3 156F 80 DUP1 1570 54 SLOAD 1571 84 DUP5 1572 92 SWAP3 1573 90 SWAP1 1574 61 PUSH2 0x157e 1577 90 SWAP1 1578 84 DUP5 1579 90 SWAP1 157A 61 PUSH2 0x265a 157D 56 *JUMP 157E 5B JUMPDEST 157F 92 SWAP3 1580 50 POP 1581 50 POP 1582 81 DUP2 1583 90 SWAP1 1584 55 SSTORE 1585 50 POP 1586 50 POP 1587 50 POP 1588 50 POP 1589 80 DUP1 158A 61 PUSH2 0x1592 158D 90 SWAP1 158E 61 PUSH2 0x276c 1591 56 *JUMP 1592 5B JUMPDEST 1593 90 SWAP1 1594 50 POP 1595 61 PUSH2 0x13de 1598 56 *JUMP 1599 5B JUMPDEST 159A 50 POP 159B 84 DUP5 159C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15B1 16 AND 15B2 86 DUP7 15B3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15C8 16 AND 15C9 82 DUP3 15CA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15DF 16 AND 15E0 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 1601 87 DUP8 1602 87 DUP8 1603 60 PUSH1 0x40 1605 51 MLOAD 1606 61 PUSH2 0x1610 1609 92 SWAP3 160A 91 SWAP2 160B 90 SWAP1 160C 61 PUSH2 0x25f5 160F 56 *JUMP 1610 5B JUMPDEST 1611 60 PUSH1 0x40 1613 51 MLOAD 1614 80 DUP1 1615 91 SWAP2 1616 03 SUB 1617 90 SWAP1 1618 A4 LOG4 1619 61 PUSH2 0x1626 161C 81 DUP2 161D 87 DUP8 161E 87 DUP8 161F 87 DUP8 1620 87 DUP8 1621 87 DUP8 1622 61 PUSH2 0x1d49 1625 56 *JUMP label_1626: // Incoming jump from 0x1ACC, if !address(stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @162D stack[-7] } 1626 5B JUMPDEST 1627 50 POP 1628 50 POP 1629 50 POP 162A 50 POP 162B 50 POP 162C 50 POP 162D 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_162E: // Incoming jump from 0x0A7A // Inputs[2] // { // @162F stack[-1] // @1630 memory[stack[-1]:stack[-1] + 0x20] // } 162E 5B JUMPDEST 162F 80 DUP1 1630 51 MLOAD 1631 61 PUSH2 0x0b23 1634 90 SWAP1 1635 60 PUSH1 0x02 1637 90 SWAP1 1638 60 PUSH1 0x20 163A 84 DUP5 163B 01 ADD 163C 90 SWAP1 163D 61 PUSH2 0x1f05 1640 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1634 stack[0] = 0x0b23 // @1637 stack[1] = 0x02 // @163C stack[2] = stack[-1] + 0x20 // @163C stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1f05 label_1641: // Incoming call from 0x0F2A, returns to 0x0A7B // Incoming call from 0x0B08, returns to 0x0B09 // Inputs[5] // { // @1645 storage[0x03] // @165B stack[-1] // @1688 memory[0x40:0x60] // @16B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @16B7 stack[-2] // } 1641 5B JUMPDEST 1642 60 PUSH1 0x03 1644 80 DUP1 1645 54 SLOAD 1646 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 165B 83 DUP4 165C 81 DUP2 165D 16 AND 165E 7F PUSH32 0xffffffffffffffffffffffff0000000000000000000000000000000000000000 167F 83 DUP4 1680 16 AND 1681 81 DUP2 1682 17 OR 1683 90 SWAP1 1684 93 SWAP4 1685 55 SSTORE 1686 60 PUSH1 0x40 1688 51 MLOAD 1689 91 SWAP2 168A 16 AND 168B 91 SWAP2 168C 90 SWAP1 168D 82 DUP3 168E 90 SWAP1 168F 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 16B0 90 SWAP1 16B1 60 PUSH1 0x00 16B3 90 SWAP1 16B4 A3 LOG3 16B5 50 POP 16B6 50 POP 16B7 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1685 storage[0x03] = (stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[0x03] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000) // @16B4 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x03] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-2] label_16B8: // Incoming call from 0x0B22, returns to 0x0B23 // Inputs[2] // { // @16B9 stack[-2] // @16D0 stack[-3] // } 16B8 5B JUMPDEST 16B9 81 DUP2 16BA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16CF 16 AND 16D0 83 DUP4 16D1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16E6 16 AND 16E7 14 EQ 16E8 15 ISZERO 16E9 61 PUSH2 0x1774 16EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1774, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) label_16ED: // Incoming jump from 0x16EC, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) // Inputs[1] { @16EF memory[0x40:0x60] } 16ED 60 PUSH1 0x40 16EF 51 MLOAD 16F0 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1711 81 DUP2 1712 52 MSTORE 1713 60 PUSH1 0x20 1715 60 PUSH1 0x04 1717 82 DUP3 1718 01 ADD 1719 52 MSTORE 171A 60 PUSH1 0x29 171C 60 PUSH1 0x24 171E 82 DUP3 171F 01 ADD 1720 52 MSTORE 1721 7F PUSH32 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 1742 60 PUSH1 0x44 1744 82 DUP3 1745 01 ADD 1746 52 MSTORE 1747 7F PUSH32 0x20666f722073656c660000000000000000000000000000000000000000000000 1768 60 PUSH1 0x64 176A 82 DUP3 176B 01 ADD 176C 52 MSTORE 176D 60 PUSH1 0x84 176F 01 ADD 1770 61 PUSH2 0x038e 1773 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1712 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1719 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1720 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @1746 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 // @176C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x20666f722073656c660000000000000000000000000000000000000000000000 // @176F stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x038e label_1774: // Incoming jump from 0x16EC, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) // Inputs[10] // { // @178A stack[-3] // @179D memory[0x00:0x40] // @179F stack[-2] // @17AA memory[0x00:0x40] // @17AC storage[keccak256(memory[0x00:0x40])] // @17CF stack[-1] // @17D9 memory[0x40:0x60] // @1802 memory[0x40:0x60] // @1807 memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x20) - memory[0x40:0x60]] // @180B stack[-4] // } 1774 5B JUMPDEST 1775 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 178A 83 DUP4 178B 81 DUP2 178C 16 AND 178D 60 PUSH1 0x00 178F 81 DUP2 1790 81 DUP2 1791 52 MSTORE 1792 60 PUSH1 0x01 1794 60 PUSH1 0x20 1796 90 SWAP1 1797 81 DUP2 1798 52 MSTORE 1799 60 PUSH1 0x40 179B 80 DUP1 179C 83 DUP4 179D 20 SHA3 179E 94 SWAP5 179F 87 DUP8 17A0 16 AND 17A1 80 DUP1 17A2 84 DUP5 17A3 52 MSTORE 17A4 94 SWAP5 17A5 82 DUP3 17A6 52 MSTORE 17A7 91 SWAP2 17A8 82 DUP3 17A9 90 SWAP1 17AA 20 SHA3 17AB 80 DUP1 17AC 54 SLOAD 17AD 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 17CE 16 AND 17CF 86 DUP7 17D0 15 ISZERO 17D1 15 ISZERO 17D2 90 SWAP1 17D3 81 DUP2 17D4 17 OR 17D5 90 SWAP1 17D6 91 SWAP2 17D7 55 SSTORE 17D8 91 SWAP2 17D9 51 MLOAD 17DA 91 SWAP2 17DB 82 DUP3 17DC 52 MSTORE 17DD 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 17FE 91 SWAP2 17FF 01 ADD 1800 60 PUSH1 0x40 1802 51 MLOAD 1803 80 DUP1 1804 91 SWAP2 1805 03 SUB 1806 90 SWAP1 1807 A3 LOG3 1808 50 POP 1809 50 POP 180A 50 POP 180B 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @1791 memory[0x00:0x20] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @1798 memory[0x20:0x40] = 0x01 // @17A3 memory[0x00:0x20] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @17A6 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @17D7 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & storage[keccak256(memory[0x00:0x40])]) // @17DC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @1807 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x20) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-4] 180C 5B JUMPDEST 180D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1822 84 DUP5 1823 16 AND 1824 61 PUSH2 0x18af 1827 57 *JUMPI 1828 60 PUSH1 0x40 182A 51 MLOAD 182B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 184C 81 DUP2 184D 52 MSTORE 184E 60 PUSH1 0x20 1850 60 PUSH1 0x04 1852 82 DUP3 1853 01 ADD 1854 52 MSTORE 1855 60 PUSH1 0x25 1857 60 PUSH1 0x24 1859 82 DUP3 185A 01 ADD 185B 52 MSTORE 185C 7F PUSH32 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 187D 60 PUSH1 0x44 187F 82 DUP3 1880 01 ADD 1881 52 MSTORE 1882 7F PUSH32 0x6472657373000000000000000000000000000000000000000000000000000000 18A3 60 PUSH1 0x64 18A5 82 DUP3 18A6 01 ADD 18A7 52 MSTORE 18A8 60 PUSH1 0x84 18AA 01 ADD 18AB 61 PUSH2 0x038e 18AE 56 *JUMP 18AF 5B JUMPDEST 18B0 33 CALLER 18B1 61 PUSH2 0x18bf 18B4 81 DUP2 18B5 87 DUP8 18B6 87 DUP8 18B7 61 PUSH2 0x11f3 18BA 88 DUP9 18BB 61 PUSH2 0x1a3d 18BE 56 *JUMP 18BF 5B JUMPDEST 18C0 60 PUSH1 0x00 18C2 84 DUP5 18C3 81 DUP2 18C4 52 MSTORE 18C5 60 PUSH1 0x20 18C7 81 DUP2 18C8 81 DUP2 18C9 52 MSTORE 18CA 60 PUSH1 0x40 18CC 80 DUP1 18CD 83 DUP4 18CE 20 SHA3 18CF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18E4 8A DUP11 18E5 16 AND 18E6 84 DUP5 18E7 52 MSTORE 18E8 90 SWAP1 18E9 91 SWAP2 18EA 52 MSTORE 18EB 90 SWAP1 18EC 20 SHA3 18ED 54 SLOAD 18EE 83 DUP4 18EF 81 DUP2 18F0 10 LT 18F1 15 ISZERO 18F2 61 PUSH2 0x197d 18F5 57 *JUMPI 18F6 60 PUSH1 0x40 18F8 51 MLOAD 18F9 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 191A 81 DUP2 191B 52 MSTORE 191C 60 PUSH1 0x20 191E 60 PUSH1 0x04 1920 82 DUP3 1921 01 ADD 1922 52 MSTORE 1923 60 PUSH1 0x2a 1925 60 PUSH1 0x24 1927 82 DUP3 1928 01 ADD 1929 52 MSTORE 192A 7F PUSH32 0x455243313135353a20696e73756666696369656e742062616c616e636520666f 194B 60 PUSH1 0x44 194D 82 DUP3 194E 01 ADD 194F 52 MSTORE 1950 7F PUSH32 0x72207472616e7366657200000000000000000000000000000000000000000000 1971 60 PUSH1 0x64 1973 82 DUP3 1974 01 ADD 1975 52 MSTORE 1976 60 PUSH1 0x84 1978 01 ADD 1979 61 PUSH2 0x038e 197C 56 *JUMP 197D 5B JUMPDEST 197E 60 PUSH1 0x00 1980 85 DUP6 1981 81 DUP2 1982 52 MSTORE 1983 60 PUSH1 0x20 1985 81 DUP2 1986 81 DUP2 1987 52 MSTORE 1988 60 PUSH1 0x40 198A 80 DUP1 198B 83 DUP4 198C 20 SHA3 198D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19A2 8B DUP12 19A3 81 DUP2 19A4 16 AND 19A5 85 DUP6 19A6 52 MSTORE 19A7 92 SWAP3 19A8 52 MSTORE 19A9 80 DUP1 19AA 83 DUP4 19AB 20 SHA3 19AC 87 DUP8 19AD 85 DUP6 19AE 03 SUB 19AF 90 SWAP1 19B0 55 SSTORE 19B1 90 SWAP1 19B2 88 DUP9 19B3 16 AND 19B4 82 DUP3 19B5 52 MSTORE 19B6 81 DUP2 19B7 20 SHA3 19B8 80 DUP1 19B9 54 SLOAD 19BA 86 DUP7 19BB 92 SWAP3 19BC 90 SWAP1 19BD 61 PUSH2 0x19c7 19C0 90 SWAP1 19C1 84 DUP5 19C2 90 SWAP1 19C3 61 PUSH2 0x265a 19C6 56 *JUMP 19C7 5B JUMPDEST 19C8 90 SWAP1 19C9 91 SWAP2 19CA 55 SSTORE 19CB 50 POP 19CC 50 POP 19CD 60 PUSH1 0x40 19CF 80 DUP1 19D0 51 MLOAD 19D1 86 DUP7 19D2 81 DUP2 19D3 52 MSTORE 19D4 60 PUSH1 0x20 19D6 81 DUP2 19D7 01 ADD 19D8 86 DUP7 19D9 90 SWAP1 19DA 52 MSTORE 19DB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19F0 80 DUP1 19F1 89 DUP10 19F2 16 AND 19F3 92 SWAP3 19F4 8A DUP11 19F5 82 DUP3 19F6 16 AND 19F7 92 SWAP3 19F8 91 SWAP2 19F9 86 DUP7 19FA 16 AND 19FB 91 SWAP2 19FC 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 1A1D 91 SWAP2 1A1E 01 ADD 1A1F 60 PUSH1 0x40 1A21 51 MLOAD 1A22 80 DUP1 1A23 91 SWAP2 1A24 03 SUB 1A25 90 SWAP1 1A26 A4 LOG4 1A27 61 PUSH2 0x1a34 1A2A 82 DUP3 1A2B 88 DUP9 1A2C 88 DUP9 1A2D 88 DUP9 1A2E 88 DUP9 1A2F 88 DUP9 1A30 61 PUSH2 0x1aaf 1A33 56 *JUMP label_1A34: // Incoming jump from 0x1CC1, if 0xf23a6e6100000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @1A3C stack[-8] } 1A34 5B JUMPDEST 1A35 50 POP 1A36 50 POP 1A37 50 POP 1A38 50 POP 1A39 50 POP 1A3A 50 POP 1A3B 50 POP 1A3C 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] label_1A3D: // Incoming call from 0x11F2, returns to 0x11F3 // Incoming call from 0x11FB, returns to 0x07F6 // Inputs[5] // { // @1A41 memory[0x40:0x60] // @1A5B msg.data.length // @1A5D msg.data[msg.data.length:msg.data.length + 0x20] // @1A64 stack[-1] // @1A69 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 1A3D 5B JUMPDEST 1A3E 60 PUSH1 0x40 1A40 80 DUP1 1A41 51 MLOAD 1A42 60 PUSH1 0x01 1A44 80 DUP1 1A45 82 DUP3 1A46 52 MSTORE 1A47 81 DUP2 1A48 83 DUP4 1A49 01 ADD 1A4A 90 SWAP1 1A4B 92 SWAP3 1A4C 52 MSTORE 1A4D 60 PUSH1 0x60 1A4F 91 SWAP2 1A50 60 PUSH1 0x00 1A52 91 SWAP2 1A53 90 SWAP1 1A54 60 PUSH1 0x20 1A56 80 DUP1 1A57 83 DUP4 1A58 01 ADD 1A59 90 SWAP1 1A5A 80 DUP1 1A5B 36 CALLDATASIZE 1A5C 83 DUP4 1A5D 37 CALLDATACOPY 1A5E 01 ADD 1A5F 90 SWAP1 1A60 50 POP 1A61 50 POP 1A62 90 SWAP1 1A63 50 POP 1A64 82 DUP3 1A65 81 DUP2 1A66 60 PUSH1 0x00 1A68 81 DUP2 1A69 51 MLOAD 1A6A 81 DUP2 1A6B 10 LT 1A6C 61 PUSH2 0x1a9e 1A6F 57 *JUMPI // Stack delta = +5 // Outputs[8] // { // @1A46 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @1A4C memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1A4F stack[0] = 0x60 // @1A5D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = msg.data[msg.data.length:msg.data.length + 0x20] // @1A62 stack[1] = memory[0x40:0x60] // @1A64 stack[2] = stack[-1] // @1A65 stack[3] = memory[0x40:0x60] // @1A66 stack[4] = 0x00 // } // Block ends with conditional jump to 0x1a9e, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] label_1A70: // Incoming jump from 0x1A6F, if not 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Inputs[1] { @1A9D memory[0x00:0x24] } 1A70 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 1A91 60 PUSH1 0x00 1A93 52 MSTORE 1A94 60 PUSH1 0x32 1A96 60 PUSH1 0x04 1A98 52 MSTORE 1A99 60 PUSH1 0x24 1A9B 60 PUSH1 0x00 1A9D FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1A93 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @1A98 memory[0x04:0x24] = 0x32 // @1A9D revert(memory[0x00:0x24]); // } // Block terminates label_1A9E: // Incoming jump from 0x1A6F, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Inputs[6] // { // @1AA1 stack[-1] // @1AA4 stack[-2] // @1AA9 stack[-3] // @1AAA stack[-7] // @1AAA stack[-4] // @1AAB stack[-6] // } 1A9E 5B JUMPDEST 1A9F 60 PUSH1 0x20 1AA1 90 SWAP1 1AA2 81 DUP2 1AA3 02 MUL 1AA4 91 SWAP2 1AA5 90 SWAP1 1AA6 91 SWAP2 1AA7 01 ADD 1AA8 01 ADD 1AA9 52 MSTORE 1AAA 92 SWAP3 1AAB 91 SWAP2 1AAC 50 POP 1AAD 50 POP 1AAE 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @1AA9 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @1AAA stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1AAF: // Incoming call from 0x12A5, returns to 0x07F6 // Inputs[2] // { // @1AC5 stack[-4] // @1AC7 address(stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 1AAF 5B JUMPDEST 1AB0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AC5 84 DUP5 1AC6 16 AND 1AC7 3B EXTCODESIZE 1AC8 15 ISZERO 1AC9 61 PUSH2 0x1626 1ACC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1626, if !address(stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_1ACD: // Incoming jump from 0x1ACC, if not !address(stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[7] // { // @1ACF memory[0x40:0x60] // @1B08 stack[-4] // @1B15 stack[-6] // @1B17 stack[-5] // @1B19 stack[-3] // @1B1B stack[-2] // @1B1D stack[-1] // } 1ACD 60 PUSH1 0x40 1ACF 51 MLOAD 1AD0 7F PUSH32 0xf23a6e6100000000000000000000000000000000000000000000000000000000 1AF1 81 DUP2 1AF2 52 MSTORE 1AF3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B08 85 DUP6 1B09 16 AND 1B0A 90 SWAP1 1B0B 63 PUSH4 0xf23a6e61 1B10 90 SWAP1 1B11 61 PUSH2 0x1b26 1B14 90 SWAP1 1B15 89 DUP10 1B16 90 SWAP1 1B17 89 DUP10 1B18 90 SWAP1 1B19 88 DUP9 1B1A 90 SWAP1 1B1B 88 DUP9 1B1C 90 SWAP1 1B1D 88 DUP9 1B1E 90 SWAP1 1B1F 60 PUSH1 0x04 1B21 01 ADD 1B22 61 PUSH2 0x2592 1B25 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @1AF2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xf23a6e6100000000000000000000000000000000000000000000000000000000 // @1B0A stack[0] = stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // @1B10 stack[1] = 0xf23a6e61 // @1B14 stack[2] = 0x1b26 // @1B16 stack[3] = stack[-6] // @1B18 stack[4] = stack[-5] // @1B1A stack[5] = stack[-3] // @1B1C stack[6] = stack[-2] // @1B1E stack[7] = stack[-1] // @1B21 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2592, returns to 0x1B26 label_1B26: // Incoming return from call to 0x2592 at 0x1B25 // Inputs[4] // { // @1B2B memory[0x40:0x60] // @1B2D stack[-1] // @1B32 stack[-3] // @1B34 address(stack[-3]).code.length // } 1B26 5B JUMPDEST 1B27 60 PUSH1 0x20 1B29 60 PUSH1 0x40 1B2B 51 MLOAD 1B2C 80 DUP1 1B2D 83 DUP4 1B2E 03 SUB 1B2F 81 DUP2 1B30 60 PUSH1 0x00 1B32 87 DUP8 1B33 80 DUP1 1B34 3B EXTCODESIZE 1B35 15 ISZERO 1B36 80 DUP1 1B37 15 ISZERO 1B38 61 PUSH2 0x1b40 1B3B 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @1B27 stack[0] = 0x20 // @1B2B stack[1] = memory[0x40:0x60] // @1B2E stack[2] = stack[-1] - memory[0x40:0x60] // @1B2F stack[3] = memory[0x40:0x60] // @1B30 stack[4] = 0x00 // @1B32 stack[5] = stack[-3] // @1B35 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1b40, if !!address(stack[-3]).code.length label_1B3C: // Incoming jump from 0x1B3B, if not !!address(stack[-3]).code.length // Inputs[1] { @1B3F memory[0x00:0x00] } 1B3C 60 PUSH1 0x00 1B3E 80 DUP1 1B3F FD *REVERT // Stack delta = +0 // Outputs[1] { @1B3F revert(memory[0x00:0x00]); } // Block terminates label_1B40: // Incoming jump from 0x1B3B, if !!address(stack[-3]).code.length // Inputs[10] // { // @1B42 msg.gas // @1B43 stack[-6] // @1B43 stack[-4] // @1B43 stack[-7] // @1B43 stack[-3] // @1B43 stack[-5] // @1B43 memory[stack[-4]:stack[-4] + stack[-5]] // @1B43 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1B43 stack[-2] // @1B44 stack[-10] // } 1B40 5B JUMPDEST 1B41 50 POP 1B42 5A GAS 1B43 F1 CALL 1B44 92 SWAP3 1B45 50 POP 1B46 50 POP 1B47 50 POP 1B48 80 DUP1 1B49 15 ISZERO 1B4A 61 PUSH2 0x1b8e 1B4D 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @1B43 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1B44 stack[-10] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1b8e, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1B4E: // Incoming jump from 0x1B4D, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1B52 memory[0x40:0x60] // @1B55 returndata.length // } 1B4E 50 POP 1B4F 60 PUSH1 0x40 1B51 80 DUP1 1B52 51 MLOAD 1B53 60 PUSH1 0x1f 1B55 3D RETURNDATASIZE 1B56 90 SWAP1 1B57 81 DUP2 1B58 01 ADD 1B59 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 1B7A 16 AND 1B7B 82 DUP3 1B7C 01 ADD 1B7D 90 SWAP1 1B7E 92 SWAP3 1B7F 52 MSTORE 1B80 61 PUSH2 0x1b8b 1B83 91 SWAP2 1B84 81 DUP2 1B85 01 ADD 1B86 90 SWAP1 1B87 61 PUSH2 0x23de 1B8A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1B7F memory[0x40:0x60] = memory[0x40:0x60] + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & returndata.length + 0x1f) // @1B83 stack[-1] = 0x1b8b // @1B86 stack[1] = memory[0x40:0x60] // @1B86 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x23de 1B8B 5B JUMPDEST 1B8C 60 PUSH1 0x01 label_1B8E: // Incoming jump from 0x1B4D, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1B92 stack[-1] } 1B8E 5B JUMPDEST 1B8F 61 PUSH2 0x1c78 1B92 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1c78, if stack[-1] label_1B93: // Incoming jump from 0x1B92, if not stack[-1] 1B93 61 PUSH2 0x1b9a 1B96 61 PUSH2 0x2846 1B99 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B93 stack[0] = 0x1b9a } // Block ends with call to 0x2846, returns to 0x1B9A label_1B9A: // Incoming return from call to 0x2846 at 0x1B99 // Inputs[1] { @1B9B stack[-1] } 1B9A 5B JUMPDEST 1B9B 80 DUP1 1B9C 63 PUSH4 0x08c379a0 1BA1 14 EQ 1BA2 15 ISZERO 1BA3 61 PUSH2 0x1bee 1BA6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1bee, if !(0x08c379a0 == stack[-1]) label_1BA7: // Incoming jump from 0x1BA6, if not !(0x08c379a0 == stack[-1]) 1BA7 50 POP 1BA8 61 PUSH2 0x1baf 1BAB 61 PUSH2 0x285e 1BAE 56 *JUMP // Stack delta = +0 // Outputs[1] { @1BA8 stack[-1] = 0x1baf } // Block ends with call to 0x285e, returns to 0x1BAF label_1BAF: // Incoming return from call to 0x285E at 0x1BAE // Incoming return from call to 0x285E at 0x1BAE // Inputs[1] { @1BB0 stack[-1] } 1BAF 5B JUMPDEST 1BB0 80 DUP1 1BB1 61 PUSH2 0x1bba 1BB4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1bba, if stack[-1] label_1BB5: // Incoming jump from 0x1BB4, if not stack[-1] 1BB5 50 POP 1BB6 61 PUSH2 0x1bf0 1BB9 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x1bf0 label_1BBA: // Incoming jump from 0x1BB4, if stack[-1] // Inputs[2] // { // @1BBB stack[-1] // @1BBE memory[0x40:0x60] // } 1BBA 5B JUMPDEST 1BBB 80 DUP1 1BBC 60 PUSH1 0x40 1BBE 51 MLOAD 1BBF 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1BE0 81 DUP2 1BE1 52 MSTORE 1BE2 60 PUSH1 0x04 1BE4 01 ADD 1BE5 61 PUSH2 0x038e 1BE8 91 SWAP2 1BE9 90 SWAP1 1BEA 61 PUSH2 0x2623 1BED 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1BE1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1BE8 stack[0] = 0x038e // @1BE9 stack[1] = stack[-1] // @1BE9 stack[2] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2623 label_1BEE: // Incoming jump from 0x1BA6, if !(0x08c379a0 == stack[-1]) // Inputs[1] { @1BF3 memory[0x40:0x60] } 1BEE 5B JUMPDEST 1BEF 50 POP 1BF0 5B JUMPDEST 1BF1 60 PUSH1 0x40 1BF3 51 MLOAD 1BF4 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1C15 81 DUP2 1C16 52 MSTORE 1C17 60 PUSH1 0x20 1C19 60 PUSH1 0x04 1C1B 82 DUP3 1C1C 01 ADD 1C1D 52 MSTORE 1C1E 60 PUSH1 0x34 1C20 60 PUSH1 0x24 1C22 82 DUP3 1C23 01 ADD 1C24 52 MSTORE 1C25 7F PUSH32 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 1C46 60 PUSH1 0x44 1C48 82 DUP3 1C49 01 ADD 1C4A 52 MSTORE 1C4B 7F PUSH32 0x526563656976657220696d706c656d656e746572000000000000000000000000 1C6C 60 PUSH1 0x64 1C6E 82 DUP3 1C6F 01 ADD 1C70 52 MSTORE 1C71 60 PUSH1 0x84 1C73 01 ADD 1C74 61 PUSH2 0x038e 1C77 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @1C16 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1C1D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1C24 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x34 // @1C4A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 // @1C70 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x526563656976657220696d706c656d656e746572000000000000000000000000 // @1C73 stack[-1] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x038e label_1C78: // Incoming jump from 0x1B92, if stack[-1] // Inputs[1] { @1C9A stack[-1] } 1C78 5B JUMPDEST 1C79 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 1C9A 81 DUP2 1C9B 16 AND 1C9C 7F PUSH32 0xf23a6e6100000000000000000000000000000000000000000000000000000000 1CBD 14 EQ 1CBE 61 PUSH2 0x1a34 1CC1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1a34, if 0xf23a6e6100000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_1CC2: // Incoming jump from 0x1CC1, if not 0xf23a6e6100000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @1CC4 memory[0x40:0x60] } 1CC2 60 PUSH1 0x40 1CC4 51 MLOAD 1CC5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1CE6 81 DUP2 1CE7 52 MSTORE 1CE8 60 PUSH1 0x20 1CEA 60 PUSH1 0x04 1CEC 82 DUP3 1CED 01 ADD 1CEE 52 MSTORE 1CEF 60 PUSH1 0x28 1CF1 60 PUSH1 0x24 1CF3 82 DUP3 1CF4 01 ADD 1CF5 52 MSTORE 1CF6 7F PUSH32 0x455243313135353a204552433131353552656365697665722072656a65637465 1D17 60 PUSH1 0x44 1D19 82 DUP3 1D1A 01 ADD 1D1B 52 MSTORE 1D1C 7F PUSH32 0x6420746f6b656e73000000000000000000000000000000000000000000000000 1D3D 60 PUSH1 0x64 1D3F 82 DUP3 1D40 01 ADD 1D41 52 MSTORE 1D42 60 PUSH1 0x84 1D44 01 ADD 1D45 61 PUSH2 0x038e 1D48 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1CE7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1CEE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1CF5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x28 // @1D1B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a204552433131353552656365697665722072656a65637465 // @1D41 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6420746f6b656e73000000000000000000000000000000000000000000000000 // @1D44 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x038e 1D49 5B JUMPDEST 1D4A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D5F 84 DUP5 1D60 16 AND 1D61 3B EXTCODESIZE 1D62 15 ISZERO 1D63 61 PUSH2 0x1626 1D66 57 *JUMPI 1D67 60 PUSH1 0x40 1D69 51 MLOAD 1D6A 7F PUSH32 0xbc197c8100000000000000000000000000000000000000000000000000000000 1D8B 81 DUP2 1D8C 52 MSTORE 1D8D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DA2 85 DUP6 1DA3 16 AND 1DA4 90 SWAP1 1DA5 63 PUSH4 0xbc197c81 1DAA 90 SWAP1 1DAB 61 PUSH2 0x1dc0 1DAE 90 SWAP1 1DAF 89 DUP10 1DB0 90 SWAP1 1DB1 89 DUP10 1DB2 90 SWAP1 1DB3 88 DUP9 1DB4 90 SWAP1 1DB5 88 DUP9 1DB6 90 SWAP1 1DB7 88 DUP9 1DB8 90 SWAP1 1DB9 60 PUSH1 0x04 1DBB 01 ADD 1DBC 61 PUSH2 0x2527 1DBF 56 *JUMP 1DC0 5B JUMPDEST 1DC1 60 PUSH1 0x20 1DC3 60 PUSH1 0x40 1DC5 51 MLOAD 1DC6 80 DUP1 1DC7 83 DUP4 1DC8 03 SUB 1DC9 81 DUP2 1DCA 60 PUSH1 0x00 1DCC 87 DUP8 1DCD 80 DUP1 1DCE 3B EXTCODESIZE 1DCF 15 ISZERO 1DD0 80 DUP1 1DD1 15 ISZERO 1DD2 61 PUSH2 0x1dda 1DD5 57 *JUMPI 1DD6 60 PUSH1 0x00 1DD8 80 DUP1 1DD9 FD *REVERT 1DDA 5B JUMPDEST 1DDB 50 POP 1DDC 5A GAS 1DDD F1 CALL 1DDE 92 SWAP3 1DDF 50 POP 1DE0 50 POP 1DE1 50 POP 1DE2 80 DUP1 1DE3 15 ISZERO 1DE4 61 PUSH2 0x1e28 1DE7 57 *JUMPI 1DE8 50 POP 1DE9 60 PUSH1 0x40 1DEB 80 DUP1 1DEC 51 MLOAD 1DED 60 PUSH1 0x1f 1DEF 3D RETURNDATASIZE 1DF0 90 SWAP1 1DF1 81 DUP2 1DF2 01 ADD 1DF3 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 1E14 16 AND 1E15 82 DUP3 1E16 01 ADD 1E17 90 SWAP1 1E18 92 SWAP3 1E19 52 MSTORE 1E1A 61 PUSH2 0x1e25 1E1D 91 SWAP2 1E1E 81 DUP2 1E1F 01 ADD 1E20 90 SWAP1 1E21 61 PUSH2 0x23de 1E24 56 *JUMP 1E25 5B JUMPDEST 1E26 60 PUSH1 0x01 1E28 5B JUMPDEST 1E29 61 PUSH2 0x1e34 1E2C 57 *JUMPI 1E2D 61 PUSH2 0x1b9a 1E30 61 PUSH2 0x2846 1E33 56 *JUMP 1E34 5B JUMPDEST 1E35 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 1E56 81 DUP2 1E57 16 AND 1E58 7F PUSH32 0xbc197c8100000000000000000000000000000000000000000000000000000000 1E79 14 EQ 1E7A 61 PUSH2 0x1a34 1E7D 57 *JUMPI 1E7E 60 PUSH1 0x40 1E80 51 MLOAD 1E81 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1EA2 81 DUP2 1EA3 52 MSTORE 1EA4 60 PUSH1 0x20 1EA6 60 PUSH1 0x04 1EA8 82 DUP3 1EA9 01 ADD 1EAA 52 MSTORE 1EAB 60 PUSH1 0x28 1EAD 60 PUSH1 0x24 1EAF 82 DUP3 1EB0 01 ADD 1EB1 52 MSTORE 1EB2 7F PUSH32 0x455243313135353a204552433131353552656365697665722072656a65637465 1ED3 60 PUSH1 0x44 1ED5 82 DUP3 1ED6 01 ADD 1ED7 52 MSTORE 1ED8 7F PUSH32 0x6420746f6b656e73000000000000000000000000000000000000000000000000 1EF9 60 PUSH1 0x64 1EFB 82 DUP3 1EFC 01 ADD 1EFD 52 MSTORE 1EFE 60 PUSH1 0x84 1F00 01 ADD 1F01 61 PUSH2 0x038e 1F04 56 *JUMP label_1F05: // Incoming jump from 0x1640 // Inputs[2] // { // @1F06 stack[-3] // @1F08 storage[stack[-3]] // } 1F05 5B JUMPDEST 1F06 82 DUP3 1F07 80 DUP1 1F08 54 SLOAD 1F09 61 PUSH2 0x1f11 1F0C 90 SWAP1 1F0D 61 PUSH2 0x26cd 1F10 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F06 stack[0] = stack[-3] // @1F0C stack[1] = 0x1f11 // @1F0C stack[2] = storage[stack[-3]] // } // Block ends with call to 0x26cd, returns to 0x1F11 label_1F11: // Incoming return from call to 0x26CD at 0x1F10 // Inputs[5] // { // @1F12 stack[-1] // @1F12 stack[-2] // @1F1A memory[0x00:0x20] // @1F25 stack[-4] // @1F26 stack[-3] // } 1F11 5B JUMPDEST 1F12 90 SWAP1 1F13 60 PUSH1 0x00 1F15 52 MSTORE 1F16 60 PUSH1 0x20 1F18 60 PUSH1 0x00 1F1A 20 SHA3 1F1B 90 SWAP1 1F1C 60 PUSH1 0x1f 1F1E 01 ADD 1F1F 60 PUSH1 0x20 1F21 90 SWAP1 1F22 04 DIV 1F23 81 DUP2 1F24 01 ADD 1F25 92 SWAP3 1F26 82 DUP3 1F27 61 PUSH2 0x1f33 1F2A 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1F15 memory[0x00:0x20] = stack[-2] // @1F1B stack[-2] = keccak256(memory[0x00:0x20]) // @1F25 stack[-1] = stack[-4] // @1F25 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x1f33, if stack[-3] label_1F2B: // Incoming jump from 0x1F2A, if not stack[-3] // Inputs[1] { @1F2D stack[-5] } 1F2B 60 PUSH1 0x00 1F2D 85 DUP6 1F2E 55 SSTORE 1F2F 61 PUSH2 0x1f79 1F32 56 *JUMP // Stack delta = +0 // Outputs[1] { @1F2E storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x1f79 label_1F33: // Incoming jump from 0x1F2A, if stack[-3] // Inputs[1] { @1F34 stack[-3] } 1F33 5B JUMPDEST 1F34 82 DUP3 1F35 60 PUSH1 0x1f 1F37 10 LT 1F38 61 PUSH2 0x1f4c 1F3B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f4c, if 0x1f < stack[-3] label_1F3C: // Incoming jump from 0x1F3B, if not 0x1f < stack[-3] // Inputs[4] // { // @1F3C stack[-1] // @1F3D memory[stack[-1]:stack[-1] + 0x20] // @1F42 stack[-3] // @1F46 stack[-5] // } 1F3C 80 DUP1 1F3D 51 MLOAD 1F3E 60 PUSH1 0xff 1F40 19 NOT 1F41 16 AND 1F42 83 DUP4 1F43 80 DUP1 1F44 01 ADD 1F45 17 OR 1F46 85 DUP6 1F47 55 SSTORE 1F48 61 PUSH2 0x1f79 1F4B 56 *JUMP // Stack delta = +0 // Outputs[1] { @1F47 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x1f79 label_1F4C: // Incoming jump from 0x1F3B, if 0x1f < stack[-3] // Inputs[2] // { // @1F4D stack[-3] // @1F53 stack[-5] // } 1F4C 5B JUMPDEST 1F4D 82 DUP3 1F4E 80 DUP1 1F4F 01 ADD 1F50 60 PUSH1 0x01 1F52 01 ADD 1F53 85 DUP6 1F54 55 SSTORE 1F55 82 DUP3 1F56 15 ISZERO 1F57 61 PUSH2 0x1f79 1F5A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1F54 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1f79, if !stack[-3] label_1F5B: // Incoming jump from 0x1F5A, if not !stack[-3] // Inputs[2] // { // @1F5B stack[-1] // @1F5B stack[-3] // } 1F5B 91 SWAP2 1F5C 82 DUP3 1F5D 01 ADD 1F5E 5B JUMPDEST 1F5F 82 DUP3 1F60 81 DUP2 1F61 11 GT 1F62 15 ISZERO 1F63 61 PUSH2 0x1f79 1F66 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1F5B stack[-3] = stack[-1] // @1F5D stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1f79, if !(stack[-1] + stack[-3] > stack[-1]) label_1F67: // Incoming jump from 0x1F66, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x1F66, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @1F67 stack[-3] // @1F68 memory[stack[-3]:stack[-3] + 0x20] // @1F69 stack[-2] // @1F6B stack[-1] // } 1F67 82 DUP3 1F68 51 MLOAD 1F69 82 DUP3 1F6A 55 SSTORE 1F6B 91 SWAP2 1F6C 60 PUSH1 0x20 1F6E 01 ADD 1F6F 91 SWAP2 1F70 90 SWAP1 1F71 60 PUSH1 0x01 1F73 01 ADD 1F74 90 SWAP1 1F75 61 PUSH2 0x1f5e 1F78 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1F6A storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1F6F stack[-3] = 0x20 + stack[-3] // @1F74 stack[-2] = 0x01 + stack[-2] // @1F74 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1f5e label_1F79: // Incoming jump from 0x1F66, if !(stack[-1] > stack[-3]) // Incoming jump from 0x1F5A, if !stack[-3] // Incoming jump from 0x1F4B // Incoming jump from 0x1F32 // Incoming jump from 0x1F66, if !(stack[-1] + stack[-3] > stack[-1]) // Inputs[2] // { // @1F7E stack[-4] // @1F7F stack[-3] // } 1F79 5B JUMPDEST 1F7A 50 POP 1F7B 61 PUSH2 0x1f85 1F7E 92 SWAP3 1F7F 91 SWAP2 1F80 50 POP 1F81 61 PUSH2 0x1f89 1F84 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1F7E stack[-4] = 0x1f85 // @1F7F stack[-3] = stack[-4] // } // Block ends with call to 0x1f89, returns to 0x1F85 label_1F85: // Incoming return from call to 0x1F89 at 0x1F84 // Incoming jump from 0x1F92, if !(stack[-2] > stack[-1]) // Incoming jump from 0x1F92, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @1F87 stack[-2] // @1F87 stack[-3] // } 1F85 5B JUMPDEST 1F86 50 POP 1F87 90 SWAP1 1F88 56 *JUMP // Stack delta = -2 // Outputs[1] { @1F87 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1F89: // Incoming call from 0x1F84, returns to 0x1F85 // Inputs[2] // { // @1F8B stack[-1] // @1F8C stack[-2] // } 1F89 5B JUMPDEST 1F8A 5B JUMPDEST 1F8B 80 DUP1 1F8C 82 DUP3 1F8D 11 GT 1F8E 15 ISZERO 1F8F 61 PUSH2 0x1f85 1F92 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f85, if !(stack[-2] > stack[-1]) label_1F93: // Incoming jump from 0x1F92, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1F92, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1F95 stack[-1] } 1F93 60 PUSH1 0x00 1F95 81 DUP2 1F96 55 SSTORE 1F97 60 PUSH1 0x01 1F99 01 ADD 1F9A 61 PUSH2 0x1f8a 1F9D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1F96 storage[stack[-1]] = 0x00 // @1F99 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1f8a label_1F9E: // Incoming call from 0x2131, returns to 0x2132 // Incoming call from 0x245B, returns to 0x0D34 // Inputs[1] { @1FAA stack[-2] } 1F9E 5B JUMPDEST 1F9F 60 PUSH1 0x00 1FA1 67 PUSH8 0xffffffffffffffff 1FAA 83 DUP4 1FAB 11 GT 1FAC 15 ISZERO 1FAD 61 PUSH2 0x1fb8 1FB0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F9F stack[0] = 0x00 } // Block ends with conditional jump to 0x1fb8, if !(stack[-2] > 0xffffffffffffffff) label_1FB1: // Incoming jump from 0x1FB0, if not !(stack[-2] > 0xffffffffffffffff) 1FB1 61 PUSH2 0x1fb8 1FB4 61 PUSH2 0x2817 1FB7 56 *JUMP // Stack delta = +1 // Outputs[1] { @1FB1 stack[0] = 0x1fb8 } // Block ends with unconditional jump to 0x2817 label_1FB8: // Incoming jump from 0x1FB0, if !(stack[-2] > 0xffffffffffffffff) // Inputs[2] // { // @1FBB memory[0x40:0x60] // @1FE4 stack[-3] // } 1FB8 5B JUMPDEST 1FB9 60 PUSH1 0x40 1FBB 51 MLOAD 1FBC 61 PUSH2 0x1fed 1FBF 60 PUSH1 0x20 1FC1 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 1FE2 60 PUSH1 0x1f 1FE4 87 DUP8 1FE5 01 ADD 1FE6 16 AND 1FE7 01 ADD 1FE8 82 DUP3 1FE9 61 PUSH2 0x2721 1FEC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1FBB stack[0] = memory[0x40:0x60] // @1FBC stack[1] = 0x1fed // @1FE7 stack[2] = (stack[-3] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + 0x20 // @1FE8 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x2721, returns to 0x1FED label_1FED: // Incoming return from call to 0x2721 at 0x1FEC // Inputs[5] // { // @1FEE stack[-1] // @1FEF stack[-2] // @1FF1 stack[-4] // @1FF4 stack[-5] // @1FF6 stack[-3] // } 1FED 5B JUMPDEST 1FEE 80 DUP1 1FEF 91 SWAP2 1FF0 50 POP 1FF1 83 DUP4 1FF2 81 DUP2 1FF3 52 MSTORE 1FF4 84 DUP5 1FF5 84 DUP5 1FF6 84 DUP5 1FF7 01 ADD 1FF8 11 GT 1FF9 15 ISZERO 1FFA 61 PUSH2 0x2002 1FFD 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1FEF stack[-2] = stack[-1] // @1FF3 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // } // Block ends with conditional jump to 0x2002, if !(stack[-3] + stack[-4] > stack[-5]) label_1FFE: // Incoming jump from 0x1FFD, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @2001 memory[0x00:0x00] } 1FFE 60 PUSH1 0x00 2000 80 DUP1 2001 FD *REVERT // Stack delta = +0 // Outputs[1] { @2001 revert(memory[0x00:0x00]); } // Block terminates label_2002: // Incoming jump from 0x1FFD, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[7] // { // @2003 stack[-4] // @2004 stack[-3] // @2007 stack[-1] // @2009 msg.data[stack[-3]:stack[-3] + stack[-4]] // @2014 stack[-2] // @2014 stack[-6] // @2015 stack[-5] // } 2002 5B JUMPDEST 2003 83 DUP4 2004 83 DUP4 2005 60 PUSH1 0x20 2007 83 DUP4 2008 01 ADD 2009 37 CALLDATACOPY 200A 60 PUSH1 0x00 200C 60 PUSH1 0x20 200E 85 DUP6 200F 83 DUP4 2010 01 ADD 2011 01 ADD 2012 52 MSTORE 2013 50 POP 2014 93 SWAP4 2015 92 SWAP3 2016 50 POP 2017 50 POP 2018 50 POP 2019 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @2009 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-4]] = msg.data[stack[-3]:stack[-3] + stack[-4]] // @2012 memory[stack[-1] + stack[-4] + 0x20:stack[-1] + stack[-4] + 0x20 + 0x20] = 0x00 // @2014 stack[-6] = stack[-2] // } // Block ends with unconditional jump to stack[-6] label_201A: // Incoming call from 0x2391, returns to 0x2392 // Incoming call from 0x2331, returns to 0x2332 // Inputs[2] // { // @201D stack[-2] // @2020 stack[-1] // } 201A 5B JUMPDEST 201B 60 PUSH1 0x00 201D 82 DUP3 201E 60 PUSH1 0x1f 2020 83 DUP4 2021 01 ADD 2022 12 SLT 2023 61 PUSH2 0x202a 2026 57 *JUMPI // Stack delta = +1 // Outputs[1] { @201B stack[0] = 0x00 } // Block ends with conditional jump to 0x202a, if stack[-1] + 0x1f i< stack[-2] label_2027: // Incoming jump from 0x2026, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @2027 stack[-1] // @2029 memory[stack[-1]:stack[-1] + stack[-1]] // } 2027 80 DUP1 2028 81 DUP2 2029 FD *REVERT // Stack delta = +0 // Outputs[1] { @2029 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_202A: // Incoming jump from 0x2026, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @202B stack[-2] // @202C msg.data[stack[-2]:stack[-2] + 0x20] // } 202A 5B JUMPDEST 202B 81 DUP2 202C 35 CALLDATALOAD 202D 60 PUSH1 0x20 202F 61 PUSH2 0x2037 2032 82 DUP3 2033 61 PUSH2 0x2636 2036 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @202C stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @202D stack[1] = 0x20 // @202F stack[2] = 0x2037 // @2032 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2636, returns to 0x2037 label_2037: // Incoming return from call to 0x2636 at 0x2036 // Inputs[2] // { // @203A memory[0x40:0x60] // @203E stack[-1] // } 2037 5B JUMPDEST 2038 60 PUSH1 0x40 203A 51 MLOAD 203B 61 PUSH2 0x2044 203E 82 DUP3 203F 82 DUP3 2040 61 PUSH2 0x2721 2043 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @203A stack[0] = memory[0x40:0x60] // @203B stack[1] = 0x2044 // @203E stack[2] = stack[-1] // @203F stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x2721, returns to 0x2044 label_2044: // Incoming return from call to 0x2721 at 0x2043 // Inputs[6] // { // @2045 stack[-4] // @2046 stack[-1] // @2048 stack[-3] // @204B stack[-2] // @204D stack[-6] // @2059 stack[-7] // } 2044 5B JUMPDEST 2045 83 DUP4 2046 81 DUP2 2047 52 MSTORE 2048 82 DUP3 2049 81 DUP2 204A 01 ADD 204B 91 SWAP2 204C 50 POP 204D 85 DUP6 204E 83 DUP4 204F 01 ADD 2050 60 PUSH1 0x05 2052 85 DUP6 2053 90 SWAP1 2054 1B SHL 2055 87 DUP8 2056 01 ADD 2057 84 DUP5 2058 01 ADD 2059 88 DUP9 205A 10 LT 205B 15 ISZERO 205C 61 PUSH2 0x2063 205F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2047 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @204B stack[-2] = stack[-1] + stack[-3] // @204F stack[0] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x2063, if !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) label_2060: // Incoming jump from 0x205F, if not !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[2] // { // @2060 stack[-6] // @2062 memory[stack[-6]:stack[-6] + stack[-6]] // } 2060 85 DUP6 2061 86 DUP7 2062 FD *REVERT // Stack delta = +0 // Outputs[1] { @2062 revert(memory[stack[-6]:stack[-6] + stack[-6]]); } // Block terminates label_2063: // Incoming jump from 0x205F, if !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[2] // { // @2064 stack[-6] // @2066 stack[-5] // } 2063 5B JUMPDEST 2064 85 DUP6 2065 5B JUMPDEST 2066 85 DUP6 2067 81 DUP2 2068 10 LT 2069 15 ISZERO 206A 61 PUSH2 0x208a 206D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2064 stack[0] = stack[-6] } // Block ends with conditional jump to 0x208a, if !(stack[-6] < stack[-5]) label_206E: // Incoming jump from 0x206D, if not !(stack[-6] < stack[-5]) // Incoming jump from 0x206D, if not !(stack[-1] < stack[-6]) // Inputs[2] // { // @206E stack[-2] // @206F msg.data[stack[-2]:stack[-2] + 0x20] // } 206E 81 DUP2 206F 35 CALLDATALOAD 2070 61 PUSH2 0x2078 2073 81 DUP2 2074 61 PUSH2 0x2906 2077 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @206F stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2070 stack[1] = 0x2078 // @2073 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2906, returns to 0x2078 label_2078: // Incoming return from call to 0x2906 at 0x2077 // Inputs[5] // { // @2079 stack[-5] // @207A stack[-1] // @207B stack[-2] // @207C stack[-6] // @207F stack[-3] // } 2078 5B JUMPDEST 2079 84 DUP5 207A 52 MSTORE 207B 92 SWAP3 207C 84 DUP5 207D 01 ADD 207E 92 SWAP3 207F 90 SWAP1 2080 84 DUP5 2081 01 ADD 2082 90 SWAP1 2083 60 PUSH1 0x01 2085 01 ADD 2086 61 PUSH2 0x2065 2089 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @207A memory[stack[-5]:stack[-5] + 0x20] = stack[-1] // @207E stack[-5] = stack[-6] + stack[-5] // @2082 stack[-3] = stack[-6] + stack[-3] // @2085 stack[-2] = 0x01 + stack[-2] // } // Block ends with unconditional jump to 0x2065 label_208A: // Incoming jump from 0x206D, if !(stack[-6] < stack[-5]) // Incoming jump from 0x20EA, if !(stack[-1] < stack[-6]) // Incoming jump from 0x20EA, if !(stack[-6] < stack[-5]) // Incoming jump from 0x206D, if !(stack[-1] < stack[-6]) // Inputs[4] // { // @208C stack[-2] // @208C stack[-3] // @208D stack[-10] // @208E stack[-9] // } 208A 5B JUMPDEST 208B 50 POP 208C 90 SWAP1 208D 97 SWAP8 208E 96 SWAP7 208F 50 POP 2090 50 POP 2091 50 POP 2092 50 POP 2093 50 POP 2094 50 POP 2095 50 POP 2096 56 *JUMP // Stack delta = -9 // Outputs[1] { @208D stack[-10] = stack[-3] } // Block ends with unconditional jump to stack[-10] label_2097: // Incoming call from 0x2207, returns to 0x2208 // Incoming call from 0x21E6, returns to 0x21E7 // Incoming call from 0x2353, returns to 0x2354 // Inputs[2] // { // @209A stack[-2] // @209D stack[-1] // } 2097 5B JUMPDEST 2098 60 PUSH1 0x00 209A 82 DUP3 209B 60 PUSH1 0x1f 209D 83 DUP4 209E 01 ADD 209F 12 SLT 20A0 61 PUSH2 0x20a7 20A3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2098 stack[0] = 0x00 } // Block ends with conditional jump to 0x20a7, if stack[-1] + 0x1f i< stack[-2] label_20A4: // Incoming jump from 0x20A3, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @20A4 stack[-1] // @20A6 memory[stack[-1]:stack[-1] + stack[-1]] // } 20A4 80 DUP1 20A5 81 DUP2 20A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @20A6 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_20A7: // Incoming jump from 0x20A3, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @20A8 stack[-2] // @20A9 msg.data[stack[-2]:stack[-2] + 0x20] // } 20A7 5B JUMPDEST 20A8 81 DUP2 20A9 35 CALLDATALOAD 20AA 60 PUSH1 0x20 20AC 61 PUSH2 0x20b4 20AF 82 DUP3 20B0 61 PUSH2 0x2636 20B3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @20A9 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @20AA stack[1] = 0x20 // @20AC stack[2] = 0x20b4 // @20AF stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2636, returns to 0x20B4 label_20B4: // Incoming return from call to 0x2636 at 0x20B3 // Inputs[2] // { // @20B7 memory[0x40:0x60] // @20BB stack[-1] // } 20B4 5B JUMPDEST 20B5 60 PUSH1 0x40 20B7 51 MLOAD 20B8 61 PUSH2 0x20c1 20BB 82 DUP3 20BC 82 DUP3 20BD 61 PUSH2 0x2721 20C0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @20B7 stack[0] = memory[0x40:0x60] // @20B8 stack[1] = 0x20c1 // @20BB stack[2] = stack[-1] // @20BC stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x2721, returns to 0x20C1 label_20C1: // Incoming return from call to 0x2721 at 0x20C0 // Inputs[6] // { // @20C2 stack[-4] // @20C3 stack[-1] // @20C5 stack[-3] // @20C8 stack[-2] // @20CA stack[-6] // @20D6 stack[-7] // } 20C1 5B JUMPDEST 20C2 83 DUP4 20C3 81 DUP2 20C4 52 MSTORE 20C5 82 DUP3 20C6 81 DUP2 20C7 01 ADD 20C8 91 SWAP2 20C9 50 POP 20CA 85 DUP6 20CB 83 DUP4 20CC 01 ADD 20CD 60 PUSH1 0x05 20CF 85 DUP6 20D0 90 SWAP1 20D1 1B SHL 20D2 87 DUP8 20D3 01 ADD 20D4 84 DUP5 20D5 01 ADD 20D6 88 DUP9 20D7 10 LT 20D8 15 ISZERO 20D9 61 PUSH2 0x20e0 20DC 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @20C4 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @20C8 stack[-2] = stack[-1] + stack[-3] // @20CC stack[0] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x20e0, if !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) label_20DD: // Incoming jump from 0x20DC, if not !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[2] // { // @20DD stack[-6] // @20DF memory[stack[-6]:stack[-6] + stack[-6]] // } 20DD 85 DUP6 20DE 86 DUP7 20DF FD *REVERT // Stack delta = +0 // Outputs[1] { @20DF revert(memory[stack[-6]:stack[-6] + stack[-6]]); } // Block terminates label_20E0: // Incoming jump from 0x20DC, if !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[2] // { // @20E1 stack[-6] // @20E3 stack[-5] // } 20E0 5B JUMPDEST 20E1 85 DUP6 20E2 5B JUMPDEST 20E3 85 DUP6 20E4 81 DUP2 20E5 10 LT 20E6 15 ISZERO 20E7 61 PUSH2 0x208a 20EA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20E1 stack[0] = stack[-6] } // Block ends with conditional jump to 0x208a, if !(stack[-6] < stack[-5]) label_20EB: // Incoming jump from 0x20EA, if not !(stack[-6] < stack[-5]) // Incoming jump from 0x20EA, if not !(stack[-1] < stack[-6]) // Inputs[5] // { // @20EB stack[-2] // @20EC msg.data[stack[-2]:stack[-2] + 0x20] // @20ED stack[-4] // @20EF stack[-1] // @20F0 stack[-5] // } 20EB 81 DUP2 20EC 35 CALLDATALOAD 20ED 84 DUP5 20EE 52 MSTORE 20EF 92 SWAP3 20F0 84 DUP5 20F1 01 ADD 20F2 92 SWAP3 20F3 90 SWAP1 20F4 84 DUP5 20F5 01 ADD 20F6 90 SWAP1 20F7 60 PUSH1 0x01 20F9 01 ADD 20FA 61 PUSH2 0x20e2 20FD 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @20EE memory[stack[-4]:stack[-4] + 0x20] = msg.data[stack[-2]:stack[-2] + 0x20] // @20F2 stack[-4] = stack[-5] + stack[-4] // @20F6 stack[-2] = stack[-5] + stack[-2] // @20F9 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x20e2 label_20FE: // Incoming call from 0x23C1, returns to 0x2132 // Incoming call from 0x22C8, returns to 0x22C9 // Inputs[2] // { // @20FF stack[-1] // @2100 msg.data[stack[-1]:stack[-1] + 0x20] // } 20FE 5B JUMPDEST 20FF 80 DUP1 2100 35 CALLDATALOAD 2101 80 DUP1 2102 15 ISZERO 2103 15 ISZERO 2104 81 DUP2 2105 14 EQ 2106 61 PUSH2 0x210e 2109 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2100 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x210e, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_210A: // Incoming jump from 0x2109, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @210D memory[0x00:0x00] } 210A 60 PUSH1 0x00 210C 80 DUP1 210D FD *REVERT // Stack delta = +0 // Outputs[1] { @210D revert(memory[0x00:0x00]); } // Block terminates label_210E: // Incoming jump from 0x2109, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @210F stack[-3] // @210F stack[-1] // @2110 stack[-2] // } 210E 5B JUMPDEST 210F 91 SWAP2 2110 90 SWAP1 2111 50 POP 2112 56 *JUMP // Stack delta = -2 // Outputs[1] { @210F stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_2113: // Incoming jump from 0x229D // Incoming jump from 0x2229 // Inputs[2] // { // @2116 stack[-2] // @2119 stack[-1] // } 2113 5B JUMPDEST 2114 60 PUSH1 0x00 2116 82 DUP3 2117 60 PUSH1 0x1f 2119 83 DUP4 211A 01 ADD 211B 12 SLT 211C 61 PUSH2 0x2123 211F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2114 stack[0] = 0x00 } // Block ends with conditional jump to 0x2123, if stack[-1] + 0x1f i< stack[-2] label_2120: // Incoming jump from 0x211F, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @2120 stack[-1] // @2122 memory[stack[-1]:stack[-1] + stack[-1]] // } 2120 80 DUP1 2121 81 DUP2 2122 FD *REVERT // Stack delta = +0 // Outputs[1] { @2122 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2123: // Incoming jump from 0x211F, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @2127 stack[-3] // @2128 stack[-2] // @2129 msg.data[stack[-2]:stack[-2] + 0x20] // } 2123 5B JUMPDEST 2124 61 PUSH2 0x2132 2127 83 DUP4 2128 83 DUP4 2129 35 CALLDATALOAD 212A 60 PUSH1 0x20 212C 85 DUP6 212D 01 ADD 212E 61 PUSH2 0x1f9e 2131 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2124 stack[0] = 0x2132 // @2127 stack[1] = stack[-3] // @2129 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // @212D stack[3] = stack[-2] + 0x20 // } // Block ends with call to 0x1f9e, returns to 0x2132 label_2132: // Incoming return from call to 0x2906 at 0x2415 // Incoming return from call to 0x2474 at 0x25F4 // Incoming return from call to 0x20FE at 0x23C1 // Incoming return from call to 0x2906 at 0x2154 // Incoming return from call to 0x2928 at 0x23F9 // Incoming return from call to 0x1F9E at 0x2131 // Incoming return from call to 0x24AE at 0x2635 // Incoming return from call to 0x2928 at 0x23DD // Inputs[3] // { // @2133 stack[-1] // @2133 stack[-5] // @2134 stack[-4] // } 2132 5B JUMPDEST 2133 93 SWAP4 2134 92 SWAP3 2135 50 POP 2136 50 POP 2137 50 POP 2138 56 *JUMP // Stack delta = -4 // Outputs[1] { @2133 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2139: // Incoming call from 0x02E7, returns to 0x02E8 // Inputs[2] // { // @213E stack[-1] // @213F stack[-2] // } 2139 5B JUMPDEST 213A 60 PUSH1 0x00 213C 60 PUSH1 0x20 213E 82 DUP3 213F 84 DUP5 2140 03 SUB 2141 12 SLT 2142 15 ISZERO 2143 61 PUSH2 0x214a 2146 57 *JUMPI // Stack delta = +1 // Outputs[1] { @213A stack[0] = 0x00 } // Block ends with conditional jump to 0x214a, if !(stack[-2] - stack[-1] i< 0x20) label_2147: // Incoming jump from 0x2146, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2147 stack[-1] // @2149 memory[stack[-1]:stack[-1] + stack[-1]] // } 2147 80 DUP1 2148 81 DUP2 2149 FD *REVERT // Stack delta = +0 // Outputs[1] { @2149 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_214A: // Incoming jump from 0x2146, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @214B stack[-2] // @214C msg.data[stack[-2]:stack[-2] + 0x20] // } 214A 5B JUMPDEST 214B 81 DUP2 214C 35 CALLDATALOAD 214D 61 PUSH2 0x2132 2150 81 DUP2 2151 61 PUSH2 0x2906 2154 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @214C stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @214D stack[1] = 0x2132 // @2150 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2906, returns to 0x2132 label_2155: // Incoming call from 0x02C1, returns to 0x02C2 // Inputs[2] // { // @215B stack[-1] // @215C stack[-2] // } 2155 5B JUMPDEST 2156 60 PUSH1 0x00 2158 80 DUP1 2159 60 PUSH1 0x40 215B 83 DUP4 215C 85 DUP6 215D 03 SUB 215E 12 SLT 215F 15 ISZERO 2160 61 PUSH2 0x2167 2163 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2156 stack[0] = 0x00 // @2158 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2167, if !(stack[-2] - stack[-1] i< 0x40) label_2164: // Incoming jump from 0x2163, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2164 stack[-1] // @2166 memory[stack[-1]:stack[-1] + stack[-1]] // } 2164 80 DUP1 2165 81 DUP2 2166 FD *REVERT // Stack delta = +0 // Outputs[1] { @2166 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2167: // Incoming jump from 0x2163, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2168 stack[-3] // @2169 msg.data[stack[-3]:stack[-3] + 0x20] // } 2167 5B JUMPDEST 2168 82 DUP3 2169 35 CALLDATALOAD 216A 61 PUSH2 0x2172 216D 81 DUP2 216E 61 PUSH2 0x2906 2171 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2169 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @216A stack[1] = 0x2172 // @216D stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x2906, returns to 0x2172 label_2172: // Incoming return from call to 0x2906 at 0x2171 // Inputs[4] // { // @2173 stack[-3] // @2173 stack[-1] // @2177 stack[-4] // @2179 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 2172 5B JUMPDEST 2173 91 SWAP2 2174 50 POP 2175 60 PUSH1 0x20 2177 83 DUP4 2178 01 ADD 2179 35 CALLDATALOAD 217A 61 PUSH2 0x2182 217D 81 DUP2 217E 61 PUSH2 0x2906 2181 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2173 stack[-3] = stack[-1] // @2179 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @217A stack[0] = 0x2182 // @217D stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x2906, returns to 0x2182 label_2182: // Incoming return from call to 0x2906 at 0x2181 // Incoming jump from 0x23A4, if msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] == msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] & 0xff // Inputs[6] // { // @2183 stack[-1] // @2184 stack[-2] // @2187 stack[-5] // @2189 stack[-3] // @2189 stack[-6] // @218A stack[-4] // } 2182 5B JUMPDEST 2183 80 DUP1 2184 91 SWAP2 2185 50 POP 2186 50 POP 2187 92 SWAP3 2188 50 POP 2189 92 SWAP3 218A 90 SWAP1 218B 50 POP 218C 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2187 stack[-5] = stack[-1] // @2189 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_218D: // Incoming jump from 0x020B // Inputs[2] // { // @2198 stack[-1] // @2199 stack[-2] // } 218D 5B JUMPDEST 218E 60 PUSH1 0x00 2190 80 DUP1 2191 60 PUSH1 0x00 2193 80 DUP1 2194 60 PUSH1 0x00 2196 60 PUSH1 0xa0 2198 86 DUP7 2199 88 DUP9 219A 03 SUB 219B 12 SLT 219C 15 ISZERO 219D 61 PUSH2 0x21a4 21A0 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @218E stack[0] = 0x00 // @2190 stack[1] = 0x00 // @2191 stack[2] = 0x00 // @2193 stack[3] = 0x00 // @2194 stack[4] = 0x00 // } // Block ends with conditional jump to 0x21a4, if !(stack[-2] - stack[-1] i< 0xa0) label_21A1: // Incoming jump from 0x21A0, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @21A1 stack[-1] // @21A3 memory[stack[-1]:stack[-1] + stack[-1]] // } 21A1 80 DUP1 21A2 81 DUP2 21A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @21A3 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_21A4: // Incoming jump from 0x21A0, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @21A5 stack[-6] // @21A6 msg.data[stack[-6]:stack[-6] + 0x20] // } 21A4 5B JUMPDEST 21A5 85 DUP6 21A6 35 CALLDATALOAD 21A7 61 PUSH2 0x21af 21AA 81 DUP2 21AB 61 PUSH2 0x2906 21AE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @21A6 stack[0] = msg.data[stack[-6]:stack[-6] + 0x20] // @21A7 stack[1] = 0x21af // @21AA stack[2] = msg.data[stack[-6]:stack[-6] + 0x20] // } // Block ends with call to 0x2906, returns to 0x21AF label_21AF: // Incoming return from call to 0x2906 at 0x21AE // Inputs[4] // { // @21B0 stack[-6] // @21B0 stack[-1] // @21B4 stack[-7] // @21B6 msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // } 21AF 5B JUMPDEST 21B0 94 SWAP5 21B1 50 POP 21B2 60 PUSH1 0x20 21B4 86 DUP7 21B5 01 ADD 21B6 35 CALLDATALOAD 21B7 61 PUSH2 0x21bf 21BA 81 DUP2 21BB 61 PUSH2 0x2906 21BE 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @21B0 stack[-6] = stack[-1] // @21B6 stack[-1] = msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // @21B7 stack[0] = 0x21bf // @21BA stack[1] = msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // } // Block ends with call to 0x2906, returns to 0x21BF label_21BF: // Incoming return from call to 0x2906 at 0x21BE // Inputs[4] // { // @21C0 stack[-5] // @21C0 stack[-1] // @21C4 stack[-7] // @21C6 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } 21BF 5B JUMPDEST 21C0 93 SWAP4 21C1 50 POP 21C2 60 PUSH1 0x40 21C4 86 DUP7 21C5 01 ADD 21C6 35 CALLDATALOAD 21C7 67 PUSH8 0xffffffffffffffff 21D0 80 DUP1 21D1 82 DUP3 21D2 11 GT 21D3 15 ISZERO 21D4 61 PUSH2 0x21db 21D7 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @21C0 stack[-5] = stack[-1] // @21C6 stack[-1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @21C7 stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x21db, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) label_21D8: // Incoming jump from 0x21D7, if not !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @21D8 stack[-3] // @21DA memory[stack[-3]:stack[-3] + stack[-3]] // } 21D8 82 DUP3 21D9 83 DUP4 21DA FD *REVERT // Stack delta = +0 // Outputs[1] { @21DA revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_21DB: // Incoming jump from 0x21D7, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @21DF stack[-9] // @21E0 stack[-2] // @21E1 stack[-8] // } 21DB 5B JUMPDEST 21DC 61 PUSH2 0x21e7 21DF 89 DUP10 21E0 83 DUP4 21E1 8A DUP11 21E2 01 ADD 21E3 61 PUSH2 0x2097 21E6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @21DC stack[0] = 0x21e7 // @21DF stack[1] = stack[-9] // @21E2 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x2097, returns to 0x21E7 label_21E7: // Incoming return from call to 0x2097 at 0x21E6 // Inputs[6] // { // @21E8 stack[-6] // @21E8 stack[-1] // @21EC stack[-9] // @21EE msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // @21EF stack[-3] // @21F1 stack[-2] // } 21E7 5B JUMPDEST 21E8 94 SWAP5 21E9 50 POP 21EA 60 PUSH1 0x60 21EC 88 DUP9 21ED 01 ADD 21EE 35 CALLDATALOAD 21EF 91 SWAP2 21F0 50 POP 21F1 80 DUP1 21F2 82 DUP3 21F3 11 GT 21F4 15 ISZERO 21F5 61 PUSH2 0x21fc 21F8 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @21E8 stack[-6] = stack[-1] // @21EF stack[-3] = msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x21fc, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) label_21F9: // Incoming jump from 0x21F8, if not !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[2] // { // @21F9 stack[-3] // @21FB memory[stack[-3]:stack[-3] + stack[-3]] // } 21F9 82 DUP3 21FA 83 DUP4 21FB FD *REVERT // Stack delta = +0 // Outputs[1] { @21FB revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_21FC: // Incoming jump from 0x21F8, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[3] // { // @2200 stack[-9] // @2201 stack[-2] // @2202 stack[-8] // } 21FC 5B JUMPDEST 21FD 61 PUSH2 0x2208 2200 89 DUP10 2201 83 DUP4 2202 8A DUP11 2203 01 ADD 2204 61 PUSH2 0x2097 2207 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @21FD stack[0] = 0x2208 // @2200 stack[1] = stack[-9] // @2203 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x2097, returns to 0x2208 label_2208: // Incoming return from call to 0x2097 at 0x2207 // Inputs[6] // { // @2209 stack[-5] // @2209 stack[-1] // @220D stack[-9] // @220F msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // @2210 stack[-3] // @2212 stack[-2] // } 2208 5B JUMPDEST 2209 93 SWAP4 220A 50 POP 220B 60 PUSH1 0x80 220D 88 DUP9 220E 01 ADD 220F 35 CALLDATALOAD 2210 91 SWAP2 2211 50 POP 2212 80 DUP1 2213 82 DUP3 2214 11 GT 2215 15 ISZERO 2216 61 PUSH2 0x221d 2219 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @2209 stack[-5] = stack[-1] // @2210 stack[-3] = msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x221d, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) label_221A: // Incoming jump from 0x2219, if not !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[2] // { // @221A stack[-3] // @221C memory[stack[-3]:stack[-3] + stack[-3]] // } 221A 82 DUP3 221B 83 DUP4 221C FD *REVERT // Stack delta = +0 // Outputs[1] { @221C revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_221D: // Incoming jump from 0x2219, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[3] // { // @2222 stack[-9] // @2223 stack[-2] // @2224 stack[-8] // } 221D 5B JUMPDEST 221E 50 POP 221F 61 PUSH2 0x222a 2222 88 DUP9 2223 82 DUP3 2224 89 DUP10 2225 01 ADD 2226 61 PUSH2 0x2113 2229 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @221F stack[-1] = 0x222a // @2222 stack[0] = stack[-9] // @2225 stack[1] = stack[-8] + stack[-2] // } // Block ends with unconditional jump to 0x2113 222A 5B JUMPDEST 222B 91 SWAP2 222C 50 POP 222D 50 POP 222E 92 SWAP3 222F 95 SWAP6 2230 50 POP 2231 92 SWAP3 2232 95 SWAP6 2233 90 SWAP1 2234 93 SWAP4 2235 50 POP 2236 56 *JUMP label_2237: // Incoming jump from 0x02D4 // Inputs[2] // { // @2242 stack[-1] // @2243 stack[-2] // } 2237 5B JUMPDEST 2238 60 PUSH1 0x00 223A 80 DUP1 223B 60 PUSH1 0x00 223D 80 DUP1 223E 60 PUSH1 0x00 2240 60 PUSH1 0xa0 2242 86 DUP7 2243 88 DUP9 2244 03 SUB 2245 12 SLT 2246 15 ISZERO 2247 61 PUSH2 0x224e 224A 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @2238 stack[0] = 0x00 // @223A stack[1] = 0x00 // @223B stack[2] = 0x00 // @223D stack[3] = 0x00 // @223E stack[4] = 0x00 // } // Block ends with conditional jump to 0x224e, if !(stack[-2] - stack[-1] i< 0xa0) label_224B: // Incoming jump from 0x224A, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @224B stack[-1] // @224D memory[stack[-1]:stack[-1] + stack[-1]] // } 224B 80 DUP1 224C 81 DUP2 224D FD *REVERT // Stack delta = +0 // Outputs[1] { @224D revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_224E: // Incoming jump from 0x224A, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @224F stack[-6] // @2250 msg.data[stack[-6]:stack[-6] + 0x20] // } 224E 5B JUMPDEST 224F 85 DUP6 2250 35 CALLDATALOAD 2251 61 PUSH2 0x2259 2254 81 DUP2 2255 61 PUSH2 0x2906 2258 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2250 stack[0] = msg.data[stack[-6]:stack[-6] + 0x20] // @2251 stack[1] = 0x2259 // @2254 stack[2] = msg.data[stack[-6]:stack[-6] + 0x20] // } // Block ends with call to 0x2906, returns to 0x2259 label_2259: // Incoming return from call to 0x2906 at 0x2258 // Inputs[4] // { // @225A stack[-1] // @225A stack[-6] // @225E stack[-7] // @2260 msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // } 2259 5B JUMPDEST 225A 94 SWAP5 225B 50 POP 225C 60 PUSH1 0x20 225E 86 DUP7 225F 01 ADD 2260 35 CALLDATALOAD 2261 61 PUSH2 0x2269 2264 81 DUP2 2265 61 PUSH2 0x2906 2268 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @225A stack[-6] = stack[-1] // @2260 stack[-1] = msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // @2261 stack[0] = 0x2269 // @2264 stack[1] = msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // } // Block ends with call to 0x2906, returns to 0x2269 label_2269: // Incoming return from call to 0x2906 at 0x2268 // Inputs[8] // { // @226A stack[-5] // @226A stack[-1] // @226E stack[-7] // @2270 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @2271 stack[-4] // @2277 msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @2278 stack[-3] // @227E msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } 2269 5B JUMPDEST 226A 93 SWAP4 226B 50 POP 226C 60 PUSH1 0x40 226E 86 DUP7 226F 01 ADD 2270 35 CALLDATALOAD 2271 92 SWAP3 2272 50 POP 2273 60 PUSH1 0x60 2275 86 DUP7 2276 01 ADD 2277 35 CALLDATALOAD 2278 91 SWAP2 2279 50 POP 227A 60 PUSH1 0x80 227C 86 DUP7 227D 01 ADD 227E 35 CALLDATALOAD 227F 67 PUSH8 0xffffffffffffffff 2288 81 DUP2 2289 11 GT 228A 15 ISZERO 228B 61 PUSH2 0x2292 228E 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @226A stack[-5] = stack[-1] // @2271 stack[-4] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @2278 stack[-3] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @227E stack[-1] = msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x2292, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) label_228F: // Incoming jump from 0x228E, if not !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @228F stack[-2] // @2291 memory[stack[-2]:stack[-2] + stack[-2]] // } 228F 81 DUP2 2290 82 DUP3 2291 FD *REVERT // Stack delta = +0 // Outputs[1] { @2291 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2292: // Incoming jump from 0x228E, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2296 stack[-8] // @2297 stack[-1] // @2298 stack[-7] // } 2292 5B JUMPDEST 2293 61 PUSH2 0x222a 2296 88 DUP9 2297 82 DUP3 2298 89 DUP10 2299 01 ADD 229A 61 PUSH2 0x2113 229D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2293 stack[0] = 0x222a // @2296 stack[1] = stack[-8] // @2299 stack[2] = stack[-7] + stack[-1] // } // Block ends with unconditional jump to 0x2113 label_229E: // Incoming call from 0x0292, returns to 0x0293 // Inputs[2] // { // @22A4 stack[-1] // @22A5 stack[-2] // } 229E 5B JUMPDEST 229F 60 PUSH1 0x00 22A1 80 DUP1 22A2 60 PUSH1 0x40 22A4 83 DUP4 22A5 85 DUP6 22A6 03 SUB 22A7 12 SLT 22A8 15 ISZERO 22A9 61 PUSH2 0x22b0 22AC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @229F stack[0] = 0x00 // @22A1 stack[1] = 0x00 // } // Block ends with conditional jump to 0x22b0, if !(stack[-2] - stack[-1] i< 0x40) label_22AD: // Incoming jump from 0x22AC, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @22AD stack[-2] // @22AF memory[stack[-2]:stack[-2] + stack[-2]] // } 22AD 81 DUP2 22AE 82 DUP3 22AF FD *REVERT // Stack delta = +0 // Outputs[1] { @22AF revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_22B0: // Incoming jump from 0x22AC, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @22B1 stack[-3] // @22B2 msg.data[stack[-3]:stack[-3] + 0x20] // } 22B0 5B JUMPDEST 22B1 82 DUP3 22B2 35 CALLDATALOAD 22B3 61 PUSH2 0x22bb 22B6 81 DUP2 22B7 61 PUSH2 0x2906 22BA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @22B2 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @22B3 stack[1] = 0x22bb // @22B6 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x2906, returns to 0x22BB label_22BB: // Incoming return from call to 0x2906 at 0x22BA // Inputs[3] // { // @22BC stack[-3] // @22BC stack[-1] // @22C3 stack[-4] // } 22BB 5B JUMPDEST 22BC 91 SWAP2 22BD 50 POP 22BE 61 PUSH2 0x22c9 22C1 60 PUSH1 0x20 22C3 84 DUP5 22C4 01 ADD 22C5 61 PUSH2 0x20fe 22C8 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @22BC stack[-3] = stack[-1] // @22BE stack[-1] = 0x22c9 // @22C4 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x20fe, returns to 0x22C9 label_22C9: // Incoming return from call to 0x20FE at 0x22C8 // Inputs[6] // { // @22CA stack[-2] // @22CA stack[-1] // @22CC stack[-5] // @22CE stack[-3] // @22CE stack[-6] // @22CF stack[-4] // } 22C9 5B JUMPDEST 22CA 90 SWAP1 22CB 50 POP 22CC 92 SWAP3 22CD 50 POP 22CE 92 SWAP3 22CF 90 SWAP1 22D0 50 POP 22D1 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @22CC stack[-5] = stack[-1] // @22CE stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_22D2: // Incoming call from 0x017D, returns to 0x017E // Inputs[2] // { // @22D8 stack[-1] // @22D9 stack[-2] // } 22D2 5B JUMPDEST 22D3 60 PUSH1 0x00 22D5 80 DUP1 22D6 60 PUSH1 0x40 22D8 83 DUP4 22D9 85 DUP6 22DA 03 SUB 22DB 12 SLT 22DC 15 ISZERO 22DD 61 PUSH2 0x22e4 22E0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @22D3 stack[0] = 0x00 // @22D5 stack[1] = 0x00 // } // Block ends with conditional jump to 0x22e4, if !(stack[-2] - stack[-1] i< 0x40) label_22E1: // Incoming jump from 0x22E0, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @22E1 stack[-2] // @22E3 memory[stack[-2]:stack[-2] + stack[-2]] // } 22E1 81 DUP2 22E2 82 DUP3 22E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @22E3 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_22E4: // Incoming jump from 0x22E0, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @22E5 stack[-3] // @22E6 msg.data[stack[-3]:stack[-3] + 0x20] // } 22E4 5B JUMPDEST 22E5 82 DUP3 22E6 35 CALLDATALOAD 22E7 61 PUSH2 0x22ef 22EA 81 DUP2 22EB 61 PUSH2 0x2906 22EE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @22E6 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @22E7 stack[1] = 0x22ef // @22EA stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x2906, returns to 0x22EF label_22EF: // Incoming return from call to 0x2906 at 0x22EE // Inputs[5] // { // @22F0 stack[-1] // @22F0 stack[-6] // @22F3 stack[-4] // @22F7 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @22F8 stack[-5] // } 22EF 5B JUMPDEST 22F0 94 SWAP5 22F1 60 PUSH1 0x20 22F3 93 SWAP4 22F4 90 SWAP1 22F5 93 SWAP4 22F6 01 ADD 22F7 35 CALLDATALOAD 22F8 93 SWAP4 22F9 50 POP 22FA 50 POP 22FB 50 POP 22FC 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @22F0 stack[-6] = stack[-1] // @22F8 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_22FD: // Incoming call from 0x021E, returns to 0x021F // Inputs[2] // { // @2303 stack[-1] // @2304 stack[-2] // } 22FD 5B JUMPDEST 22FE 60 PUSH1 0x00 2300 80 DUP1 2301 60 PUSH1 0x40 2303 83 DUP4 2304 85 DUP6 2305 03 SUB 2306 12 SLT 2307 15 ISZERO 2308 61 PUSH2 0x230f 230B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @22FE stack[0] = 0x00 // @2300 stack[1] = 0x00 // } // Block ends with conditional jump to 0x230f, if !(stack[-2] - stack[-1] i< 0x40) label_230C: // Incoming jump from 0x230B, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @230C stack[-2] // @230E memory[stack[-2]:stack[-2] + stack[-2]] // } 230C 81 DUP2 230D 82 DUP3 230E FD *REVERT // Stack delta = +0 // Outputs[1] { @230E revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_230F: // Incoming jump from 0x230B, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2310 stack[-3] // @2311 msg.data[stack[-3]:stack[-3] + 0x20] // } 230F 5B JUMPDEST 2310 82 DUP3 2311 35 CALLDATALOAD 2312 67 PUSH8 0xffffffffffffffff 231B 80 DUP1 231C 82 DUP3 231D 11 GT 231E 15 ISZERO 231F 61 PUSH2 0x2326 2322 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2311 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @2312 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x2326, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_2323: // Incoming jump from 0x2322, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2323 stack[-4] // @2325 memory[stack[-4]:stack[-4] + stack[-4]] // } 2323 83 DUP4 2324 84 DUP5 2325 FD *REVERT // Stack delta = +0 // Outputs[1] { @2325 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_2326: // Incoming jump from 0x2322, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @232A stack[-6] // @232B stack[-2] // @232C stack[-5] // } 2326 5B JUMPDEST 2327 61 PUSH2 0x2332 232A 86 DUP7 232B 83 DUP4 232C 87 DUP8 232D 01 ADD 232E 61 PUSH2 0x201a 2331 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2327 stack[0] = 0x2332 // @232A stack[1] = stack[-6] // @232D stack[2] = stack[-5] + stack[-2] // } // Block ends with call to 0x201a, returns to 0x2332 label_2332: // Incoming return from call to 0x201A at 0x2331 // Inputs[6] // { // @2333 stack[-5] // @2333 stack[-1] // @2337 stack[-6] // @2339 msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @233A stack[-3] // @233C stack[-2] // } 2332 5B JUMPDEST 2333 93 SWAP4 2334 50 POP 2335 60 PUSH1 0x20 2337 85 DUP6 2338 01 ADD 2339 35 CALLDATALOAD 233A 91 SWAP2 233B 50 POP 233C 80 DUP1 233D 82 DUP3 233E 11 GT 233F 15 ISZERO 2340 61 PUSH2 0x2347 2343 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @2333 stack[-5] = stack[-1] // @233A stack[-3] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2347, if !(msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] > stack[-2]) label_2344: // Incoming jump from 0x2343, if not !(msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] > stack[-2]) // Inputs[2] // { // @2344 stack[-3] // @2346 memory[stack[-3]:stack[-3] + stack[-3]] // } 2344 82 DUP3 2345 83 DUP4 2346 FD *REVERT // Stack delta = +0 // Outputs[1] { @2346 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_2347: // Incoming jump from 0x2343, if !(msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] > stack[-2]) // Inputs[3] // { // @234C stack[-6] // @234D stack[-2] // @234E stack[-5] // } 2347 5B JUMPDEST 2348 50 POP 2349 61 PUSH2 0x2354 234C 85 DUP6 234D 82 DUP3 234E 86 DUP7 234F 01 ADD 2350 61 PUSH2 0x2097 2353 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2349 stack[-1] = 0x2354 // @234C stack[0] = stack[-6] // @234F stack[1] = stack[-5] + stack[-2] // } // Block ends with call to 0x2097, returns to 0x2354 label_2354: // Incoming return from call to 0x2097 at 0x2353 // Inputs[6] // { // @2355 stack[-1] // @2355 stack[-3] // @2358 stack[-6] // @235A stack[-7] // @235A stack[-4] // @235B stack[-5] // } 2354 5B JUMPDEST 2355 91 SWAP2 2356 50 POP 2357 50 POP 2358 92 SWAP3 2359 50 POP 235A 92 SWAP3 235B 90 SWAP1 235C 50 POP 235D 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @2358 stack[-6] = stack[-1] // @235A stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_235E: // Incoming call from 0x01EE, returns to 0x01EF // Inputs[2] // { // @2364 stack[-1] // @2365 stack[-2] // } 235E 5B JUMPDEST 235F 60 PUSH1 0x00 2361 80 DUP1 2362 60 PUSH1 0x40 2364 83 DUP4 2365 85 DUP6 2366 03 SUB 2367 12 SLT 2368 15 ISZERO 2369 61 PUSH2 0x2370 236C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @235F stack[0] = 0x00 // @2361 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2370, if !(stack[-2] - stack[-1] i< 0x40) label_236D: // Incoming jump from 0x236C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @236D stack[-2] // @236F memory[stack[-2]:stack[-2] + stack[-2]] // } 236D 81 DUP2 236E 82 DUP3 236F FD *REVERT // Stack delta = +0 // Outputs[1] { @236F revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2370: // Incoming jump from 0x236C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2371 stack[-3] // @2372 msg.data[stack[-3]:stack[-3] + 0x20] // } 2370 5B JUMPDEST 2371 82 DUP3 2372 35 CALLDATALOAD 2373 67 PUSH8 0xffffffffffffffff 237C 81 DUP2 237D 11 GT 237E 15 ISZERO 237F 61 PUSH2 0x2386 2382 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2372 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x2386, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_2383: // Incoming jump from 0x2382, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2383 stack[-3] // @2385 memory[stack[-3]:stack[-3] + stack[-3]] // } 2383 82 DUP3 2384 83 DUP4 2385 FD *REVERT // Stack delta = +0 // Outputs[1] { @2385 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_2386: // Incoming jump from 0x2382, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @238A stack[-5] // @238B stack[-1] // @238C stack[-4] // } 2386 5B JUMPDEST 2387 61 PUSH2 0x2392 238A 85 DUP6 238B 82 DUP3 238C 86 DUP7 238D 01 ADD 238E 61 PUSH2 0x201a 2391 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2387 stack[0] = 0x2392 // @238A stack[1] = stack[-5] // @238D stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x201a, returns to 0x2392 label_2392: // Incoming return from call to 0x201A at 0x2391 // Inputs[4] // { // @2393 stack[-1] // @2393 stack[-4] // @2398 stack[-5] // @239A msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 2392 5B JUMPDEST 2393 92 SWAP3 2394 50 POP 2395 50 POP 2396 60 PUSH1 0x20 2398 83 DUP4 2399 01 ADD 239A 35 CALLDATALOAD 239B 60 PUSH1 0xff 239D 81 DUP2 239E 16 AND 239F 81 DUP2 23A0 14 EQ 23A1 61 PUSH2 0x2182 23A4 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @2393 stack[-4] = stack[-1] // @239A stack[-2] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2182, if msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] == msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] & 0xff label_23A5: // Incoming jump from 0x23A4, if not msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] == msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] & 0xff // Inputs[2] // { // @23A5 stack[-2] // @23A7 memory[stack[-2]:stack[-2] + stack[-2]] // } 23A5 81 DUP2 23A6 82 DUP3 23A7 FD *REVERT // Stack delta = +0 // Outputs[1] { @23A7 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_23A8: // Incoming call from 0x02AE, returns to 0x02AF // Inputs[2] // { // @23AD stack[-1] // @23AE stack[-2] // } 23A8 5B JUMPDEST 23A9 60 PUSH1 0x00 23AB 60 PUSH1 0x20 23AD 82 DUP3 23AE 84 DUP5 23AF 03 SUB 23B0 12 SLT 23B1 15 ISZERO 23B2 61 PUSH2 0x23b9 23B5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @23A9 stack[0] = 0x00 } // Block ends with conditional jump to 0x23b9, if !(stack[-2] - stack[-1] i< 0x20) label_23B6: // Incoming jump from 0x23B5, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @23B6 stack[-1] // @23B8 memory[stack[-1]:stack[-1] + stack[-1]] // } 23B6 80 DUP1 23B7 81 DUP2 23B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @23B8 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_23B9: // Incoming jump from 0x23B5, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @23BD stack[-2] } 23B9 5B JUMPDEST 23BA 61 PUSH2 0x2132 23BD 82 DUP3 23BE 61 PUSH2 0x20fe 23C1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23BA stack[0] = 0x2132 // @23BD stack[1] = stack[-2] // } // Block ends with call to 0x20fe, returns to 0x2132 label_23C2: // Incoming call from 0x01A3, returns to 0x01A4 // Inputs[2] // { // @23C7 stack[-1] // @23C8 stack[-2] // } 23C2 5B JUMPDEST 23C3 60 PUSH1 0x00 23C5 60 PUSH1 0x20 23C7 82 DUP3 23C8 84 DUP5 23C9 03 SUB 23CA 12 SLT 23CB 15 ISZERO 23CC 61 PUSH2 0x23d3 23CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @23C3 stack[0] = 0x00 } // Block ends with conditional jump to 0x23d3, if !(stack[-2] - stack[-1] i< 0x20) label_23D0: // Incoming jump from 0x23CF, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @23D0 stack[-1] // @23D2 memory[stack[-1]:stack[-1] + stack[-1]] // } 23D0 80 DUP1 23D1 81 DUP2 23D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @23D2 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_23D3: // Incoming jump from 0x23CF, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @23D4 stack[-2] // @23D5 msg.data[stack[-2]:stack[-2] + 0x20] // } 23D3 5B JUMPDEST 23D4 81 DUP2 23D5 35 CALLDATALOAD 23D6 61 PUSH2 0x2132 23D9 81 DUP2 23DA 61 PUSH2 0x2928 23DD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @23D5 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @23D6 stack[1] = 0x2132 // @23D9 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2928, returns to 0x2132 label_23DE: // Incoming jump from 0x1B8A // Inputs[2] // { // @23E3 stack[-1] // @23E4 stack[-2] // } 23DE 5B JUMPDEST 23DF 60 PUSH1 0x00 23E1 60 PUSH1 0x20 23E3 82 DUP3 23E4 84 DUP5 23E5 03 SUB 23E6 12 SLT 23E7 15 ISZERO 23E8 61 PUSH2 0x23ef 23EB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @23DF stack[0] = 0x00 } // Block ends with conditional jump to 0x23ef, if !(stack[-2] - stack[-1] i< 0x20) label_23EC: // Incoming jump from 0x23EB, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @23EC stack[-1] // @23EE memory[stack[-1]:stack[-1] + stack[-1]] // } 23EC 80 DUP1 23ED 81 DUP2 23EE FD *REVERT // Stack delta = +0 // Outputs[1] { @23EE revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_23EF: // Incoming jump from 0x23EB, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @23F0 stack[-2] // @23F1 memory[stack[-2]:stack[-2] + 0x20] // } 23EF 5B JUMPDEST 23F0 81 DUP2 23F1 51 MLOAD 23F2 61 PUSH2 0x2132 23F5 81 DUP2 23F6 61 PUSH2 0x2928 23F9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @23F1 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @23F2 stack[1] = 0x2132 // @23F5 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2928, returns to 0x2132 label_23FA: // Incoming jump from 0x0CD5 // Inputs[2] // { // @23FF stack[-1] // @2400 stack[-2] // } 23FA 5B JUMPDEST 23FB 60 PUSH1 0x00 23FD 60 PUSH1 0x20 23FF 82 DUP3 2400 84 DUP5 2401 03 SUB 2402 12 SLT 2403 15 ISZERO 2404 61 PUSH2 0x240b 2407 57 *JUMPI // Stack delta = +1 // Outputs[1] { @23FB stack[0] = 0x00 } // Block ends with conditional jump to 0x240b, if !(stack[-2] - stack[-1] i< 0x20) label_2408: // Incoming jump from 0x2407, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2408 stack[-1] // @240A memory[stack[-1]:stack[-1] + stack[-1]] // } 2408 80 DUP1 2409 81 DUP2 240A FD *REVERT // Stack delta = +0 // Outputs[1] { @240A revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_240B: // Incoming jump from 0x2407, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @240C stack[-2] // @240D memory[stack[-2]:stack[-2] + 0x20] // } 240B 5B JUMPDEST 240C 81 DUP2 240D 51 MLOAD 240E 61 PUSH2 0x2132 2411 81 DUP2 2412 61 PUSH2 0x2906 2415 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @240D stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @240E stack[1] = 0x2132 // @2411 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2906, returns to 0x2132 label_2416: // Incoming call from 0x023E, returns to 0x023F // Inputs[2] // { // @241B stack[-1] // @241C stack[-2] // } 2416 5B JUMPDEST 2417 60 PUSH1 0x00 2419 60 PUSH1 0x20 241B 82 DUP3 241C 84 DUP5 241D 03 SUB 241E 12 SLT 241F 15 ISZERO 2420 61 PUSH2 0x2427 2423 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2417 stack[0] = 0x00 } // Block ends with conditional jump to 0x2427, if !(stack[-2] - stack[-1] i< 0x20) label_2424: // Incoming jump from 0x2423, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2424 stack[-1] // @2426 memory[stack[-1]:stack[-1] + stack[-1]] // } 2424 80 DUP1 2425 81 DUP2 2426 FD *REVERT // Stack delta = +0 // Outputs[1] { @2426 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2427: // Incoming jump from 0x2423, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2428 stack[-2] // @2429 msg.data[stack[-2]:stack[-2] + 0x20] // } 2427 5B JUMPDEST 2428 81 DUP2 2429 35 CALLDATALOAD 242A 67 PUSH8 0xffffffffffffffff 2433 81 DUP2 2434 11 GT 2435 15 ISZERO 2436 61 PUSH2 0x243d 2439 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2429 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x243d, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_243A: // Incoming jump from 0x2439, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @243A stack[-2] // @243C memory[stack[-2]:stack[-2] + stack[-2]] // } 243A 81 DUP2 243B 82 DUP3 243C FD *REVERT // Stack delta = +0 // Outputs[1] { @243C revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_243D: // Incoming jump from 0x2439, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @243E stack[-3] // @243F stack[-1] // @2444 stack[-4] // } 243D 5B JUMPDEST 243E 82 DUP3 243F 01 ADD 2440 60 PUSH1 0x1f 2442 81 DUP2 2443 01 ADD 2444 84 DUP5 2445 13 SGT 2446 61 PUSH2 0x244d 2449 57 *JUMPI // Stack delta = +0 // Outputs[1] { @243F stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x244d, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_244A: // Incoming jump from 0x2449, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[2] // { // @244A stack[-2] // @244C memory[stack[-2]:stack[-2] + stack[-2]] // } 244A 81 DUP2 244B 82 DUP3 244C FD *REVERT // Stack delta = +0 // Outputs[1] { @244C revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_244D: // Incoming jump from 0x2449, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @2451 stack[-4] // @2452 stack[-1] // @2453 msg.data[stack[-1]:stack[-1] + 0x20] // } 244D 5B JUMPDEST 244E 61 PUSH2 0x0d34 2451 84 DUP5 2452 82 DUP3 2453 35 CALLDATALOAD 2454 60 PUSH1 0x20 2456 84 DUP5 2457 01 ADD 2458 61 PUSH2 0x1f9e 245B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @244E stack[0] = 0x0d34 // @2451 stack[1] = stack[-4] // @2453 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2457 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1f9e, returns to 0x0D34 label_245C: // Incoming call from 0x01DB, returns to 0x01DC // Inputs[2] // { // @2461 stack[-1] // @2462 stack[-2] // } 245C 5B JUMPDEST 245D 60 PUSH1 0x00 245F 60 PUSH1 0x20 2461 82 DUP3 2462 84 DUP5 2463 03 SUB 2464 12 SLT 2465 15 ISZERO 2466 61 PUSH2 0x246d 2469 57 *JUMPI // Stack delta = +1 // Outputs[1] { @245D stack[0] = 0x00 } // Block ends with conditional jump to 0x246d, if !(stack[-2] - stack[-1] i< 0x20) label_246A: // Incoming jump from 0x2469, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @246A stack[-1] // @246C memory[stack[-1]:stack[-1] + stack[-1]] // } 246A 80 DUP1 246B 81 DUP2 246C FD *REVERT // Stack delta = +0 // Outputs[1] { @246C revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_246D: // Incoming jump from 0x2469, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @246F msg.data[stack[-2]:stack[-2] + 0x20] // @246F stack[-2] // @2470 stack[-4] // @2471 stack[-3] // } 246D 5B JUMPDEST 246E 50 POP 246F 35 CALLDATALOAD 2470 91 SWAP2 2471 90 SWAP1 2472 50 POP 2473 56 *JUMP // Stack delta = -3 // Outputs[1] { @2470 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_2474: // Incoming call from 0x25F4, returns to 0x2132 // Inputs[3] // { // @2477 stack[-1] // @2478 memory[stack[-1]:stack[-1] + 0x20] // @247A stack[-2] // } 2474 5B JUMPDEST 2475 60 PUSH1 0x00 2477 81 DUP2 2478 51 MLOAD 2479 80 DUP1 247A 84 DUP5 247B 52 MSTORE 247C 60 PUSH1 0x20 247E 80 DUP1 247F 85 DUP6 2480 01 ADD 2481 94 SWAP5 2482 50 POP 2483 80 DUP1 2484 84 DUP5 2485 01 ADD 2486 83 DUP4 2487 5B JUMPDEST 2488 83 DUP4 2489 81 DUP2 248A 10 LT 248B 15 ISZERO 248C 61 PUSH2 0x24a3 248F 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @2475 stack[0] = 0x00 // @2478 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @247B memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @247C stack[2] = 0x20 // @2481 stack[-2] = stack[-2] + 0x20 // @2485 stack[3] = stack[-1] + 0x20 // @2486 stack[4] = 0x00 // } // Block ends with conditional jump to 0x24a3, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_2490: // Incoming jump from 0x248F, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x248F, if not !(stack[-1] < stack[-4]) // Inputs[5] // { // @2490 stack[-2] // @2491 memory[stack[-2]:stack[-2] + 0x20] // @2492 stack[-7] // @2494 stack[-1] // @2495 stack[-3] // } 2490 81 DUP2 2491 51 MLOAD 2492 87 DUP8 2493 52 MSTORE 2494 95 SWAP6 2495 82 DUP3 2496 01 ADD 2497 95 SWAP6 2498 90 SWAP1 2499 82 DUP3 249A 01 ADD 249B 90 SWAP1 249C 60 PUSH1 0x01 249E 01 ADD 249F 61 PUSH2 0x2487 24A2 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2493 memory[stack[-7]:stack[-7] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @2497 stack[-7] = stack[-3] + stack[-7] // @249B stack[-2] = stack[-3] + stack[-2] // @249E stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2487 label_24A3: // Incoming jump from 0x248F, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x248F, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @24A5 stack[-2] // @24A5 stack[-7] // @24A6 stack[-8] // } 24A3 5B JUMPDEST 24A4 50 POP 24A5 94 SWAP5 24A6 95 SWAP6 24A7 94 SWAP5 24A8 50 POP 24A9 50 POP 24AA 50 POP 24AB 50 POP 24AC 50 POP 24AD 56 *JUMP // Stack delta = -7 // Outputs[1] { @24A6 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_24AE: // Incoming call from 0x2635, returns to 0x2132 // Incoming call from 0x25D6, returns to 0x25D7 // Inputs[3] // { // @24B1 stack[-1] // @24B2 memory[stack[-1]:stack[-1] + 0x20] // @24B4 stack[-2] // } 24AE 5B JUMPDEST 24AF 60 PUSH1 0x00 24B1 81 DUP2 24B2 51 MLOAD 24B3 80 DUP1 24B4 84 DUP5 24B5 52 MSTORE 24B6 61 PUSH2 0x24c6 24B9 81 DUP2 24BA 60 PUSH1 0x20 24BC 86 DUP7 24BD 01 ADD 24BE 60 PUSH1 0x20 24C0 86 DUP7 24C1 01 ADD 24C2 61 PUSH2 0x269d 24C5 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @24AF stack[0] = 0x00 // @24B2 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @24B5 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @24B6 stack[2] = 0x24c6 // @24B9 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @24BD stack[4] = stack[-2] + 0x20 // @24C1 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x269d, returns to 0x24C6 label_24C6: // Incoming return from call to 0x269D at 0x24C5 // Inputs[4] // { // @24C9 stack[-1] // @24EC stack[-4] // @24ED stack[-2] // @24F3 stack[-5] // } 24C6 5B JUMPDEST 24C7 60 PUSH1 0x1f 24C9 01 ADD 24CA 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 24EB 16 AND 24EC 92 SWAP3 24ED 90 SWAP1 24EE 92 SWAP3 24EF 01 ADD 24F0 60 PUSH1 0x20 24F2 01 ADD 24F3 92 SWAP3 24F4 91 SWAP2 24F5 50 POP 24F6 50 POP 24F7 56 *JUMP // Stack delta = -4 // Outputs[1] { @24F3 stack[-5] = 0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_24F8: // Incoming call from 0x0567, returns to 0x0568 // Inputs[3] // { // @24FB stack[-3] // @24FC memory[stack[-3]:stack[-3] + 0x20] // @2501 stack[-1] // } 24F8 5B JUMPDEST 24F9 60 PUSH1 0x00 24FB 83 DUP4 24FC 51 MLOAD 24FD 61 PUSH2 0x250a 2500 81 DUP2 2501 84 DUP5 2502 60 PUSH1 0x20 2504 88 DUP9 2505 01 ADD 2506 61 PUSH2 0x269d 2509 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @24F9 stack[0] = 0x00 // @24FC stack[1] = memory[stack[-3]:stack[-3] + 0x20] // @24FD stack[2] = 0x250a // @2500 stack[3] = memory[stack[-3]:stack[-3] + 0x20] // @2501 stack[4] = stack[-1] // @2505 stack[5] = stack[-3] + 0x20 // } // Block ends with call to 0x269d, returns to 0x250A label_250A: // Incoming return from call to 0x269D at 0x2509 // Inputs[4] // { // @250B stack[-4] // @250C memory[stack[-4]:stack[-4] + 0x20] // @250D stack[-1] // @250E stack[-3] // } 250A 5B JUMPDEST 250B 83 DUP4 250C 51 MLOAD 250D 90 SWAP1 250E 83 DUP4 250F 01 ADD 2510 90 SWAP1 2511 61 PUSH2 0x251e 2514 81 DUP2 2515 83 DUP4 2516 60 PUSH1 0x20 2518 88 DUP9 2519 01 ADD 251A 61 PUSH2 0x269d 251D 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @2510 stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @2510 stack[-1] = stack[-3] + stack[-1] // @2511 stack[1] = 0x251e // @2514 stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @2515 stack[3] = stack[-3] + stack[-1] // @2519 stack[4] = stack[-4] + 0x20 // } // Block ends with call to 0x269d, returns to 0x251E label_251E: // Incoming return from call to 0x269D at 0x251D // Inputs[4] // { // @251F stack[-2] // @251F stack[-1] // @2520 stack[-7] // @2521 stack[-6] // } 251E 5B JUMPDEST 251F 01 ADD 2520 94 SWAP5 2521 93 SWAP4 2522 50 POP 2523 50 POP 2524 50 POP 2525 50 POP 2526 56 *JUMP // Stack delta = -6 // Outputs[1] { @2520 stack[-7] = stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-7] 2527 5B JUMPDEST 2528 60 PUSH1 0x00 252A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 253F 80 DUP1 2540 88 DUP9 2541 16 AND 2542 83 DUP4 2543 52 MSTORE 2544 80 DUP1 2545 87 DUP8 2546 16 AND 2547 60 PUSH1 0x20 2549 84 DUP5 254A 01 ADD 254B 52 MSTORE 254C 50 POP 254D 60 PUSH1 0xa0 254F 60 PUSH1 0x40 2551 83 DUP4 2552 01 ADD 2553 52 MSTORE 2554 61 PUSH2 0x2560 2557 60 PUSH1 0xa0 2559 83 DUP4 255A 01 ADD 255B 86 DUP7 255C 61 PUSH2 0x2474 255F 56 *JUMP 2560 5B JUMPDEST 2561 82 DUP3 2562 81 DUP2 2563 03 SUB 2564 60 PUSH1 0x60 2566 84 DUP5 2567 01 ADD 2568 52 MSTORE 2569 61 PUSH2 0x2572 256C 81 DUP2 256D 86 DUP7 256E 61 PUSH2 0x2474 2571 56 *JUMP 2572 5B JUMPDEST 2573 90 SWAP1 2574 50 POP 2575 82 DUP3 2576 81 DUP2 2577 03 SUB 2578 60 PUSH1 0x80 257A 84 DUP5 257B 01 ADD 257C 52 MSTORE 257D 61 PUSH2 0x2586 2580 81 DUP2 2581 85 DUP6 2582 61 PUSH2 0x24ae 2585 56 *JUMP 2586 5B JUMPDEST 2587 98 SWAP9 2588 97 SWAP8 2589 50 POP 258A 50 POP 258B 50 POP 258C 50 POP 258D 50 POP 258E 50 POP 258F 50 POP 2590 50 POP 2591 56 *JUMP label_2592: // Incoming call from 0x1B25, returns to 0x1B26 // Inputs[6] // { // @25AB stack[-6] // @25AD stack[-1] // @25B0 stack[-5] // @25B8 stack[-4] // @25BE stack[-3] // @25D2 stack[-2] // } 2592 5B JUMPDEST 2593 60 PUSH1 0x00 2595 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25AA 80 DUP1 25AB 88 DUP9 25AC 16 AND 25AD 83 DUP4 25AE 52 MSTORE 25AF 80 DUP1 25B0 87 DUP8 25B1 16 AND 25B2 60 PUSH1 0x20 25B4 84 DUP5 25B5 01 ADD 25B6 52 MSTORE 25B7 50 POP 25B8 84 DUP5 25B9 60 PUSH1 0x40 25BB 83 DUP4 25BC 01 ADD 25BD 52 MSTORE 25BE 83 DUP4 25BF 60 PUSH1 0x60 25C1 83 DUP4 25C2 01 ADD 25C3 52 MSTORE 25C4 60 PUSH1 0xa0 25C6 60 PUSH1 0x80 25C8 83 DUP4 25C9 01 ADD 25CA 52 MSTORE 25CB 61 PUSH2 0x25d7 25CE 60 PUSH1 0xa0 25D0 83 DUP4 25D1 01 ADD 25D2 84 DUP5 25D3 61 PUSH2 0x24ae 25D6 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @2593 stack[0] = 0x00 // @25AE memory[stack[-1]:stack[-1] + 0x20] = stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // @25B6 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff // @25BD memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-4] // @25C3 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = stack[-3] // @25CA memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] = 0xa0 // @25CB stack[1] = 0x25d7 // @25D1 stack[2] = stack[-1] + 0xa0 // @25D2 stack[3] = stack[-2] // } // Block ends with call to 0x24ae, returns to 0x25D7 label_25D7: // Incoming return from call to 0x24AE at 0x25D6 // Inputs[3] // { // @25D8 stack[-9] // @25D8 stack[-1] // @25D9 stack[-8] // } 25D7 5B JUMPDEST 25D8 97 SWAP8 25D9 96 SWAP7 25DA 50 POP 25DB 50 POP 25DC 50 POP 25DD 50 POP 25DE 50 POP 25DF 50 POP 25E0 50 POP 25E1 56 *JUMP // Stack delta = -8 // Outputs[1] { @25D8 stack[-9] = stack[-1] } // Block ends with unconditional jump to stack[-9] label_25E2: // Incoming jump from 0x0230 // Inputs[2] // { // @25E5 stack[-1] // @25F0 stack[-2] // } 25E2 5B JUMPDEST 25E3 60 PUSH1 0x20 25E5 81 DUP2 25E6 52 MSTORE 25E7 60 PUSH1 0x00 25E9 61 PUSH2 0x2132 25EC 60 PUSH1 0x20 25EE 83 DUP4 25EF 01 ADD 25F0 84 DUP5 25F1 61 PUSH2 0x2474 25F4 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @25E6 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @25E7 stack[0] = 0x00 // @25E9 stack[1] = 0x2132 // @25EF stack[2] = stack[-1] + 0x20 // @25F0 stack[3] = stack[-2] // } // Block ends with call to 0x2474, returns to 0x2132 25F5 5B JUMPDEST 25F6 60 PUSH1 0x40 25F8 81 DUP2 25F9 52 MSTORE 25FA 60 PUSH1 0x00 25FC 61 PUSH2 0x2608 25FF 60 PUSH1 0x40 2601 83 DUP4 2602 01 ADD 2603 85 DUP6 2604 61 PUSH2 0x2474 2607 56 *JUMP 2608 5B JUMPDEST 2609 82 DUP3 260A 81 DUP2 260B 03 SUB 260C 60 PUSH1 0x20 260E 84 DUP5 260F 01 ADD 2610 52 MSTORE 2611 61 PUSH2 0x261a 2614 81 DUP2 2615 85 DUP6 2616 61 PUSH2 0x2474 2619 56 *JUMP 261A 5B JUMPDEST 261B 95 SWAP6 261C 94 SWAP5 261D 50 POP 261E 50 POP 261F 50 POP 2620 50 POP 2621 50 POP 2622 56 *JUMP label_2623: // Incoming jump from 0x01CD // Incoming jump from 0x1BED // Inputs[2] // { // @2626 stack[-1] // @2631 stack[-2] // } 2623 5B JUMPDEST 2624 60 PUSH1 0x20 2626 81 DUP2 2627 52 MSTORE 2628 60 PUSH1 0x00 262A 61 PUSH2 0x2132 262D 60 PUSH1 0x20 262F 83 DUP4 2630 01 ADD 2631 84 DUP5 2632 61 PUSH2 0x24ae 2635 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2627 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2628 stack[0] = 0x00 // @262A stack[1] = 0x2132 // @2630 stack[2] = stack[-1] + 0x20 // @2631 stack[3] = stack[-2] // } // Block ends with call to 0x24ae, returns to 0x2132 label_2636: // Incoming call from 0x2036, returns to 0x2037 // Incoming call from 0x20B3, returns to 0x20B4 // Inputs[1] { @2642 stack[-1] } 2636 5B JUMPDEST 2637 60 PUSH1 0x00 2639 67 PUSH8 0xffffffffffffffff 2642 82 DUP3 2643 11 GT 2644 15 ISZERO 2645 61 PUSH2 0x2650 2648 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2637 stack[0] = 0x00 } // Block ends with conditional jump to 0x2650, if !(stack[-1] > 0xffffffffffffffff) label_2649: // Incoming jump from 0x2648, if not !(stack[-1] > 0xffffffffffffffff) 2649 61 PUSH2 0x2650 264C 61 PUSH2 0x2817 264F 56 *JUMP // Stack delta = +1 // Outputs[1] { @2649 stack[0] = 0x2650 } // Block ends with unconditional jump to 0x2817 label_2650: // Incoming jump from 0x2648, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @2654 stack[-2] // @2658 stack[-3] // } 2650 5B JUMPDEST 2651 50 POP 2652 60 PUSH1 0x05 2654 1B SHL 2655 60 PUSH1 0x20 2657 01 ADD 2658 90 SWAP1 2659 56 *JUMP // Stack delta = -2 // Outputs[1] { @2658 stack[-3] = 0x20 + (stack[-2] << 0x05) } // Block ends with unconditional jump to stack[-3] label_265A: // Incoming call from 0x072C, returns to 0x072D // Incoming call from 0x1238, returns to 0x1239 // Incoming call from 0x0611, returns to 0x0612 // Incoming call from 0x10C1, returns to 0x10C2 // Inputs[2] // { // @265D stack[-2] // @265F stack[-1] // } 265A 5B JUMPDEST 265B 60 PUSH1 0x00 265D 82 DUP3 265E 19 NOT 265F 82 DUP3 2660 11 GT 2661 15 ISZERO 2662 61 PUSH2 0x266d 2665 57 *JUMPI // Stack delta = +1 // Outputs[1] { @265B stack[0] = 0x00 } // Block ends with conditional jump to 0x266d, if !(stack[-1] > ~stack[-2]) label_2666: // Incoming jump from 0x2665, if not !(stack[-1] > ~stack[-2]) 2666 61 PUSH2 0x266d 2669 61 PUSH2 0x27b9 266C 56 *JUMP // Stack delta = +1 // Outputs[1] { @2666 stack[0] = 0x266d } // Block ends with unconditional jump to 0x27b9 label_266D: // Incoming jump from 0x2665, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @266F stack[-2] // @266F stack[-3] // @2670 stack[-4] // } 266D 5B JUMPDEST 266E 50 POP 266F 01 ADD 2670 90 SWAP1 2671 56 *JUMP // Stack delta = -3 // Outputs[1] { @2670 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_2672: // Incoming call from 0x1137, returns to 0x1138 // Incoming call from 0x1021, returns to 0x1022 // Inputs[1] { @2675 stack[-2] } 2672 5B JUMPDEST 2673 60 PUSH1 0x00 2675 82 DUP3 2676 61 PUSH2 0x2681 2679 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2673 stack[0] = 0x00 } // Block ends with conditional jump to 0x2681, if stack[-2] label_267A: // Incoming jump from 0x2679, if not stack[-2] 267A 61 PUSH2 0x2681 267D 61 PUSH2 0x27e8 2680 56 *JUMP // Stack delta = +1 // Outputs[1] { @267A stack[0] = 0x2681 } // Block ends with unconditional jump to 0x27e8 label_2681: // Incoming jump from 0x2679, if stack[-2] // Inputs[3] // { // @2683 stack[-2] // @2683 stack[-3] // @2684 stack[-4] // } 2681 5B JUMPDEST 2682 50 POP 2683 04 DIV 2684 90 SWAP1 2685 56 *JUMP // Stack delta = -3 // Outputs[1] { @2684 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_2686: // Incoming call from 0x10A9, returns to 0x10AA // Inputs[2] // { // @2689 stack[-2] // @268A stack[-1] // } 2686 5B JUMPDEST 2687 60 PUSH1 0x00 2689 82 DUP3 268A 82 DUP3 268B 10 LT 268C 15 ISZERO 268D 61 PUSH2 0x2698 2690 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2687 stack[0] = 0x00 } // Block ends with conditional jump to 0x2698, if !(stack[-1] < stack[-2]) label_2691: // Incoming jump from 0x2690, if not !(stack[-1] < stack[-2]) 2691 61 PUSH2 0x2698 2694 61 PUSH2 0x27b9 2697 56 *JUMP // Stack delta = +1 // Outputs[1] { @2691 stack[0] = 0x2698 } // Block ends with unconditional jump to 0x27b9 label_2698: // Incoming jump from 0x2690, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @269A stack[-3] // @269A stack[-2] // @269B stack[-4] // } 2698 5B JUMPDEST 2699 50 POP 269A 03 SUB 269B 90 SWAP1 269C 56 *JUMP // Stack delta = -3 // Outputs[1] { @269B stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_269D: // Incoming call from 0x251D, returns to 0x251E // Incoming call from 0x2509, returns to 0x250A // Incoming call from 0x24C5, returns to 0x24C6 // Inputs[1] { @26A1 stack[-3] } 269D 5B JUMPDEST 269E 60 PUSH1 0x00 26A0 5B JUMPDEST 26A1 83 DUP4 26A2 81 DUP2 26A3 10 LT 26A4 15 ISZERO 26A5 61 PUSH2 0x26b8 26A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @269E stack[0] = 0x00 } // Block ends with conditional jump to 0x26b8, if !(0x00 < stack[-3]) label_26A9: // Incoming jump from 0x26A8, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x26A8, if not !(0x00 < stack[-3]) // Inputs[4] // { // @26A9 stack[-2] // @26AA stack[-1] // @26AC memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @26AD stack[-3] // } 26A9 81 DUP2 26AA 81 DUP2 26AB 01 ADD 26AC 51 MLOAD 26AD 83 DUP4 26AE 82 DUP3 26AF 01 ADD 26B0 52 MSTORE 26B1 60 PUSH1 0x20 26B3 01 ADD 26B4 61 PUSH2 0x26a0 26B7 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @26B0 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @26B3 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x26a0 label_26B8: // Incoming jump from 0x26A8, if !(stack[-1] < stack[-4]) // Incoming jump from 0x26A8, if !(0x00 < stack[-3]) // Inputs[2] // { // @26B9 stack[-4] // @26BA stack[-1] // } 26B8 5B JUMPDEST 26B9 83 DUP4 26BA 81 DUP2 26BB 11 GT 26BC 15 ISZERO 26BD 61 PUSH2 0x26c7 26C0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x26c7, if !(stack[-1] > stack[-4]) label_26C1: // Incoming jump from 0x26C0, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @26C3 stack[-4] // @26C4 stack[-3] // @26CC stack[-5] // } 26C1 60 PUSH1 0x00 26C3 84 DUP5 26C4 84 DUP5 26C5 01 ADD 26C6 52 MSTORE 26C7 5B JUMPDEST 26C8 50 POP 26C9 50 POP 26CA 50 POP 26CB 50 POP 26CC 56 *JUMP // Stack delta = -5 // Outputs[1] { @26C6 memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_26CD: // Incoming call from 0x04BC, returns to 0x04BD // Incoming call from 0x0B17, returns to 0x04BD // Incoming call from 0x0F65, returns to 0x0F66 // Incoming call from 0x1F10, returns to 0x1F11 // Incoming call from 0x04E8, returns to 0x04E9 // Incoming call from 0x0F39, returns to 0x0F3A // Inputs[1] { @26D0 stack[-1] } 26CD 5B JUMPDEST 26CE 60 PUSH1 0x01 26D0 81 DUP2 26D1 81 DUP2 26D2 1C SHR 26D3 90 SWAP1 26D4 82 DUP3 26D5 16 AND 26D6 80 DUP1 26D7 61 PUSH2 0x26e1 26DA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @26D3 stack[0] = stack[-1] >> 0x01 // @26D5 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x26e1, if stack[-1] & 0x01 label_26DB: // Incoming jump from 0x26DA, if not stack[-1] & 0x01 // Inputs[2] // { // @26DD stack[-2] // @26E6 stack[-1] // } 26DB 60 PUSH1 0x7f 26DD 82 DUP3 26DE 16 AND 26DF 91 SWAP2 26E0 50 POP 26E1 5B JUMPDEST 26E2 60 PUSH1 0x20 26E4 82 DUP3 26E5 10 LT 26E6 81 DUP2 26E7 14 EQ 26E8 15 ISZERO 26E9 61 PUSH2 0x271b 26EC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @26DF stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x271b, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_26ED: // Incoming jump from 0x26EC, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x26EC, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @271A memory[0x00:0x24] } 26ED 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 270E 60 PUSH1 0x00 2710 52 MSTORE 2711 60 PUSH1 0x22 2713 60 PUSH1 0x04 2715 52 MSTORE 2716 60 PUSH1 0x24 2718 60 PUSH1 0x00 271A FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2710 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @2715 memory[0x04:0x24] = 0x22 // @271A revert(memory[0x00:0x24]); // } // Block terminates label_271B: // Incoming jump from 0x26EC, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x26EC, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @271D stack[-4] // @271D stack[-2] // @271E stack[-3] // } 271B 5B JUMPDEST 271C 50 POP 271D 91 SWAP2 271E 90 SWAP1 271F 50 POP 2720 56 *JUMP // Stack delta = -3 // Outputs[1] { @271D stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2721: // Incoming call from 0x1FEC, returns to 0x1FED // Incoming call from 0x28FA, returns to 0x28FB // Incoming call from 0x20C0, returns to 0x20C1 // Incoming call from 0x2043, returns to 0x2044 // Inputs[2] // { // @2745 stack[-2] // @2748 stack[-1] // } 2721 5B JUMPDEST 2722 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 2743 60 PUSH1 0x1f 2745 83 DUP4 2746 01 ADD 2747 16 AND 2748 81 DUP2 2749 01 ADD 274A 81 DUP2 274B 81 DUP2 274C 10 LT 274D 67 PUSH8 0xffffffffffffffff 2756 82 DUP3 2757 11 GT 2758 17 OR 2759 15 ISZERO 275A 61 PUSH2 0x2765 275D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2749 stack[0] = stack[-1] + (stack[-2] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) } // Block ends with conditional jump to 0x2765, if !((stack[-1] + (stack[-2] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < stack[-1])) label_275E: // Incoming jump from 0x275D, if not !((stack[-1] + (stack[-2] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < stack[-1])) 275E 61 PUSH2 0x2765 2761 61 PUSH2 0x2817 2764 56 *JUMP // Stack delta = +1 // Outputs[1] { @275E stack[0] = 0x2765 } // Block ends with unconditional jump to 0x2817 label_2765: // Incoming jump from 0x275D, if !((stack[-1] + (stack[-2] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < stack[-1])) // Inputs[2] // { // @2768 stack[-1] // @276B stack[-4] // } 2765 5B JUMPDEST 2766 60 PUSH1 0x40 2768 52 MSTORE 2769 50 POP 276A 50 POP 276B 56 *JUMP // Stack delta = -4 // Outputs[1] { @2768 memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_276C: // Incoming call from 0x09E1, returns to 0x09E2 // Incoming call from 0x1012, returns to 0x1013 // Inputs[1] { @2790 stack[-1] } 276C 5B JUMPDEST 276D 60 PUSH1 0x00 276F 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2790 82 DUP3 2791 14 EQ 2792 15 ISZERO 2793 61 PUSH2 0x279e 2796 57 *JUMPI // Stack delta = +1 // Outputs[1] { @276D stack[0] = 0x00 } // Block ends with conditional jump to 0x279e, if !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) label_2797: // Incoming jump from 0x2796, if not !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) 2797 61 PUSH2 0x279e 279A 61 PUSH2 0x27b9 279D 56 *JUMP // Stack delta = +1 // Outputs[1] { @2797 stack[0] = 0x279e } // Block ends with unconditional jump to 0x27b9 label_279E: // Incoming jump from 0x2796, if !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // Inputs[2] // { // @27A2 stack[-2] // @27A3 stack[-3] // } 279E 5B JUMPDEST 279F 50 POP 27A0 60 PUSH1 0x01 27A2 01 ADD 27A3 90 SWAP1 27A4 56 *JUMP // Stack delta = -2 // Outputs[1] { @27A3 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_27A5: // Incoming call from 0x10B6, returns to 0x10B7 // Inputs[1] { @27A8 stack[-2] } 27A5 5B JUMPDEST 27A6 60 PUSH1 0x00 27A8 82 DUP3 27A9 61 PUSH2 0x27b4 27AC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @27A6 stack[0] = 0x00 } // Block ends with conditional jump to 0x27b4, if stack[-2] label_27AD: // Incoming jump from 0x27AC, if not stack[-2] 27AD 61 PUSH2 0x27b4 27B0 61 PUSH2 0x27e8 27B3 56 *JUMP // Stack delta = +1 // Outputs[1] { @27AD stack[0] = 0x27b4 } // Block ends with unconditional jump to 0x27e8 label_27B4: // Incoming jump from 0x27AC, if stack[-2] // Inputs[3] // { // @27B6 stack[-3] // @27B6 stack[-2] // @27B7 stack[-4] // } 27B4 5B JUMPDEST 27B5 50 POP 27B6 06 MOD 27B7 90 SWAP1 27B8 56 *JUMP // Stack delta = -3 // Outputs[1] { @27B7 stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_27B9: // Incoming jump from 0x279D // Incoming jump from 0x2697 // Incoming jump from 0x266C // Inputs[1] { @27E7 memory[0x00:0x24] } 27B9 5B JUMPDEST 27BA 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 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] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @27E2 memory[0x04:0x24] = 0x11 // @27E7 revert(memory[0x00:0x24]); // } // Block terminates label_27E8: // Incoming jump from 0x27B3 // Incoming jump from 0x2680 // Inputs[1] { @2816 memory[0x00:0x24] } 27E8 5B JUMPDEST 27E9 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 280A 60 PUSH1 0x00 280C 52 MSTORE 280D 60 PUSH1 0x12 280F 60 PUSH1 0x04 2811 52 MSTORE 2812 60 PUSH1 0x24 2814 60 PUSH1 0x00 2816 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @280C memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @2811 memory[0x04:0x24] = 0x12 // @2816 revert(memory[0x00:0x24]); // } // Block terminates label_2817: // Incoming jump from 0x264F // Incoming jump from 0x1FB7 // Incoming jump from 0x2764 // Inputs[1] { @2845 memory[0x00:0x24] } 2817 5B JUMPDEST 2818 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 2839 60 PUSH1 0x00 283B 52 MSTORE 283C 60 PUSH1 0x41 283E 60 PUSH1 0x04 2840 52 MSTORE 2841 60 PUSH1 0x24 2843 60 PUSH1 0x00 2845 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @283B memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @2840 memory[0x04:0x24] = 0x41 // @2845 revert(memory[0x00:0x24]); // } // Block terminates label_2846: // Incoming call from 0x1B99, returns to 0x1B9A // Inputs[1] { @284B returndata.length } 2846 5B JUMPDEST 2847 60 PUSH1 0x00 2849 60 PUSH1 0x03 284B 3D RETURNDATASIZE 284C 11 GT 284D 15 ISZERO 284E 61 PUSH2 0x285b 2851 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2847 stack[0] = 0x00 } // Block ends with conditional jump to 0x285b, if !(returndata.length > 0x03) label_2852: // Incoming jump from 0x2851, if not !(returndata.length > 0x03) // Inputs[4] // { // @2854 stack[-1] // @2856 returndata[stack[-1]:stack[-1] + 0x04] // @2857 memory[stack[-1]:stack[-1] + 0x20] // @285C stack[-2] // } 2852 60 PUSH1 0x04 2854 81 DUP2 2855 82 DUP3 2856 3E RETURNDATACOPY 2857 51 MLOAD 2858 60 PUSH1 0xe0 285A 1C SHR 285B 5B JUMPDEST 285C 90 SWAP1 285D 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2856 memory[stack[-1]:stack[-1] + 0x04] = returndata[stack[-1]:stack[-1] + 0x04] // @285C stack[-2] = memory[stack[-1]:stack[-1] + 0x20] >> 0xe0 // } // Block ends with unconditional jump to stack[-2] label_285E: // Incoming call from 0x1BAE, returns to 0x1BAF // Inputs[1] { @2863 returndata.length } 285E 5B JUMPDEST 285F 60 PUSH1 0x00 2861 60 PUSH1 0x44 2863 3D RETURNDATASIZE 2864 10 LT 2865 15 ISZERO 2866 61 PUSH2 0x286c 2869 57 *JUMPI // Stack delta = +1 // Outputs[1] { @285F stack[0] = 0x00 } // Block ends with conditional jump to 0x286c, if !(returndata.length < 0x44) label_286A: // Incoming jump from 0x2869, if not !(returndata.length < 0x44) // Inputs[2] // { // @286A stack[-2] // @286A stack[-1] // } 286A 90 SWAP1 286B 56 *JUMP // Stack delta = -1 // Outputs[1] { @286A stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_286C: // Incoming jump from 0x2869, if !(returndata.length < 0x44) // Inputs[5] // { // @286F memory[0x40:0x60] // @2892 returndata.length // @2897 returndata[0x04:0x04 + returndata.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc] // @2899 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @289A returndata.length // } 286C 5B JUMPDEST 286D 60 PUSH1 0x40 286F 51 MLOAD 2870 7F PUSH32 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc 2891 80 DUP1 2892 3D RETURNDATASIZE 2893 01 ADD 2894 60 PUSH1 0x04 2896 83 DUP4 2897 3E RETURNDATACOPY 2898 81 DUP2 2899 51 MLOAD 289A 3D RETURNDATASIZE 289B 67 PUSH8 0xffffffffffffffff 28A4 81 DUP2 28A5 60 PUSH1 0x24 28A7 84 DUP5 28A8 01 ADD 28A9 11 GT 28AA 81 DUP2 28AB 84 DUP5 28AC 11 GT 28AD 17 OR 28AE 15 ISZERO 28AF 61 PUSH2 0x28ba 28B2 57 *JUMPI // Stack delta = +5 // Outputs[6] // { // @286F stack[0] = memory[0x40:0x60] // @2870 stack[1] = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc // @2897 memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc] = returndata[0x04:0x04 + returndata.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc] // @2899 stack[2] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @289A stack[3] = returndata.length // @289B stack[4] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x28ba, if !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) label_28B3: // Incoming jump from 0x28B2, if not !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) // Inputs[2] // { // @28B8 stack[-7] // @28B8 stack[-6] // } 28B3 50 POP 28B4 50 POP 28B5 50 POP 28B6 50 POP 28B7 50 POP 28B8 90 SWAP1 28B9 56 *JUMP // Stack delta = -6 // Outputs[1] { @28B8 stack[-7] = stack[-6] } // Block ends with unconditional jump to stack[-7] label_28BA: // Incoming jump from 0x28B2, if !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) // Inputs[5] // { // @28BB stack[-3] // @28BC stack[-5] // @28BE stack[-2] // @28C1 memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] // @28C2 stack[-1] // } 28BA 5B JUMPDEST 28BB 82 DUP3 28BC 85 DUP6 28BD 01 ADD 28BE 91 SWAP2 28BF 50 POP 28C0 81 DUP2 28C1 51 MLOAD 28C2 81 DUP2 28C3 81 DUP2 28C4 11 GT 28C5 15 ISZERO 28C6 61 PUSH2 0x28d2 28C9 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @28BE stack[-2] = stack[-5] + stack[-3] // @28C1 stack[0] = memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] // } // Block ends with conditional jump to 0x28d2, if !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) label_28CA: // Incoming jump from 0x28C9, if not !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) // Inputs[2] // { // @28D0 stack[-8] // @28D0 stack[-7] // } 28CA 50 POP 28CB 50 POP 28CC 50 POP 28CD 50 POP 28CE 50 POP 28CF 50 POP 28D0 90 SWAP1 28D1 56 *JUMP // Stack delta = -7 // Outputs[1] { @28D0 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_28D2: // Incoming jump from 0x28C9, if !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) // Inputs[5] // { // @28D3 stack[-5] // @28D4 returndata.length // @28D5 stack[-6] // @28DA stack[-1] // @28DB stack[-3] // } 28D2 5B JUMPDEST 28D3 84 DUP5 28D4 3D RETURNDATASIZE 28D5 87 DUP8 28D6 01 ADD 28D7 01 ADD 28D8 60 PUSH1 0x20 28DA 82 DUP3 28DB 85 DUP6 28DC 01 ADD 28DD 01 ADD 28DE 11 GT 28DF 15 ISZERO 28E0 61 PUSH2 0x28ec 28E3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x28ec, if !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) label_28E4: // Incoming jump from 0x28E3, if not !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) // Inputs[2] // { // @28EA stack[-7] // @28EA stack[-8] // } 28E4 50 POP 28E5 50 POP 28E6 50 POP 28E7 50 POP 28E8 50 POP 28E9 50 POP 28EA 90 SWAP1 28EB 56 *JUMP // Stack delta = -7 // Outputs[1] { @28EA stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_28EC: // Incoming jump from 0x28E3, if !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) // Inputs[3] // { // @28F2 stack[-1] // @28F3 stack[-4] // @28F6 stack[-6] // } 28EC 5B JUMPDEST 28ED 61 PUSH2 0x28fb 28F0 60 PUSH1 0x20 28F2 82 DUP3 28F3 86 DUP7 28F4 01 ADD 28F5 01 ADD 28F6 87 DUP8 28F7 61 PUSH2 0x2721 28FA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @28ED stack[0] = 0x28fb // @28F5 stack[1] = stack[-4] + stack[-1] + 0x20 // @28F6 stack[2] = stack[-6] // } // Block ends with call to 0x2721, returns to 0x28FB label_28FB: // Incoming return from call to 0x2721 at 0x28FA // Inputs[4] // { // @28FD stack[-2] // @28FD stack[-3] // @28FE stack[-8] // @28FF stack[-7] // } 28FB 5B JUMPDEST 28FC 50 POP 28FD 90 SWAP1 28FE 95 SWAP6 28FF 94 SWAP5 2900 50 POP 2901 50 POP 2902 50 POP 2903 50 POP 2904 50 POP 2905 56 *JUMP // Stack delta = -7 // Outputs[1] { @28FE stack[-8] = stack[-3] } // Block ends with unconditional jump to stack[-8] label_2906: // Incoming call from 0x21AE, returns to 0x21AF // Incoming call from 0x22EE, returns to 0x22EF // Incoming call from 0x2171, returns to 0x2172 // Incoming call from 0x2415, returns to 0x2132 // Incoming call from 0x21BE, returns to 0x21BF // Incoming call from 0x2268, returns to 0x2269 // Incoming call from 0x2154, returns to 0x2132 // Incoming call from 0x22BA, returns to 0x22BB // Incoming call from 0x2077, returns to 0x2078 // Incoming call from 0x2181, returns to 0x2182 // Incoming call from 0x2258, returns to 0x2259 // Inputs[1] { @291C stack[-1] } 2906 5B JUMPDEST 2907 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 291C 81 DUP2 291D 16 AND 291E 81 DUP2 291F 14 EQ 2920 61 PUSH2 0x0a7b 2923 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a7b, if stack[-1] == stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff label_2924: // Incoming jump from 0x2923, if not stack[-1] == stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @2927 memory[0x00:0x00] } 2924 60 PUSH1 0x00 2926 80 DUP1 2927 FD *REVERT // Stack delta = +0 // Outputs[1] { @2927 revert(memory[0x00:0x00]); } // Block terminates label_2928: // Incoming call from 0x23F9, returns to 0x2132 // Incoming call from 0x23DD, returns to 0x2132 // Inputs[1] { @294A stack[-1] } 2928 5B JUMPDEST 2929 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 294A 81 DUP2 294B 16 AND 294C 81 DUP2 294D 14 EQ 294E 61 PUSH2 0x0a7b 2951 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a7b, if stack[-1] == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_2952: // Incoming jump from 0x2951, if not stack[-1] == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @2955 memory[0x00:0x00] } 2952 60 PUSH1 0x00 2954 80 DUP1 2955 FD *REVERT // Stack delta = +0 // Outputs[1] { @2955 revert(memory[0x00:0x00]); } // Block terminates 2956 FE *ASSERT 2957 A2 LOG2 2958 64 PUSH5 0x6970667358 295E 22 22 295F 12 SLT 2960 20 SHA3 2961 4A 4A 2962 CA CA 2963 38 CODESIZE 2964 B8 B8 2965 20 SHA3 2966 C1 C1 2967 BE BE 2968 44 DIFFICULTY 2969 76 PUSH23 0xf2bf010931ce1c4f155d3830547aff66333b7ae89739ea 2981 64 PUSH5 0x736f6c6343 2987 00 *STOP 2988 08 ADDMOD 2989 04 DIV 298A 00 *STOP 298B 33 CALLER